tango-app-api-task 3.4.0-flag-2 → 3.4.1-activitylog-1

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-task",
-    "version": "3.4.0-flag-2",
+    "version": "3.4.1-activitylog-1",
     "description": "Task",
     "main": "index.js",
     "type": "module",

package/src/controllers/task.controller.js

@@ -176,13 +176,9 @@ export async function createUpdateTask( req, res ) {
           }, {} );
         }
 
-        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;
@@ -191,8 +187,8 @@ export async function createUpdateTask( req, res ) {
                 delete ans.answeroptionNumber;
               } );
               let compare = findDifferences( qn, question );
-              if ( Object.keys( compare ).length && ( compare?.answerType || compare?.answers || compare?.linkType || compare?.qname) ) {
-                questionList.questionEdit.push( { sectionName: ele.section, questions: [ { previous: qn ,new: question} ] } );
+              if ( Object.keys( compare ).length ) {
+                questionList.questionEdit.push( { sectionName: ele.section, questions: [ { previous: qn, new: question } ] } );
               }
             } else {
               let sectionIndex = questionList.questionDelete.findIndex( ( sec ) => sec.sectionName === ele.section );
@@ -273,6 +269,25 @@ export async function createUpdateTask( req, res ) {
         };
         await insertOpenSearchData( JSON.parse( process.env.OPENSEARCH ).traxActivityLog, logObj );
       }
+
+      if ( inputBody?.submitType == 'save' ) {
+        let logObj = {
+          client_id: inputBody.clientId,
+          createAt: new Date(),
+          sourceCheckList_id: inputBody._id,
+          checkListName: inputBody.checklistName,
+          fromCheckListName: '',
+          type: 'task',
+          action: 'draft',
+          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 );
@@ -659,14 +674,14 @@ export const validateUserv1 = async ( req, res ) => {
       {
         $project: {
           newEmail: { $toLower: '$email' },
-          isActive: 1,
+          // isActive: 1,
           clientId: 1,
         },
       },
       {
         $match: {
           newEmail: { $in: userEmailList },
-          isActive: true,
+          // isActive: true,
           clientId: { $ne: req.body.clientId },
         },
       },
@@ -707,7 +722,7 @@ export const validateUserv1 = async ( req, res ) => {
     let newStoreList = storeList.filter( ( ele ) => ele != null && !existsStore.includes( ele.toLowerCase() ) );
     if ( req.body.coverage == 'store' ) {
       assignDetails.forEach( ( item ) => {
-        let getStoreDetails = storeDetails.find( ( store ) => store.storeName.toLowerCase() == item.storeName.toLowerCase() );
+        let getStoreDetails = storeDetails.find( ( store ) => store.storeName.toLowerCase() == item.storeName.trim().toLowerCase() );
         if ( getStoreDetails ) {
           let storeUserDetails = userDetails.find( ( ele ) => ele.newEmail.toLowerCase() == item.userEmail.toLowerCase() );
           item._id = getStoreDetails._id;
@@ -728,6 +743,11 @@ export const validateUserv1 = async ( req, res ) => {
       } );
     }
 
+    newStoreList = [ ...new Set( newStoreList.map( ( item ) => item ) ) ];
+    newUserList = [ ...new Set( newUserList.map( ( item ) => item ) ) ];
+    existEmail = [ ...new Set( existEmail.map( ( item ) => item ) ) ];
+    inActiveStores = [ ...new Set( inActiveStores.map( ( item ) => item ) ) ];
+
     if ( ( newUserList.length || newStoreList.length || existEmail.length || inActiveStores.length ) && !req.body?.addUser ) {
       return res.sendError( { validate: false, user: newUserList, store: newStoreList, existEmail, inActiveStores, data: assignDetails }, 400 );
     }
@@ -1001,7 +1021,7 @@ export async function taskConfig( req, res ) {
     await checklistLogs.create( logInsertData );
 
     checklistDetails = await taskService.findOne( { _id: inputBody._id, isdeleted: false, client_id: inputBody.clientId } );
-
+    let oldPublish = checklistDetails.publish;
     if ( !checklistDetails ) {
       return res.sendError( 'No data found', 204 );
     }
@@ -1081,13 +1101,19 @@ export async function taskConfig( req, res ) {
       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' ];
+      let removedKeys = [ 'clientId', 'submitType', 'removedUsers', 'publish', 'assignedUsers', 'added', 'removed', 'publishDate', 'scheduleEndTimeISO', 'storeCount' ];
       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 differences = findObjectDifference( configDetails, checklistDetails );
+      if ( Object.keys( differences ).length || inputBody.added.length || req.body.removed?.user?.length || req.body.removed?.store?.length ) {
+        let showSchedule = false;
+        let scheduleKeys = [ 'scheduleDate', 'priorityType', 'scheduleEndTime' ];
+
+        if ( scheduleKeys.some( ( key ) => differences?.[key] ) ) {
+          showSchedule = true;
+        }
         let insertData = {
           client_id: inputBody.clientId,
           createAt: new Date(),
@@ -1095,7 +1121,7 @@ export async function taskConfig( req, res ) {
           checkListName: checklistDetails.checkListName,
           fromCheckListName: '',
           type: 'task',
-          action: 'updated',
+          action: inputBody.publish ? 'updated' : 'draft',
           storeName: '',
           store_id: '',
           createdByEmail: req.user.email,
@@ -1104,14 +1130,14 @@ export async function taskConfig( req, res ) {
           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 : '',
+                ...( showSchedule ) ? { scheduleDate: checklistDetails?.scheduleDate } :{},
+                time: showSchedule ? checklistDetails.scheduleEndTime : '',
+                priority: showSchedule ? 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 : '',
+                ...( showSchedule ) ? { scheduleDate: configDetails?.scheduleDate } :{},
+                time: showSchedule ? configDetails.scheduleEndTime : '',
+                priority: showSchedule ? configDetails?.priorityType : '',
               },
             },
             response: {
@@ -1123,35 +1149,36 @@ export async function taskConfig( req, res ) {
               ],
             },
             ...( differences?.approver ) ? { approver:
-           { previous: differences?.approver?.previous.map( ( item ) => item.name ).toString(),
-             new: differences?.approver?.new.map( ( item ) => item.name ).toString() },
+           { previous: checklistDetails?.approver.map( ( item ) => item.name ).toString(),
+             new: configDetails?.approver.map( ( item ) => item.name ).toString() },
             } : { approver: {} },
             owner: {},
             ...( inputBody.coverage == 'store' ) ? { storeAdded: inputBody.added } :{ storeAdded: [] },
-            ...( inputBody.coverage == 'store' ) ? { storeRemoved: inputBody.removed } :{ storeRemoved: [] },
+            ...( req.body.removed.store.length ) ? { storeRemoved: inputBody.removed.store } :{ storeRemoved: [] },
             ...( inputBody.coverage == 'user' ) ? { userAdded: inputBody.added } :{ userAdded: [] },
-            ...( inputBody.coverage == 'user' ) ? { userRemoved: inputBody.removed } :{ userRemoved: [] },
+            ...( req.body.removed.user.length ) ? { userRemoved: inputBody.removed.user } :{ 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 );
+      if ( inputBody.publish != oldPublish || inputBody?.publish ) {
+        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 ) {
@@ -1742,7 +1769,60 @@ export async function reinitiateTask( req, res ) {
         await taskProcessedService.insert( userTaskData );
       }
     }
+    let differences = findObjectDifference( req.body, taskDetails );
+    if ( Object.keys( differences ).length ) {
+      let showSchedule = false;
+      let scheduleKeys = [ 'scheduleDate', 'priorityType', 'scheduleEndTime' ];
+
+      if ( scheduleKeys.some( ( key ) => differences?.[key] ) ) {
+        showSchedule = true;
+      }
 
+      let insertData = {
+        client_id: taskDetails.client_id,
+        createAt: new Date(),
+        sourceCheckList_id: taskDetails._id,
+        checkListName: taskDetails.checkListName,
+        fromCheckListName: '',
+        type: 'task',
+        action: 'updated',
+        storeName: '',
+        store_id: '',
+        createdByEmail: req.user.email,
+        createdBy: req.user.userName,
+        coverage: taskDetails.coverage,
+        logDetails: {
+          schedule: {
+            previous: {
+              ...( showSchedule ) ? { scheduleDate: taskDetails?.scheduleDate } :{},
+              time: showSchedule ? taskDetails.scheduleEndTime : '',
+              priority: showSchedule ? taskDetails?.priorityType : '',
+            },
+            new: {
+              ...( showSchedule ) ? { scheduleDate: req.body?.scheduleDate } :{},
+              time: showSchedule ? req.body.scheduleEndTime : '',
+              priority: showSchedule ? req.body?.priorityType : '',
+            },
+          },
+          response: {
+            previous: [
+              ...( differences?.allowedStoreLocation && taskDetails.allowedStoreLocation ? [ 'Geo fencing' ] : [] ),
+            ],
+            new: [
+              ...( differences?.allowedStoreLocation && req.body.allowedStoreLocation ? [ 'Geo fencing' ] : [] ),
+            ],
+          },
+          approver: { previous: taskDetails?.approver.map( ( item ) => item.name ).toString(),
+            new: taskDetails?.approver.map( ( item ) => item.name ).toString() },
+          owner: {},
+          storeAdded: [],
+          storeRemoved: [],
+          userAdded: [],
+          userRemoved: [],
+        },
+      };
+      await insertOpenSearchData( JSON.parse( process.env.OPENSEARCH ).traxActivityLog, insertData );
+    }
     return res.sendSuccess( 'Task reinitaite SUccessfully' );
   } catch ( e ) {
     logger.error( { functionName: 'reinitiateTask', error: e } );
@@ -1906,7 +1986,6 @@ export async function createChecklistTask( req, res ) {
             section_id: inputBody.sectionId,
             qno: inputBody.qno,
             parentQuestion: inputBody.parentQuestion,
-            uniqueNo: inputBody.uniqueNo,
           },
           'upsert': {
             taskId: String( response?._id ),
@@ -1934,11 +2013,11 @@ export async function createChecklistTask( req, res ) {
         let logData= {
           'client_id': inputBody.clientId,
           'createAt': new Date(),
-          'sourceCheckList_id': taskDetails.sourceCheckList_id,
+          'sourceCheckList_id': response._id,
           'checkListName': inputBody.checkListName,
           'fromCheckListName': taskDetails.checkListName,
           'type': 'task',
-          'action': 'created',
+          'action': 'task_created',
           'store_id': storeDetails?.storeId?storeDetails.storeId:'',
           'storeName': inputBody?.storeName?inputBody?.storeName:'',
           'createdByEmail': req.user.email,
@@ -1956,6 +2035,7 @@ export async function createChecklistTask( req, res ) {
       return res.sendSuccess( 'Task created successfully' );
     }
   } catch ( e ) {
+    // console.log( 'e', e );
     logger.error( { functionName: 'createChecklistTask', error: e, message: req.body } );
     return res.sendError( e, 500 );
   }
@@ -1964,7 +2044,7 @@ export async function createChecklistTask( req, res ) {
 export async function createChecklistMultiTask( req, res ) {
   try {
     let inputBody = req.body;
-    console.log( inputBody );
+    // console.log( inputBody );
     let inputData= inputBody.coverage==='user'?inputBody.userEmail:inputBody.storeName;
     let userDetailList;
     for ( let user of inputData ) {
@@ -2152,11 +2232,11 @@ export async function createChecklistMultiTask( req, res ) {
           let logData= {
             'client_id': inputBody.clientId,
             'createAt': new Date(),
-            'sourceCheckList_id': taskDetails.sourceCheckList_id,
+            'sourceCheckList_id': response._id,
             'checkListName': inputBody.checkListName,
             'fromCheckListName': taskDetails.checkListName,
             'type': 'task',
-            'action': 'created',
+            'action': 'task_created',
             'store_id': storeDetails?.storeId?storeDetails.storeId:'',
             'storeName': originaldata?.storeName?originaldata?.storeName:'',
             'createdByEmail': req.user.email,
@@ -2190,7 +2270,7 @@ export async function approveTask( req, res ) {
     if ( req.body?.storeId?.length ) {
       query['store_id'] = { $in: req.body.storeId };
     }
-    let taskDetails = await taskProcessedService.find( query, { _id: 1, checklistStatus: 1, storeName: 1, store_id: 1, userEmail: 1 } );
+    let taskDetails = await taskProcessedService.find( query, { _id: 1, checklistStatus: 1, storeName: 1, store_id: 1, userEmail: 1, client_id: 1, coverage: 1, checkListName: 1 } );
     if ( !taskDetails.length ) {
       return res.sendError( 'No data found', 204 );
     }
@@ -2199,7 +2279,7 @@ export async function approveTask( req, res ) {
       let updateResponse = await taskProcessedService.updateMany( { _id: { $in: idList } }, { approvalStatus: true } );
       if ( updateResponse.modifiedCount || updateResponse.matchedCount ) {
         let inputstores = taskDetails.filter( ( data ) => data.checklistStatus == 'submit' );
-
+        let storeNames = inputstores.map( ( data ) => data.storeName );
         let params = {
           'payload': {
             sourceCheckList_id: req.body.sourceCheckList_id,
@@ -2212,8 +2292,6 @@ export async function approveTask( req, res ) {
             approvalStatus: true,
           },
         };
-
-
         const requestOptions = {
           method: 'POST',
           headers: {
@@ -2224,7 +2302,27 @@ export async function approveTask( req, res ) {
         let url = JSON.parse( process.env.LAMBDAURL );
 
         let searchResponse = await fetch( url.approveTask, requestOptions );
-
+        console.log( 'logData', logData );
+        let logData= {
+          'client_id': taskDetails[0].client_id,
+          'createAt': new Date(),
+          'sourceCheckList_id': req.body.sourceCheckList_id,
+          'checkListName': taskDetails[0].checkListName,
+          'fromCheckListName': taskDetails[0].checkListName,
+          'type': 'checklist',
+          'action': 'approved',
+          'storeName': '',
+          'store_id': '',
+          'createdByEmail': req.user.email,
+          'createdBy': req.user._id,
+          'coverage': taskDetails[0].coverage,
+          'logDetails': {
+            'approved': storeNames,
+          },
+        };
+        let urlopensearch = JSON.parse( process.env.OPENSEARCH );
+        console.log( 'logData', logData );
+        await insertOpenSearchData( urlopensearch.traxActivityLog, logData );
         if ( searchResponse.ok ) {
           let pendingstores = taskDetails.filter( ( data ) => data.checklistStatus != 'submit' );
           if ( pendingstores && pendingstores.length > 0 ) {
@@ -2413,7 +2511,7 @@ export async function redomultiTask( req, res ) {
           sectionId: originalData.section_id,
           sectionName: question[sectionIndex].sectionName,
           questionName: question[sectionIndex].questions[req.body.payload.qno - 1].qname,
-          action: 'redo',
+          action: 'multiredo',
           store_id: taskDetails?.store_id?taskDetails?.store_id:'',
           storeName: taskDetails.storeName?taskDetails.storeName:'',
           client_id: taskDetails.client_id,
@@ -2972,6 +3070,22 @@ export const duplicateChecklist = async ( req, res ) => {
           sections.push( sectionDetails );
         }
         await taskQuestionService.insertMany( sections );
+        let logObj = {
+          client_id: checkDetails.client_id,
+          createAt: new Date(),
+          sourceCheckList_id: checkDetails._id,
+          checkListName: checkDetails.checkListName,
+          fromCheckListName: '',
+          type: 'task',
+          action: 'duplicated',
+          storeName: '',
+          store_id: '',
+          createdByEmail: req.user.email,
+          createdBy: req.user.userName,
+          coverage: checkDetails.coverage,
+          logDetails: {},
+        };
+        insertOpenSearchData( JSON.parse( process.env.OPENSEARCH ).traxActivityLog, logObj );
         return res.sendSuccess( { message: 'Task Duplicated Successfully' } );
       } else {
         return res.sendSuccess( { message: 'Duplicated Successfully' } );
@@ -3322,7 +3436,7 @@ export async function StoreHygienetask( req, res ) {
       return res.sendError( 'Maximum 3 referenceImage only allowed', 500 );
     }
     let data = {
-      checkListName: `${inputBody.taskName}(${storeDetails.storeName}-${dayjs().format( 'YYYY-MM-DD' )}-${inputBody.count})`,
+      checkListName: `${inputBody.taskName}(${storeDetails.storeName}-${dayjs().format( 'YYYY-MM-DD' )}-${inputBody.zoneName?inputBody.zoneName:''})`,
       checkListDescription: inputBody.taskDescription,
       createdBy: creator[0]._id,
       createdByName: creator[0].userName,
@@ -4292,47 +4406,76 @@ export async function updateAssign( req, res ) {
     if ( !taskDetails ) {
       return res.sendError( 'No data found', 204 );
     }
+    let groupList = req.body.assignedGroup;
     req.body.assignedGroup = [ ...new Set( req.body.assignedGroup.map( ( item ) => item.id ) ) ];
+    groupList = req.body.assignedGroup.reduce( ( acc, ele ) => {
+      let findDetails = groupList.find( ( item ) => item.id == ele );
+      if ( findDetails ) {
+        acc.push( findDetails?.clusterName || findDetails?.teamName );
+      };
+      return acc;
+    }, [] );
     // req.body.assignedGroup = req.body.assignedGroup.map( ( ele ) => {
     //   return { id: ele };
     // } );
     let getAssignedDetails = await taskAssignService.find( { checkListId: req.body.taskId } );
+    let oldCoverage;
     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 ) ) ];
-      }
+      oldCoverage = getAssignedDetails?.[0]?.coverage;
+      let storeClusterDetails = getAssignedDetails.filter( ( ele ) => ele?.storeName || ele?.clusterName );
+      let userTeamDetails = getAssignedDetails.filter( ( ele ) => !ele?.storeName && ( ele?.userName || ele?.teamName ) );
+      storeClusterDetails = [ ...new Set( storeClusterDetails.map( ( ele ) => ele?.storeName || ele?.clusterName ) ) ];
+      userTeamDetails= [ ...new Set( userTeamDetails.map( ( ele ) => ele?.userName || ele?.teamName ) ) ];
+      getAssignedDetails = [ ...storeClusterDetails, ...userTeamDetails ];
     }
 
-    let added = req.body.assignedList.filter( ( item ) => {
+    let assignedAllList = [ ...req.body.assignedList, ...groupList ];
+    let added = assignedAllList.filter( ( item ) => {
       let storeUsername;
+      let clusterTeamName;
       if ( req.body.coverage == 'store' ) {
-        storeUsername = item.storeName;
+        if ( item?.storeName ) {
+          storeUsername = item?.storeName;
+        } else {
+          clusterTeamName = item;
+        }
       } else {
-        storeUsername = item.userName;
+        if ( item?.userName ) {
+          storeUsername = item?.userName;
+        } else {
+          clusterTeamName = item;
+        }
       }
-      if ( !getAssignedDetails.includes( storeUsername ) ) {
+      if ( !getAssignedDetails.includes( storeUsername ) && !getAssignedDetails.includes( clusterTeamName ) ) {
         return item;
       }
     } ).map( ( ele ) => {
       if ( req.body.coverage == 'store' ) {
-        return ele.storeName;
+        return ele?.storeName || ele;
       } else {
-        return ele.userName;
+        return ele?.userName || ele;
       }
     } );
     let removed = getAssignedDetails.filter( ( item ) => {
       let list;
       if ( req.body.coverage == 'store' ) {
-        list = req.body.assignedList.map( ( item ) => item.storeName );
+        list = assignedAllList.map( ( item ) => item?.storeName );
+        let clusterList = assignedAllList.filter( ( item ) => !item?.storeName );
+        list = [ ...list, ...clusterList ];
       } else {
-        list = req.body.assignedList.map( ( item ) => item.userName ); ;
+        list = assignedAllList.map( ( item ) => item.userName );
+        let teamList = assignedAllList.filter( ( item ) => !item?.userName );
+        list = [ ...list, ...teamList ];
       }
       if ( !list.includes( item ) ) {
         return item;
       }
     } );
+    if ( getAssignedDetails.length ) {
+      removed = { user: oldCoverage == 'user' ? removed : [], store: oldCoverage == 'store' ? removed : [] };
+    } else {
+      removed = { user: [], store: [] };
+    }
     await taskAssignService.deleteMany( { checkListId: req.body.taskId } );
     let assignedUserList = [];
     let userEmailList = req.body.assignedList.map( ( ele ) => ele.userEmail.toLowerCase() );
@@ -4350,7 +4493,7 @@ export async function updateAssign( req, res ) {
       },
     ];
     let assignUserDetails = await userService.aggregate( query );
-    await Promise.all( req.body.assignedList.map( async ( assign ) => {
+    for ( let assign of req.body.assignedList ) {
       let userDetails = assignUserDetails.find( ( ele ) => ele.email.toLowerCase() == assign.userEmail.toLowerCase() );
       if ( !userDetails ) {
         let userData = {
@@ -4360,6 +4503,7 @@ export async function updateAssign( req, res ) {
           clientId: req.body.clientId,
         };
         userDetails = await createUser( userData );
+        assignUserDetails.push( userDetails );
       }
       let data = {
         ...assign,
@@ -4373,7 +4517,7 @@ export async function updateAssign( req, res ) {
       };
       delete data._id;
       assignedUserList.push( data );
-    } ) );
+    }
     let assignGroupDetails = [];
     if ( req.body.coverage == 'store' ) {
       assignGroupDetails = await clusterServices.findcluster( { _id: { $in: req.body.assignedGroup } } );
@@ -4791,14 +4935,252 @@ 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 );
-      return res.sendSuccess( 'Task created successfully' );
+      return res.sendSuccess( { sourceCheckList_id: response?._id } );
     }
   } catch ( e ) {
     logger.error( { function: 'taskcreation ventota', error: e } );
     return res.sendError( e, 500 );
   }
 }
+export async function breachedTasks( req, res ) {
+  try {
+    let inputBody = req.body;
+
+
+    inputBody.taskDescription = '';
+    let userId;
+    let storeDetails = await storeService.findOne( { storeId: inputBody.storeId, clientId: inputBody.clientId, status: 'active' }, { storeId: 1, storeName: 1, storeProfile: 1 } );
+    if ( !storeDetails ) {
+      return res.sendError( 'Store Not Found', 500 );
+    }
+
+    let url = JSON.parse( process.env.LAMBDAURL );
+    let checklistId = url.dailystoreChecklistId;
+    let finduser = await checklistassignconfigModel.findOne( { checkListId: new mongoose.Types.ObjectId( checklistId ), store_id: storeDetails.storeId } );
+
+    if ( !finduser ) {
+      return res.sendError( 'No user Found For this store', 500 );
+    }
+
+    userId = finduser.userId;
+    inputBody.userName = finduser.userName;
+    inputBody.userEmail = finduser.userEmail;
+
+
+    let teamList = await findteams( { users: { $elemMatch: { email: finduser.userEmail } } } );
+
+    inputBody.approver = '';
+    for ( let team of teamList ) {
+      for ( let user of team.Teamlead ) {
+        inputBody.approver = user.email + ',' + inputBody.approver;
+      }
+    }
+    inputBody.approver = inputBody.approver.replace( /,$/, '' );
+
+
+    let title = `New Task Alert ${inputBody.taskName}-${storeDetails.storeName}-${dayjs().format( 'YYYY-MM-DD' )}`;
+    let time = inputBody?.scheduleEndTime || '11:59 PM';
+    let date = inputBody?.scheduleDate || dayjs().format( 'YYYY-MM-DD' );
+    let description = `A new task has been assigned to ${storeDetails.storeName}. Please complete it before the due date of ${date}.`;
+    if ( userDetails&&userDetails.fcmToken ) {
+      const fcmToken = userDetails.fcmToken;
+      await sendPushNotification( title, description, fcmToken );
+    }
+    const inputDateTime = dayjs.utc( `${date} ${time}`, 'YYYY-MM-DD hh:mm A' );
+    const currentTime = dayjs.utc();
+    if ( inputDateTime.isBefore( currentTime ) ) {
+      return res.sendError( 'The input date-time is before the current time.', 500 );
+    }
+
+    let approverList = inputBody?.approver.split( ',' );
+
+
+    let userAdmin = await userService.find( { clientId: inputBody.clientId, email: { $in: approverList }, userType: 'client', isActive: true }, { name: '$userName', email: 1 } );
+
+    if ( userAdmin && userAdmin.length === 0 ) {
+      userAdmin = await userService.find( { clientId: inputBody.clientId, email: 'rohit.chawla@lenskart.com', userType: 'client', isActive: true }, { name: '$userName', email: 1 } );
+    }
+
+    let creator = await userService.find( { clientId: inputBody.clientId, email: 'rohit.chawla@lenskart.com', userType: 'client', isActive: true } );
+    if ( creator && creator.length === 0 ) {
+      return res.sendError( 'Invalid Creator Details', 500 );
+    }
+
+    if ( req.body && req.body.referenceImage && req.body.referenceImage.length > 3 ) {
+      return res.sendError( 'Maximum 3 referenceImage only allowed', 500 );
+    }
+    let data = {
+      checkListName: `${inputBody.taskName}(${storeDetails.storeName}-${dayjs().format( 'YYYY-MM-DD' )})`,
+      checkListDescription: inputBody.taskDescription,
+      createdBy: creator[0]._id,
+      createdByName: creator[0].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: 'task',
+      publishDate: new Date(),
+      locationCount: 1,
+      ...( inputBody?.checkListId ) ? { referenceCheckListId: inputBody?.checkListId } : {},
+    };
+    data['approver'] = userAdmin;
+    let answer = await findAnswer( inputBody?.answerType );
+    if ( answer.length == 0 ) {
+      return res.sendError( 'please enter Valid AnswerType', 500 );
+    }
+    if ( inputBody?.answerType === 'multiplechoicesingle' || inputBody?.answerType === 'multiplechoicemultiple' ) {
+      if ( inputBody?.options && inputBody?.options.length > 0 ) {
+        let optionsResult = [];
+        let optionList = inputBody?.options.split( ',' );
+        for ( let option of optionList ) {
+          let optiondata = {
+            'answer': '',
+            'sopFlag': false,
+            'validation': false,
+            'validationType': '',
+            'referenceImage': [],
+            'runAI': false,
+            'allowUploadfromGallery': false,
+            'descriptivetype': '',
+            'showLinked': false,
+            'linkedQuestion': 0,
+            'nestedQuestion': [],
+          };
+          optiondata.answer = option;
+          optionsResult.push( optiondata );
+        }
+        answer = optionsResult;
+      } else {
+        return res.sendError( 'please enter Valid Options', 500 );
+      }
+    }
+    let response = await taskService.create( data );
+    if ( response?.approver.length ) {
+      let inputData = [];
+      response?.approver.forEach( ( ele ) => {
+        inputData.push( {
+          userEmail: ele.email,
+          checkListId: response._id,
+          type: 'task',
+          client_id: inputBody.clientId,
+          checkListName: data?.checkListName || '',
+        } );
+      } );
+      await traxApprover.insertMany( inputData );
+    }
+    if ( response?._id ) {
+      let question = [];
+      for ( let [ index, ques ] of inputBody.questions.entries() ) {
+        let answer = await findAnswer( ques?.answerType );
+        if ( answer.length == 0 ) {
+          return res.sendError( 'please enter Valid AnswerType', 500 );
+        }
+        if ( ques?.answerType === 'multiplechoicesingle' || ques?.answerType === 'multiplechoicemultiple' ) {
+          if ( ques?.options && ques?.options.length > 1 ) {
+            let optionsResult = [];
+            for ( let option of ques?.options ) {
+              let optiondata = {
+                'answer': '',
+                'sopFlag': false,
+                'validation': false,
+                'validationType': '',
+                'referenceImage': [],
+                'runAI': false,
+                'allowUploadfromGallery': false,
+                'descriptivetype': '',
+                'showLinked': false,
+                'linkedQuestion': 0,
+                'nestedQuestion': [],
+              };
+              optiondata.answer = String( option );
+              optionsResult.push( optiondata );
+            }
+            answer = optionsResult;
+          } else {
+            return res.sendError( 'please enter Valid Options', 500 );
+          }
+        }
+        question.push( {
+          'qno': index+1,
+          'qname': ques.question,
+          'answerType': ques?.answerType || 'yes/no',
+          'runAI': false,
+          'runAIDescription': '',
+          'allowUploadfromGallery': false,
+          'linkType': false,
+          'questionReferenceImage': [],
+          'answers': answer,
+          'descriptivetype': 'text',
+        } );
+        let images = [];
+        for ( let imgpath of req.body.referenceImage ) {
+          let configURL = JSON.parse( process.env.BUCKET );
+          let inputData = {
+            Bucket: configURL.commonAiTaskBucket,
+            Key: imgpath,
+          };
+          let output = await getObject( inputData );
+          let image = {
+            data: output.Body,
+            name: imgpath,
+            mimetype: output.ContentType,
+          };
+          let uplaodedImage = await uploadmultiImage( image );
+
+          let imgUrl = decodeURIComponent( uplaodedImage.imgUrl.split( '?' )[0] );
+          let url = imgUrl.split( '/' );
+          if ( url.includes( 'https:' ) || url.includes( 'http:' ) ) {
+            url.splice( 0, 3 );
+          }
+          images.push( url.join( '/' ) );
+        }
+        question[0].questionReferenceImage = images;
+
+        if ( inputBody?.answerType === 'image' || inputBody?.answerType === 'descriptiveImage' || inputBody?.answerType === 'multipleImage' ) {
+          answer[0].referenceImage = question[0].questionReferenceImage;
+        }
+
+        // if ( inputBody?.answerType === 'image' || inputBody?.answerType === 'descriptiveImage' || inputBody?.answerType === 'multipleImage' ) {
+        //   answer[0].referenceImage = question[0].questionReferenceImage;
+        // }
+
+        question = {
+          checkListId: response?._id,
+          question: question,
+          section: 'Section 1',
+          checkList: data.checkListName,
+          client_id: inputBody.clientId,
+        };
+        await taskQuestionService.create( question );
+
+        let userDetails = {
+          userName: inputBody.userName,
+          userEmail: inputBody.userEmail,
+          store_id: storeDetails.storeId,
+          storeName: storeDetails.storeName,
+          city: storeDetails?.storeProfile?.city,
+          checkFlag: true,
+          checkListId: response?._id,
+          checkListName: data.checkListName,
+          client_id: inputBody.clientId,
+          userId: userId,
+          assignId: storeDetails._id,
+        };
+        await taskAssignService.create( userDetails );
+        await insertSingleProcessData( response?._id );
+        return res.sendSuccess( 'Task created successfully' );
+      }
+    }
+  } catch ( e ) {
+    logger.error( { function: 'taskcreation Ai checklist breach', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+

package/src/controllers/taskDashboard.controllers.js

@@ -1,6 +1,6 @@
 import * as taskService from '../service/task.service.js';
 import * as processedTaskService from '../service/processedTaskList.service.js';
-import { logger, download } from 'tango-app-api-middleware'; // getChecklistUsers
+import { logger, download, insertOpenSearchData } from 'tango-app-api-middleware'; // getChecklistUsers
 import dayjs from 'dayjs';
 import mongoose from 'mongoose';
 // const ObjectId = mongoose.Types.ObjectId;
@@ -961,7 +961,7 @@ export const taskDeleteV1 = async ( req, res ) => {
       return res.sendError( 'Missing taskId in request body', 400 );
     }
 
-    const taskConfig = await taskService.findOne( { _id: new mongoose.Types.ObjectId( requestData.taskId ) }, { _id: 1 } );
+    const taskConfig = await taskService.findOne( { _id: new mongoose.Types.ObjectId( requestData.taskId ) } );
     if ( !taskConfig ) {
       // console.log( 'Task found:', taskConfig );
       return res.sendError( 'Task not found', 404 );
@@ -973,12 +973,29 @@ export const taskDeleteV1 = async ( req, res ) => {
     );
 
     if ( resultData ) {
+      let logObj = {
+        client_id: taskConfig.client_id,
+        createAt: new Date(),
+        sourceCheckList_id: taskConfig._id,
+        checkListName: taskConfig.checkListName,
+        fromCheckListName: '',
+        type: 'task',
+        action: 'deleted',
+        storeName: '',
+        store_id: '',
+        createdByEmail: req.user.email,
+        createdBy: req.user.userName,
+        coverage: taskConfig.coverage,
+        logDetails: {},
+      };
+      insertOpenSearchData( JSON.parse( process.env.OPENSEARCH ).traxActivityLog, logObj );
       // 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 ) {
+    // console.log( 'e', e );
     logger.error( 'taskDeleteV1 =>', e );
     return res.sendError( e, 500 );
   }

package/src/dtos/task.dto.js

@@ -21,7 +21,7 @@ export const StoreHygienetaskSchema = Joi.object().keys( {
   scheduleDate: Joi.string().optional(),
   scheduleEndTime: Joi.string().optional(),
   referenceImage: Joi.array().required(),
-  count: Joi.number().required(),
+  zoneName: Joi.string().required(),
 } );
 
 

package/src/routes/task.routes.js

@@ -38,6 +38,7 @@ taskRouter
     .post( '/commonAiTask', isAllowedInternalAPIHandler, validate( commonAiTaskvalidation ), taskController.commonAiTask )
     .post( '/updateAssign', isAllowedSessionHandler, taskController.updateAssign )
     .post( '/taskcreation', isAllowedInternalAPIHandler, validate( taskcreationvalidation ), taskController.taskcreation )
+    .post( '/breached-tasks', isAllowedInternalAPIHandler, validate( taskcreationvalidation ), taskController.breachedTasks )
     .get( '/getcoustemer', taskController.customertrial );