tango-app-api-task 3.2.1-beta-27 → 3.3.1-beta-1

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-task",
-    "version": "3.2.1-beta-27",
+    "version": "3.3.1-beta-1",
     "description": "Task",
     "main": "index.js",
     "type": "module",
@@ -24,8 +24,8 @@
         "mongodb": "^6.10.0",
         "nodemon": "^3.1.7",
         "npm": "^10.9.2",
-        "tango-api-schema": "^2.2.52",
-        "tango-app-api-middleware": "^3.1.58",
+        "tango-api-schema": "^2.2.44",
+        "tango-app-api-middleware": "^3.1.55",
         "winston": "^3.17.0",
         "winston-daily-rotate-file": "^5.0.0"
     },

package/src/controllers/task.controller.js

@@ -8,9 +8,7 @@ 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 checklistassignconfigModel from '../service/checklistAssign.service.js';
-import * as clusterServices from '../service/cluster.service.js';
-import * as teamsServices from '../service/teams.service.js';
-// import * as clusterModel from '../service/cluster.service.js';
+import * as clusterModel from '../service/cluster.service.js';
 // import * as domainService from '../service/domain.service.js';
 import mongoose from 'mongoose';
 const ObjectId = mongoose.Types.ObjectId;
@@ -127,6 +125,38 @@ export async function createUpdateTask( req, res ) {
             } );
           } );
 
+          for ( let [ index, question ] of section.questions.entries() ) {
+            await processNested( index, question );
+          }
+
+          async function processNested( qIdx, question, nestedIndex = -1 ) {
+            if ( question?.answers?.length ) {
+              for ( let [ index, answer ] of question?.answers?.entries() ) {
+                if ( !section.questions[qIdx].answers[index]?.nestedQuestion && nestedIndex == -1 ) {
+                  section.questions[qIdx].answers[index].nestedQuestion = [];
+                }
+                if ( answer.showLinked ) {
+                  if ( nestedIndex != -1 ) {
+                    section.questions[qIdx].answers[nestedIndex].nestedQuestion.push( answer.linkedQuestion );
+                  } else {
+                    section.questions[qIdx].answers[index].nestedQuestion.push( answer.linkedQuestion );
+                  }
+                  let nestedLinkedQuestion = section.questions.find( ( item ) => item.qno == answer.linkedQuestion );
+                  if ( nestedLinkedQuestion ) {
+                    let findNestedAnswers = nestedLinkedQuestion.answers.find( ( item ) => item.showLinked );
+                    if ( findNestedAnswers ) {
+                      if ( nestedIndex != -1 ) {
+                        await processNested( qIdx, nestedLinkedQuestion, nestedIndex );
+                      } else {
+                        await processNested( qIdx, nestedLinkedQuestion, index );
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+
           sectionList.push( {
             section: section?.name || 'Section 1',
             createdBy: req.user._id,
@@ -264,9 +294,9 @@ export async function taskDetails( req, res ) {
     }
     if ( storechecklistdetails ) {
       result.checkListDetails = { ...storechecklistdetails._doc };
-      let assignedusers = await taskAssignService.find( { checkListId: storechecklistdetails._id }, { assignId: 1 } );
-      assignedusers = assignedusers?.map( ( item ) => item.assignId );
-      result.checkListDetails = { ...result.checkListDetails, ...{ sections: sectionList }, ...{ assignedusers: assignedusers } };
+      let removedUsers = await taskAssignService.find( { checkFlag: false, checkListId: storechecklistdetails._id }, { _id: 1 } );
+      removedUsers = removedUsers?.map( ( item ) => item._id );
+      result.checkListDetails = { ...result.checkListDetails, ...{ sections: sectionList }, ...{ removedUsers: removedUsers } };
     }
     return res.sendSuccess( result );
   } catch ( e ) {
@@ -565,8 +595,11 @@ export async function userDetails( req, res ) {
     if ( !req.query.taskId ) {
       return res.sendError( { message: 'Task Id is required' }, 400 );
     }
+    let limit = parseInt( req.query.limit ) || 5;
+    let page = parseInt( req.query.offset ) || 0;
+    let skip = limit * page;
 
-    let query = [ { $match: { checkListId: new ObjectId( req.query.taskId ), ...( req.query.coverage ) ? { coverage: req.query.coverage } : {}, isdeleted: false } } ];
+    let query = [ { $match: { checkListId: new ObjectId( req.query.taskId ) } } ];
     if ( req.query?.search?.trim() && req.query?.search?.trim() != '' ) {
       let searchValue = req.query.search;
       searchValue = searchValue.split( ',' ).map( ( item ) => item.trim().toLowerCase() );
@@ -578,6 +611,17 @@ export async function userDetails( req, res ) {
       }
     }
 
+    query.push( {
+      $facet: {
+        data: [
+          { $skip: skip }, { $limit: limit },
+        ],
+        count: [
+          { $count: 'total' },
+        ],
+      },
+    } );
+
     let taskDetails = await taskAssignService.aggregate( query );
 
     if ( !taskDetails[0].data.length ) {
@@ -585,70 +629,19 @@ export async function userDetails( req, res ) {
     }
 
     let userDetails = [];
-    let storeList = [];
-    let userList = [];
-    await Promise.all( taskDetails.map( async ( ele ) => {
-      if ( ele?.store_id || ele?.clusterName ) {
-        storeList.push( ele.assignId );
-      } else {
-        userList.push( ele.assignId );
-      }
-
-      if ( ele?.clusterName ) {
-        let clusterDetails = await clusterServices.findOneCluster( { _id: ele.assignId }, { stores: 1 } );
-        if ( clusterDetails ) {
-          let storeDetails = await storeService.find( { _id: { $in: clusterDetails.stores.map( ( item ) => item.store ) }, status: 'active' } );
-          storeDetails.forEach( ( item ) => {
-            userDetails.push( {
-              id: ele._id,
-              userName: item.spocDetails?.[0]?.name,
-              userEmail: item.spocDetails?.[0]?.email,
-              store_id: item?.storeId,
-              storeName: item?.storeName,
-              userPhone: item.spocDetails?.[0]?.phone,
-              city: ele?.city,
-              checkFlag: ele.checkFlag,
-              clusterName: ele?.clusterName || '',
-              teamName: ele?.teamName || '',
-            } );
-          } );
-        }
-      } else if ( ele?.teamName ) {
-        let teamDetails = await teamsServices.findOneTeams( { _id: ele.assignId }, { users: 1, teamName: 1 } );
-        if ( teamDetails ) {
-          let teamUserDetails = await userService.find( { _id: { $in: teamDetails.users.map( ( item ) => item.userId ) } } );
-          teamUserDetails.forEach( ( item ) => {
-            userDetails.push( {
-              id: ele._id,
-              userName: item.userName,
-              userEmail: item.email,
-              store_id: ele?.storeId,
-              storeName: ele?.storeName,
-              userPhone: item?.mobileNumber,
-              city: ele?.city,
-              checkFlag: ele.checkFlag,
-              clusterName: ele?.clusterName || '',
-              teamName: ele?.teamName || '',
-            } );
-          } );
-        }
-      } else {
-        userDetails.push( {
-          id: ele._id,
-          userName: ele.userName,
-          userEmail: ele.userEmail,
-          store_id: ele?.store_id,
-          storeName: ele?.storeName,
-          userPhone: ele.userPhone,
-          city: ele.city,
-          checkFlag: ele.checkFlag,
-          clusterName: ele?.clusterName || '',
-          teamName: ele?.teamName || '',
-        } );
-      }
-    } ) );
-
-    return res.sendSuccess( { count: userDetails.length, storeList, userList, users: limitedData } );
+    taskDetails[0].data.forEach( ( item ) => {
+      userDetails.push( {
+        id: item._id,
+        userName: item.userName,
+        userEmail: item.userEmail,
+        store_id: item.store_id,
+        storeName: item.storeName,
+        userPhone: item.userPhone,
+        city: item.city,
+        checkFlag: item.checkFlag,
+      } );
+    } );
+    return res.sendSuccess( { users: userDetails, count: taskDetails[0].count[0].total } );
   } catch ( e ) {
     logger.error( { functionName: 'userDetails', error: e, message: req.body } );
     return res.sendError( e, 500 );
@@ -658,22 +651,20 @@ export async function userDetails( req, res ) {
 export async function taskConfig( req, res ) {
   try {
     let inputBody = req.body;
+    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 );
     }
 
-    if ( !inputBody.assignedUsers.length && inputBody.submitType == 'publish' ) {
-      return res.sendError( 'Please Assigned a user', 400 );
+    if ( inputBody.submitType == 'publish' ) {
+      let checkUserAssigned = await taskAssignService.findOne( { checkListId: inputBody._id, checkFlag: true } );
+      if ( !checkUserAssigned ) {
+        return res.sendError( { message: 'Please assign a user' }, 400 );
+      }
     }
-
-    // if ( inputBody.submitType == 'publish' ) {
-    //   let checkUserAssigned = await taskAssignService.findOne( { checkListId: inputBody._id, checkFlag: true } );
-    //   if ( !checkUserAssigned ) {
-    //     return res.sendError( { message: 'Please assign a user' }, 400 );
-    //   }
-    // }
     if ( !inputBody?.approver.length && inputBody.submitType == 'publish' ) {
       return res.sendError( { message: 'Please assign approver' }, 400 );
     }
@@ -691,7 +682,7 @@ 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 } );
 
     if ( !checklistDetails ) {
       return res.sendError( 'No data found', 204 );
@@ -729,21 +720,39 @@ export async function taskConfig( req, res ) {
         await traxApprover.insertMany( data );
       }
     }
-    if ( inputBody.assignedUsers.length ) {
-      await taskAssignService.deleteMany( { checkListId: inputBody._id } );
-      await Promise.all( inputBody.assignedUsers.map( async ( user ) => {
-        let data = {
-          ...user,
-          clientId: req.body.clientId,
-          checkListName: checklistDetails.checkListName,
-          checklistId: checklistDetails._id,
-          coverage: inputBody.coverage,
-          insert: true,
-        };
-        await assignUsers( data );
-      } ) );
+    await taskAssignService.updateMany( { checkListId: inputBody._id }, { checkFlag: true } );
+    if ( inputBody.removedUsers.length ) {
+      await taskAssignService.updateMany( { _id: { $in: inputBody.removedUsers } }, { checkFlag: false } );
     }
     let storeConfigDetails = await taskAssignService.find( { checkListId: inputBody._id, checkFlag: true }, { _id: 0, store_id: 1, userEmail: 1, storeName: 1 } );
+    let storeList = storeConfigDetails.map( ( store ) => store.store_id );
+
+    storeCount = storeList.length;
+    if ( storeList.length ) {
+      let query = [
+        {
+          $match: {
+            client_id: inputBody.client_id,
+            id: { $in: storeList },
+            city: { $exists: true },
+          },
+        },
+        {
+          $group: {
+            _id: '$city',
+          },
+        },
+        {
+          $project: {
+            _id: 0,
+            city: '$_id',
+          },
+        },
+      ];
+      let storeDetails = await storeService.aggregate( query );
+      locationCount = storeDetails.length;
+    }
+    await taskService.updateOne( { _id: inputBody._id }, { storeCount, locationCount } );
     if ( inputBody.submitType == 'publish' ) {
       let taskName = checklistDetails.checkListName;
       let dueDate = dayjs( configDetails.scheduleEndTimeISO ).format( 'YYYY-MM-DD hh:mm A' );
@@ -901,6 +910,7 @@ export async function insertSingleProcessData( checklistId ) {
             await taskProcessedConfigService.updateOne( { _id: checklistDetails._id }, insertDataPerDay );
             updatedchecklist = checklistDetails;
           }
+
           if ( updatedchecklist ) {
             await insertPCBulkV3( getCLconfig, checklistId, updatedchecklist, dateVal, startTimeIso, endTimeIso, insertdata );
           }
@@ -928,80 +938,7 @@ async function insertPCBulkV3( getCLconfig, checklistId, updatedchecklist, date,
 
   if ( allQuestion ) {
     let userIdList = [];
-    let assignList = [];
-    let assignUserList = [];
-    if ( getCLconfig.coverage == 'store' ) {
-      let clusterList = allQuestion.filter( ( ele ) => ele?.clusterName ).map( ( item ) => item.assignId );
-      if ( clusterList.length ) {
-        let clusterDetails = await clusterServices.findcluster( { _id: { $in: clusterList } } );
-        if ( clusterDetails.length ) {
-          let idList = clusterDetails.flatMap( ( item ) => item.stores.map( ( ele ) => ele.store ) );
-          let getStoreDetails = await storeService.find( { _id: { $in: idList }, status: 'active' } );
-          if ( getStoreDetails.length ) {
-            assignList = await Promise.all( getStoreDetails.map( async ( store ) => {
-              let userDetails = await userService.findOne( { email: store?.spocDetails?.[0]?.email, clientId: store.clientId } );
-              if ( !userDetails ) {
-                let data = {
-                  clientId: store.clientId,
-                  userName: store.spocDetails?.[0]?.name,
-                  mobileNumber: store.spocDetails?.[0]?.phone || '',
-                  email: store.spocDetails[0].email,
-                };
-                userDetails = await createUser( data );
-              }
-              let data = {
-                store_id: store?.storeId,
-                storeName: store?.storeName,
-                userId: userDetails._id,
-                userName: userDetails.userName,
-                userEmail: userDetails.email,
-                userPhone: userDetails?.mobileNumber,
-                city: store?.storeProfile?.city,
-                country: store?.storeProfile?.country,
-                checkFlag: true,
-                checkListId: getCLconfig._id,
-                checkListName: getCLconfig.checkListName,
-                client_id: getCLconfig.client_id,
-              };
-              return data;
-            } ) );
-          }
-        }
-      }
-      allQuestion = allQuestion.filter( ( ele ) => !clusterList.includes( ele.assignId ) );
-    }
-    if ( getCLconfig.coverage == 'user' ) {
-      let teamsList = allQuestion.filter( ( ele ) => ele?.teamName ).map( ( item ) => item.assignId );
-      if ( teamsList.length ) {
-        let teamDetails = await teamsServices.findteams( { _id: { $in: teamsList } } );
-        if ( teamDetails.length ) {
-          let idList = teamDetails.flatMap( ( item ) => item.users.map( ( ele ) => ele.userId ) );
-          let getUserDetails = await userService.find( { _id: { $in: idList } } );
-          if ( getUserDetails.length ) {
-            assignList = getUserDetails.map( ( user ) => {
-              let data = {
-                store_id: '',
-                storeName: '',
-                userId: user._id,
-                userName: user.userName,
-                userEmail: user.email,
-                userPhone: user?.mobileNumber,
-                city: '',
-                country: '',
-                checkFlag: true,
-                checkListId: getCLconfig._id,
-                checkListName: getCLconfig.checkListName,
-                client_id: getCLconfig.client_id,
-              };
-              return data;
-            } );
-          }
-        }
-      }
-      allQuestion = allQuestion.filter( ( ele ) => !teamsList.includes( ele.assignId ) );
-    }
-    allQuestion = [ ...allQuestion, ...assignList ];
-    await Promise.all( allQuestion.map( async ( element4 ) => {
+    for ( let element4 of allQuestion ) {
       let query;
       query = {
         date_string: dayjs( date ).format( 'YYYY-MM-DD' ),
@@ -1017,39 +954,38 @@ async function insertPCBulkV3( getCLconfig, checklistId, updatedchecklist, date,
       let getsubmitDetails = await taskProcessedService.find( query );
       if ( getsubmitDetails.length ) {
         userIdList.push( element4._id );
-      } else {
-        delete element4._id;
-        delete element4.checkFlag;
-        delete element4.isdeleted;
-        delete element4.createdAt;
-        delete element4.updatedAt;
-        element4.checkListId = updatedchecklist._id;
-        element4.checkListName = getCLconfig.checkListName;
-        element4.checkListDescription = getCLconfig.checkListDescription;
-        element4.date_iso = new Date( dayjs( date, 'YYYY-MM-DD' ).format( 'YYYY-MM-DD' ) );
-        element4.date_string = dayjs( date ).format( 'YYYY-MM-DD' );
-        element4.allowedOverTime = false;
-        element4.allowedStoreLocation = getCLconfig.allowedStoreLocation;
-        element4.scheduleStartTime = '12:00 AM';
-        element4.scheduleStartTime_iso = startTimeIso.format();
-        element4.scheduleEndTime = getCLconfig.scheduleEndTime;
-        element4.scheduleEndTime_iso = endTimeIso.format();
-        element4.createdBy = new ObjectId( getCLconfig.createdBy );
-        element4.createdByName = getCLconfig.createdByName;
-        element4.sourceCheckList_id = getCLconfig._id;
-        element4.checkListType = getCLconfig.checkListType;
-        element4.storeCount = getCLconfig.storeCount;
-        element4.questionCount = getCLconfig.questionCount;
-        element4.publishDate = getCLconfig.publishDate;
-        element4.locationCount = getCLconfig.locationCount;
-        element4.scheduleRepeatedType = 'daily';
-        element4.approvalEnable = getCLconfig.approver.length ? true : false;
-        element4.priorityType = getCLconfig.priorityType;
-        element4.remainder = getCLconfig?.remainder || [];
-        element4.restrictAttendance = getCLconfig?.restrictAttendance;
-        assignUserList.push( element4 );
-      }
-    } ) );
+        continue;
+      }
+      delete element4._id;
+      delete element4.checkFlag;
+      delete element4.isdeleted;
+      delete element4.createdAt;
+      delete element4.updatedAt;
+      element4.checkListId = updatedchecklist._id;
+      element4.checkListName = getCLconfig.checkListName;
+      element4.checkListDescription = getCLconfig.checkListDescription;
+      element4.date_iso = new Date( dayjs( date, 'YYYY-MM-DD' ).format( 'YYYY-MM-DD' ) );
+      element4.date_string = dayjs( date ).format( 'YYYY-MM-DD' );
+      element4.allowedOverTime = false;
+      element4.allowedStoreLocation = getCLconfig.allowedStoreLocation;
+      element4.scheduleStartTime = '12:00 AM';
+      element4.scheduleStartTime_iso = startTimeIso.format();
+      element4.scheduleEndTime = getCLconfig.scheduleEndTime;
+      element4.scheduleEndTime_iso = endTimeIso.format();
+      element4.createdBy = new ObjectId( getCLconfig.createdBy );
+      element4.createdByName = getCLconfig.createdByName;
+      element4.sourceCheckList_id = getCLconfig._id;
+      element4.checkListType = getCLconfig.checkListType;
+      element4.storeCount = getCLconfig.storeCount;
+      element4.questionCount = getCLconfig.questionCount;
+      element4.publishDate = getCLconfig.publishDate;
+      element4.locationCount = getCLconfig.locationCount;
+      element4.scheduleRepeatedType = 'daily';
+      element4.approvalEnable = getCLconfig.approver.length ? true : false;
+      element4.priorityType = getCLconfig.priorityType;
+      element4.remainder = getCLconfig?.remainder || [];
+      element4.restrictAttendance = getCLconfig?.restrictAttendance;
+    }
     if ( userIdList.length ) {
       allQuestion = allQuestion.filter( ( item ) => typeof item._id == 'undefined' );
     }
@@ -1143,7 +1079,6 @@ export async function uploadImage( req, res ) {
 
 async function createUser( data ) {
   try {
-    console.log( 'createUser ====>', data );
     let params = {
       userName: data.userName,
       email: data.email,
@@ -1226,8 +1161,7 @@ async function createUser( data ) {
       ],
     };
     let response = await userService.create( params );
-    // console.log( 'createUser ====>', response );
-    return response;
+    return response._id;
   } catch ( e ) {
     logger.error( 'createUser =>', e );
     return false;
@@ -1427,17 +1361,16 @@ export async function createChecklistTask( req, res ) {
         client_id: inputBody.clientId,
       };
       await taskQuestionService.create( question );
-      let storeDetails;
-      if ( inputBody?.storeName ) {
-        storeDetails = await storeService.findOne( { storeName: inputBody.storeName, status: 'active' }, { 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 );
       }
-
       let userDetails = {
         userName: inputBody.userName,
         userEmail: inputBody.userEmail,
-        store_id: storeDetails?.storeId?storeDetails.storeId:'',
-        storeName: inputBody?.storeName?inputBody?.storeName:'',
-        city: storeDetails?.storeProfile?.city?storeDetails?.storeProfile?.city:'',
+        store_id: storeDetails.storeId,
+        storeName: inputBody.storeName,
+        city: storeDetails?.storeProfile?.city,
         checkFlag: true,
         checkListId: response?._id,
         checkListName: data.checkListName,
@@ -1456,9 +1389,8 @@ export async function createChecklistTask( req, res ) {
         if ( sectionIndex == -1 ) {
           return res.sendError( 'section is not found', 400 );
         }
-        let findQuestion = question[sectionIndex].questions.findIndex( ( ele ) => ele?.parentQuestion ? ele.qno == req.body.qno && ele.parentQuestion == req.body.parentQuestion : ele.qno == req.body.qno );
+        let data = { ...question[sectionIndex].questions[req.body.qno - 1], taskId: response?._id, task: true };
 
-        let data = { ...question[sectionIndex].questions[findQuestion], taskId: response?._id, task: true };
         question[sectionIndex].questions[req.body.qno - 1] = data;
         taskDetails.questionAnswers = question;
         let updateData = {
@@ -1471,7 +1403,6 @@ export async function createChecklistTask( req, res ) {
             _id: inputBody.processedChecklistId,
             section_id: inputBody.sectionId,
             qno: inputBody.qno,
-            parentQuestion: inputBody.parentQuestion,
           },
           'upsert': {
             taskId: String( response?._id ),
@@ -1531,7 +1462,6 @@ export async function approveTask( req, res ) {
             sourceCheckList_id: req.body.sourceCheckList_id,
             fromDate: req.body.fromDate,
             toDate: req.body.toDate,
-            filtertype: req.body.filtertype,
             store_id: inputstores,
           },
           'upsert': {
@@ -1609,7 +1539,6 @@ export async function redoTask( req, res ) {
     };
 
     let response = await taskProcessedService.updateOne( { _id: req.body.payload._id }, updateData );
-    console.log( response );
     if ( response.modifiedCount || response.matchedCount ) {
       let storeTimeZone = await storeService.findOne( { storeName: taskDetails.storeName }, { 'storeProfile.timeZone': 1 } );
       let currentDateTime;
@@ -1626,8 +1555,8 @@ export async function redoTask( req, res ) {
         sectionName: question[sectionIndex].sectionName,
         questionName: question[sectionIndex].questions[req.body.payload.qno - 1].qname,
         action: 'redo',
-        store_id: taskDetails?.store_id?taskDetails?.store_id:'',
-        storeName: taskDetails.storeName?taskDetails.storeName:'',
+        store_id: taskDetails.store_id,
+        storeName: taskDetails.storeName,
         client_id: taskDetails.client_id,
         processedChecklistId: taskDetails._id,
         type: taskDetails.checkListType,
@@ -1649,7 +1578,6 @@ export async function redoTask( req, res ) {
       };
       let url = JSON.parse( process.env.LAMBDAURL );
       let searchResponse = await fetch( url.redoTask, requestOptions );
-      console.log( searchResponse.ok );
       if ( searchResponse.ok ) {
         return res.sendSuccess( 'Question redo successfully' );
       } else {
@@ -1746,7 +1674,6 @@ export const taskDropdown = async ( req, res ) => {
         scheduleRepeatedType: 1,
         scheduleStartTime: 1,
         scheduleEndTime: 1,
-        coverage: 1,
       },
     } );
 
@@ -1761,7 +1688,6 @@ export const taskDropdown = async ( req, res ) => {
         scheduleRepeatedType: { $last: '$scheduleRepeatedType' },
         scheduleStartTime: { $last: '$scheduleStartTime' },
         scheduleEndTime: { $last: '$scheduleEndTime' },
-        coverage: { $last: '$coverage' },
       },
     } );
 
@@ -1800,7 +1726,6 @@ export const taskDropdown = async ( req, res ) => {
         scheduleRepeatedType: 1,
         scheduleStartTime: 1,
         scheduleEndTime: 1,
-        coverage: 1,
         checkListDescription: '$checklistconfigs.checkListDescription',
         publish: '$checklistconfigs.publish',
       },
@@ -2236,13 +2161,13 @@ export async function clusterMigrations( req, res ) {
       if ( userexits ) {
         let findStore = await storeService.findOne( { storeName: user.FacilityCode } );
         if ( findStore ) {
-          let clusterExists = await clusterServices.findOneCluster( { clusterName: user.AomName } );
+          let clusterExists = await clusterModel.findOneCluster( { clusterName: user.AomName } );
           if ( clusterExists ) {
             let data = {
               storeId: findStore.storeId,
               store: findStore._id,
             };
-            let updatecluster = await clusterServices.updateCluster( { clusterName: user.AomName }, { $push: { stores: data } } );
+            let updatecluster = await clusterModel.updateCluster( { clusterName: user.AomName }, { $push: { stores: data } } );
             console.log( updatecluster );
           } else {
             let payload = {
@@ -2264,7 +2189,7 @@ export async function clusterMigrations( req, res ) {
               ],
               'users': [],
             };
-            let createcluster = await clusterServices.createclusterModel( payload );
+            let createcluster = await clusterModel.createclusterModel( payload );
             console.log( createcluster );
           }
         }
@@ -2464,16 +2389,14 @@ export async function StoreHygienetask( req, res ) {
     inputBody.approver = inputBody.approver.replace( /,$/, '' );
 
 
-    let title = `New Task Alert ${inputBody.taskName}-${storeDetails.storeName}-${dayjs().format( 'YYYY-MM-DD' )}`;
+    // 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}.`;
-    let userDetails = await userService.findOne( { _id: new mongoose.Types.ObjectId( finduser.userId ) } );
-    console.log( userDetails.fcmToken );
-    if ( userDetails&&userDetails.fcmToken ) {
-      const fcmToken = userDetails.fcmToken;
-      await sendPushNotification( title, description, fcmToken );
-    }
+    // 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 ) ) {
@@ -2652,7 +2575,6 @@ export async function StoreHygienetask( req, res ) {
 export async function eyeTesttask( req, res ) {
   try {
     let inputBody = req.body;
-    console.log( inputBody );
     inputBody.clientId = 11;
     inputBody.taskDescription = '';
     let userId;
@@ -2663,9 +2585,7 @@ export async function eyeTesttask( req, res ) {
 
     let url = JSON.parse( process.env.LAMBDAURL );
     let checklistId = url.dailystoreChecklistId;
-    console.log( checklistId );
     let finduser = await checklistassignconfigModel.findOne( { checkListId: new mongoose.Types.ObjectId( checklistId ), store_id: storeDetails.storeId } );
-    console.log( finduser );
 
     if ( !finduser ) {
       return res.sendError( 'No user Found For this store', 500 );
@@ -2687,16 +2607,14 @@ export async function eyeTesttask( req, res ) {
     inputBody.approver = inputBody.approver.replace( /,$/, '' );
 
 
-    let title = `New Task Alert ${inputBody.taskName}-${storeDetails.storeName}-${dayjs().format( 'YYYY-MM-DD' )}`;
+    // 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}.`;
-    let userDetails = await userService.findOne( { _id: new mongoose.Types.ObjectId( finduser.userId ) } );
-    console.log( userDetails.fcmToken );
-    if ( userDetails&&userDetails.fcmToken ) {
-      const fcmToken = userDetails.fcmToken;
-      await sendPushNotification( title, description, fcmToken );
-    }
+    // 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 ) ) {
@@ -2824,10 +2742,8 @@ export async function eyeTesttask( req, res ) {
         }
         question[0].questionReferenceImage = images;
       } else {
-        console.log( req.file );
         let images = [];
         let uplaodedImage = await uploadmultiImage( req.files.referenceImage );
-        console.log( uplaodedImage );
         let imgUrl = decodeURIComponent( uplaodedImage.imgUrl.split( '?' )[0] );
         let url = imgUrl.split( '/' );
         if ( url.includes( 'https:' ) || url.includes( 'http:' ) ) {
@@ -3341,337 +3257,6 @@ export async function uploadmultiImage( images ) {
   }
 };
 
-export async function taskAssign( req, res ) {
-  try {
-    if ( !req.body.taskId ) {
-      return res.sendError( 'Checklist id is required', 400 );
-    }
-    if ( !req.body.coverage ) {
-      return res.sendError( 'Coverage is required', 400 );
-    }
-    if ( !req.body.idList ) {
-      return res.sendError( 'Id is required', 400 );
-    }
-
-    let taskDetails = await taskService.findOne( { _id: req.body.taskId } );
-    if ( !taskDetails ) {
-      return res.sendError( 'No data found', 204 );
-    }
-    let assignList = [];
-
-    // for ( let data of req.body.idList ) {
-    //   let assignedData = {
-    //     ...data,
-    //     clientId: req.body.clientId,
-    //     checkListName: taskDetails.checkListName,
-    //     checklistId: taskDetails._id,
-    //     coverage: req.body.coverage,
-    //     insert: false,
-    //   };
-    //   // console.log( assignedData, 'daterthj' );
-    //   let uploadData = await assignUsers( assignedData );
-    //   if ( uploadData ) {
-    //     if ( Array.isArray( uploadData ) ) {
-    //       assignList.push( ...uploadData );
-    //     } else {
-    //       assignList.push( uploadData );
-    //     }
-    //   }
-    // }
-
-    await Promise.all( req.body.idList.map( async ( data ) => {
-      let assignedData = {
-        ...data,
-        clientId: req.body.clientId,
-        checkListName: taskDetails.checkListName,
-        checklistId: taskDetails._id,
-        coverage: req.body.coverage,
-        insert: false,
-      };
-      // console.log( assignedData, 'daterthj' );
-      let uploadData = await assignUsers( assignedData );
-      if ( uploadData ) {
-        if ( Array.isArray( uploadData ) ) {
-          assignList.push( ...uploadData );
-        } else {
-          assignList.push( uploadData );
-        }
-      }
-    } ) );
-
-
-    return res.sendSuccess( { count: assignList.length, assignList } );
-  } catch ( e ) {
-    logger.error( { functionName: 'checklistAssign', error: e } );
-    return res.sendError( e, 500 );
-  }
-}
-
-async function assignUsers( data ) {
-  console.log( data );
-  let assignedData;
-  if ( data.coverage == 'store' ) {
-    if ( data?.type == 'cluster' ) {
-      let query = [
-        {
-          $addFields: {
-            cluster: { $toLower: '$clusterName' },
-          },
-        },
-        {
-          $match: {
-            clientId: data.clientId,
-            ...( !data?.clusterName ) ? { _id: new mongoose.Types.ObjectId( data.id ) } : { cluster: data.clusterName.toLowerCase() },
-          },
-        },
-        {
-          $project: {
-            stores: 1,
-            clusterName: 1,
-          },
-        },
-      ];
-      let clusterDetails = await clusterServices.aggregateCluster( query );
-      if ( clusterDetails.length ) {
-        if ( data.insert ) {
-          assignedData = {
-            checkFlag: true,
-            checkListId: data.checklistId,
-            checkListName: data.checkListName,
-            client_id: data?.clientId,
-            clusterName: clusterDetails?.[0]?.clusterName,
-            assignId: data?.id || clusterDetails?.[0]?._id,
-            coverage: 'store',
-          };
-        } else {
-          let clusterList = clusterDetails[0].stores.map( ( ele ) => ele.store );
-          let storeDetails = await storeService.find( { _id: { $in: clusterList }, status: 'active' } );
-          assignedData = await Promise.all( storeDetails.map( async ( store ) => {
-            let userDetails = await userService.findOne( { email: store.spocDetails?.[0]?.email, clientId: data.clientId } );
-            if ( !userDetails && store?.spocDetails?.length ) {
-              let userData = {
-                userName: store.spocDetails?.[0]?.name,
-                email: store.spocDetails[0]?.email,
-                mobileNumber: store.spocDetails?.[0]?.phone,
-                clientId: data.clientId,
-              };
-              userDetails = await createUser( userData );
-            }
-            let userData = {
-              userId: userDetails?._id,
-              userName: userDetails?.userName,
-              userEmail: userDetails?.email,
-              userPhone: userDetails?.mobileNumber,
-              checkFlag: true,
-              checkListId: data.checklistId,
-              checkListName: data.checkListName,
-              client_id: data.clientId,
-              assignId: data?.id || clusterDetails?.[0]?._id,
-              coverage: 'store',
-              clusterName: clusterDetails?.[0]?.clusterName,
-              storeId: store.storeId,
-              storeName: store.storeName,
-            };
-            return userData;
-          } ) );
-        }
-      }
-    } else {
-      let query = [
-        {
-          $addFields: {
-            store: { $toLower: '$storeName' },
-          },
-        },
-        {
-          $match: {
-            clientId: data.clientId,
-            ...( !data.storeName ) ? { _id: new mongoose.Types.ObjectId( data.id ) } : { store: data.storeName.toLowerCase() },
-          },
-        },
-      ];
-      let storeDetails = await storeService.aggregate( query );
-      if ( storeDetails.length ) {
-        let email = data?.userEmail ? data.userEmail : storeDetails?.[0]?.spocDetails?.[0]?.email;
-        let userDetails = await userService.findOne( { email: email, clientId: data.clientId } );
-        if ( !userDetails ) {
-          let userData = {
-            userName: storeDetails?.[0]?.spocDetails?.[0]?.name,
-            email: storeDetails?.[0]?.spocDetails[0].email,
-            mobileNumber: storeDetails?.[0]?.spocDetails?.[0]?.phone,
-            clientId: data.clientId,
-          };
-          userDetails = await createUser( userData );
-          console.log( 'userDetails =>', userDetails );
-        }
-        assignedData = {
-          store_id: storeDetails?.[0]?.storeId,
-          storeName: storeDetails?.[0]?.storeName,
-          userId: userDetails._id,
-          userName: userDetails.userName,
-          userEmail: userDetails.email,
-          userPhone: userDetails?.mobileNumber,
-          city: storeDetails?.[0]?.storeProfile?.city,
-          country: storeDetails?.[0]?.storeProfile?.country,
-          checkFlag: true,
-          checkListId: data.checklistId,
-          checkListName: data.checkListName,
-          client_id: data.clientId,
-          assignId: data?.id || storeDetails?.[0]?._id,
-          coverage: 'store',
-        };
-      }
-    }
-  } else {
-    if ( data.type == 'teams' ) {
-      let query = [
-        {
-          $addFields: {
-            team: { $toLower: '$teamName' },
-          },
-        },
-        {
-          $match: {
-            clientId: data.clientId,
-            ...( !data?.teamName ) ? { _id: new mongoose.Types.ObjectId( data.id ) } : { team: data.teamName.toLowerCase() },
-          },
-        },
-      ];
-      let teamDetails = await teamsServices.aggregateTeams( query );
-      if ( teamDetails.length ) {
-        if ( data.insert ) {
-          assignedData = {
-            checkFlag: true,
-            checkListId: data.checklistId,
-            checkListName: data.checkListName,
-            client_id: data.clientId,
-            teamName: teamDetails?.[0]?.teamName,
-            assignId: data?.id || teamDetails?.[0]?._id,
-            coverage: 'user',
-          };
-        } else {
-          let userIdList = teamDetails[0].users.map( ( ele ) => ele.userId );
-          let userDetails = await userService.find( { _id: userIdList } );
-          assignedData = userDetails.map( ( user ) => {
-            let userData = {
-              userId: user._id,
-              userName: user.userName,
-              userEmail: user.email,
-              userPhone: user.mobileNumber,
-              checkFlag: true,
-              checkListId: data.checklistId,
-              checkListName: data.checkListName,
-              client_id: data.clientId,
-              assignId: data?.id || teamDetails?.[0]?._id,
-              coverage: 'user',
-              teamName: teamDetails?.[0]?.teamName,
-            };
-            return userData;
-          } );
-        }
-      }
-    } else {
-      let query = [
-        {
-          $addFields: {
-            userEmail: { $toLower: '$email' },
-          },
-        },
-        {
-          $match: {
-            clientId: data.clientId,
-            ...( !data?.userEmail ) ? { _id: new mongoose.Types.ObjectId( data.id ) } : { userEmail: data.userEmail.toLowerCase() },
-          },
-        },
-      ];
-      // console.log( 'data?.userEmail=>', data.userEmail );
-      let userDetails = await userService.aggregate( query );
-      if ( !userDetails.length ) {
-        let userData = {
-          userName: data?.userEmail?.split( '@' )[0],
-          email: data.userEmail,
-          clientId: data.clientId,
-        };
-        // console.log( userData, 'userData', data );
-        let details = await createUser( userData );
-        userDetails = [ details ];
-      }
-      if ( userDetails.length ) {
-        assignedData = {
-          userId: userDetails?.[0]?._id,
-          userName: userDetails?.[0]?.userName,
-          userEmail: userDetails?.[0]?.email,
-          userPhone: userDetails?.[0]?.mobileNumber,
-          checkFlag: true,
-          checkListId: data.checklistId,
-          checkListName: data.checkListName,
-          client_id: data.clientId,
-          assignId: data?.id || userDetails?.[0]?._id,
-          coverage: 'user',
-        };
-      }
-    }
-  }
-
-  // console.log( assignedData, 'test', data );
-  if ( assignedData && !data.upload && data.insert ) {
-    await taskAssignService.updateOne( { checkListId: assignedData.checkListId, assignId: assignedData.assignId }, assignedData );
-  } else {
-    return assignedData;
-  }
-}
-
-export async function assignTaskUser( req, res ) {
-  try {
-    let inputBody = req.body;
-    let assignDetails = inputBody.assignUsers;
-    let newUsers = inputBody.newUsers;
-    let taskDetails = await taskService.findOne( { _id: inputBody.taskId } );
-    if ( !taskDetails ) {
-      return res.sendError( 'No data found', 204 );
-    }
-    // await Promise.all( newUsers.map( async ( user ) => {
-    //   let getUser = inputBody.assignUsers.find( ( ele ) => ele.userEmail.toLowerCase() == user.toLowerCase() );
-    //   let userData = {
-    //     userName: getUser.userName,
-    //     email: user,
-    //     mobileNumber: getUser?.phone,
-    //     clientId: inputBody.clientId,
-    //   };
-    //   await createUser( userData );
-    // } ) );
-    for ( let i = 0; i < newUsers.length; i++ ) {
-      let getUser = inputBody.assignUsers.find( ( ele ) => ele.userEmail.toLowerCase() == newUsers[i].toLowerCase() );
-      let userData = {
-        userName: getUser.userName,
-        email: newUsers[i],
-        mobileNumber: getUser?.phone,
-        clientId: inputBody.clientId,
-      };
-      await createUser( userData );
-    }
-    let assignData = [];
-    await Promise.all( assignDetails.map( async ( assign ) => {
-      assign.checklistId = inputBody.taskId;
-      assign.checkListName = taskDetails.checkListName;
-      assign.coverage = inputBody.coverage;
-      assign.clientId = inputBody.clientId;
-      assign.upload = inputBody.type;
-      let uploadData = await assignUsers( assign );
-      if ( uploadData ) {
-        if ( Array.isArray( uploadData ) ) {
-          assignData.push( ...uploadData );
-        } else {
-          assignData.push( uploadData );
-        }
-      }
-    } ) );
-    return res.sendSuccess( { idList: [ ...new Set( assignData.map( ( item ) => item?.assignId?.toString() ) ) ], assignData } );
-  } catch ( e ) {
-    logger.error( { functionName: 'assignTaskUser', error: e } );
-    return res.sendError( e, 500 );
-  }
-}
 
 export async function customertrial( params ) {
   try {

package/src/routes/task.routes.js

@@ -28,9 +28,6 @@ taskRouter
     .get( '/teamMigrations', taskController.teamMigrations )
     .get( '/clusterMigrations', taskController.clusterMigrations )
     .post( '/createaiChecklist', isAllowedInternalAPIHandler, taskController.createAiChecklist )
-    .post( '/createaiTask', isAllowedInternalAPIHandler, taskController.createAiTask )
-    .post( '/assign', isAllowedSessionHandler, taskController.taskAssign )
-    .post( '/assignUpload', isAllowedSessionHandler, taskController.assignTaskUser )
     .post( '/createaiTask', isAllowedInternalAPIHandler, validate( aitaskvalidation ), taskController.createAiTask )
     .post( '/StoreHygienetask', isAllowedInternalAPIHandler, validate( StoreHygienetaskvalidation ), taskController.StoreHygienetask )
     .post( '/eyeTesttask', isAllowedInternalAPIHandler, validate( eyeTesttaskvalidation ), taskController.eyeTesttask )

package/src/service/cluster.service.js

@@ -26,7 +26,6 @@ export async function createclusterModel( data ) {
 export async function findcluster( query, project ) {
   return await clusterModel.find( query, project );
 };
-
 export function countDocumentsClusters( query ) {
   return clusterModel.countDocuments( query );
 }

package/src/service/taskAssign.service.js

@@ -13,7 +13,7 @@ export const updateMany = async ( query = {}, record={} ) => {
 };
 
 export const updateOne = async ( query = {}, record={} ) => {
-  return model.taskAssignModel.updateOne( query, { $set: record }, { upsert: true } );
+  return model.taskAssignModel.updateOne( query, { $set: record } );
 };
 
 export const insertMany = async ( data = [] ) => {

package/src/service/user.service.js

@@ -20,10 +20,6 @@ export const updateOne = async ( query = {}, record={} ) => {
   return model.userModel.updateOne( query, { $set: record } );
 };
 
-export const upsert = async ( query = {}, record={} ) => {
-  return model.userModel.updateOne( query, { $set: record }, { upsert: true } );
-};
-
 export const aggregate = async ( query = {} ) => {
   return model.userModel.aggregate( query );
 };

package/src/service/teams.service copy.js

@@ -1,30 +0,0 @@
-import teamsModel from 'tango-api-schema/schema/teams.model.js';
-
-
-export async function createTeamsModel( data ) {
-  return await teamsModel.create( data );
-};
-export async function updateOneTeams( query, record ) {
-  return await teamsModel.updateOne( query, { $set: record }, { upsert: true } );
-};
-
-export async function aggregateTeams( query ) {
-  return await teamsModel.aggregate( query );
-};
-export async function deleteTeams( query ={} ) {
-  return await teamsModel.deleteOne( query );
-};
-
-export async function findOneTeams( query ={}, field={} ) {
-  return await teamsModel.findOne( query, field );
-};
-export async function findteams( query ={}, field={} ) {
-  return await teamsModel.find( query, field );
-};
-
-export async function updateOneTeamModel( query, record ) {
-  return await teamsModel.updateOne( query, record );
-}
-export function countDocumentsTeams( query ) {
-  return teamsModel.countDocuments( query );
-}