tango-app-api-task 3.2.1-beta-20 → 3.2.1-beta-21

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-task",
-    "version": "3.2.1-beta-20",
+    "version": "3.2.1-beta-21",
     "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.49",
-        "tango-app-api-middleware": "^3.1.55",
+        "tango-api-schema": "^2.2.52",
+        "tango-app-api-middleware": "^3.1.58",
         "winston": "^3.17.0",
         "winston-daily-rotate-file": "^5.0.0"
     },

package/src/controllers/task.controller.js

@@ -8,7 +8,9 @@ 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 clusterModel from '../service/cluster.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 domainService from '../service/domain.service.js';
 import mongoose from 'mongoose';
 const ObjectId = mongoose.Types.ObjectId;
@@ -125,38 +127,6 @@ 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,
@@ -294,9 +264,9 @@ export async function taskDetails( req, res ) {
     }
     if ( storechecklistdetails ) {
       result.checkListDetails = { ...storechecklistdetails._doc };
-      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 } };
+      let assignedusers = await taskAssignService.find( { checkListId: storechecklistdetails._id }, { _id: 1 } );
+      assignedusers = assignedusers?.map( ( item ) => item._id );
+      result.checkListDetails = { ...result.checkListDetails, ...{ sections: sectionList }, ...{ assignedusers: assignedusers } };
     }
     return res.sendSuccess( result );
   } catch ( e ) {
@@ -595,11 +565,8 @@ 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 ) } } ];
+    let query = [ { $match: { checkListId: new ObjectId( req.query.taskId ), ...( req.query.coverage ) ? { coverage: req.query.coverage } : {}, isdeleted: false } } ];
     if ( req.query?.search?.trim() && req.query?.search?.trim() != '' ) {
       let searchValue = req.query.search;
       searchValue = searchValue.split( ',' ).map( ( item ) => item.trim().toLowerCase() );
@@ -611,17 +578,6 @@ 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 ) {
@@ -629,19 +585,70 @@ export async function userDetails( req, res ) {
     }
 
     let userDetails = [];
-    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 } );
+    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 ) } } );
+          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 } );
   } catch ( e ) {
     logger.error( { functionName: 'userDetails', error: e, message: req.body } );
     return res.sendError( e, 500 );
@@ -651,8 +658,6 @@ 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 ) {
@@ -682,7 +687,7 @@ export async function taskConfig( req, res ) {
     };
     await checklistLogs.create( logInsertData );
 
-    checklistDetails = await taskService.findOne( { _id: inputBody._id, isdeleted: false } );
+    checklistDetails = await taskService.findOne( { _id: inputBody._id, isdeleted: false, client_id: inputBody.clientId } );
 
     if ( !checklistDetails ) {
       return res.sendError( 'No data found', 204 );
@@ -720,39 +725,20 @@ export async function taskConfig( req, res ) {
         await traxApprover.insertMany( data );
       }
     }
-    await taskAssignService.updateMany( { checkListId: inputBody._id }, { checkFlag: true } );
-    if ( inputBody.removedUsers.length ) {
-      await taskAssignService.updateMany( { _id: { $in: inputBody.removedUsers } }, { checkFlag: false } );
+    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,
+        };
+        await assignUsers( data );
+      } ) );
     }
     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' );
@@ -910,7 +896,6 @@ 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 );
           }
@@ -938,7 +923,80 @@ async function insertPCBulkV3( getCLconfig, checklistId, updatedchecklist, date,
 
   if ( allQuestion ) {
     let userIdList = [];
-    for ( let element4 of allQuestion ) {
+    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 } } );
+          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 ) => {
       let query;
       query = {
         date_string: dayjs( date ).format( 'YYYY-MM-DD' ),
@@ -954,38 +1012,39 @@ async function insertPCBulkV3( getCLconfig, checklistId, updatedchecklist, date,
       let getsubmitDetails = await taskProcessedService.find( query );
       if ( getsubmitDetails.length ) {
         userIdList.push( element4._id );
-        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;
-    }
+      } 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 );
+      }
+    } ) );
     if ( userIdList.length ) {
       allQuestion = allQuestion.filter( ( item ) => typeof item._id == 'undefined' );
     }
@@ -1390,8 +1449,9 @@ export async function createChecklistTask( req, res ) {
         if ( sectionIndex == -1 ) {
           return res.sendError( 'section is not found', 400 );
         }
-        let data = { ...question[sectionIndex].questions[req.body.qno - 1], taskId: response?._id, task: true };
+        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[findQuestion], taskId: response?._id, task: true };
         question[sectionIndex].questions[req.body.qno - 1] = data;
         taskDetails.questionAnswers = question;
         let updateData = {
@@ -2168,13 +2228,13 @@ export async function clusterMigrations( req, res ) {
       if ( userexits ) {
         let findStore = await storeService.findOne( { storeName: user.FacilityCode } );
         if ( findStore ) {
-          let clusterExists = await clusterModel.findOneCluster( { clusterName: user.AomName } );
+          let clusterExists = await clusterServices.findOneCluster( { clusterName: user.AomName } );
           if ( clusterExists ) {
             let data = {
               storeId: findStore.storeId,
               store: findStore._id,
             };
-            let updatecluster = await clusterModel.updateCluster( { clusterName: user.AomName }, { $push: { stores: data } } );
+            let updatecluster = await clusterServices.updateCluster( { clusterName: user.AomName }, { $push: { stores: data } } );
             console.log( updatecluster );
           } else {
             let payload = {
@@ -2196,7 +2256,7 @@ export async function clusterMigrations( req, res ) {
               ],
               'users': [],
             };
-            let createcluster = await clusterModel.createclusterModel( payload );
+            let createcluster = await clusterServices.createclusterModel( payload );
             console.log( createcluster );
           }
         }
@@ -3268,6 +3328,340 @@ 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 idList;
+    let assignList;
+    if ( req.body.coverage == 'store' ) {
+      let clusterDetails = await clusterServices.findcluster( { _id: { $in: req.body.idList } }, { stores: 1, clusterName: 1 } );
+      if ( clusterDetails.length ) {
+        let clusterList = clusterDetails.map( ( item ) => item._id.toString() );
+        idList = [
+          ...clusterDetails.flatMap( ( item ) => item.stores.map( ( ele ) => ele.store ) ),
+          ...req.body.idList.filter( ( ele ) => !clusterList.includes( ele ) ),
+        ];
+      } else {
+        idList = req.body.idList;
+      }
+      let getStoreDetails = await storeService.find( { _id: { $in: idList } } );
+      if ( !getStoreDetails.length ) {
+        return res.sendError( 'No data found', 204 );
+      }
+      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,
+          clusterName: clusterDetails?.clusterName,
+        };
+        return data;
+      } ) );
+    } else {
+      let teamDetails = await teamsServices.findteams( { _id: { $in: req.body.idList } }, { users: 1, teamName: 1 } );
+      if ( teamDetails.length ) {
+        let teamList = teamDetails.map( ( ele ) => ele._id.toString() );
+        idList = [
+          ...teamDetails.flatMap( ( item ) => item.users.map( ( ele ) => ele.userId ) ),
+          ...req.body.idList.filter( ( ele ) => !teamList.includes( ele._id ) ),
+        ];
+      } else {
+        idList = req.body.idList;
+      }
+      let userDetails = await userService.find( { _id: { $in: idList } } );
+      if ( !userDetails.length ) {
+        return res.sendError( 'No data found', 204 );
+      }
+      assignList = [];
+      userDetails.forEach( ( user ) => {
+        assignList.push( {
+          userId: user._id,
+          userName: user.userName,
+          userEmail: user.email,
+          userPhone: user?.mobileNumber,
+          teamName: teamDetails?.teamName,
+        } );
+      } );
+    }
+    return res.sendSuccess( { count: assignList.length, assignList } );
+  } catch ( e ) {
+    logger.error( { functionName: 'checklistAssign', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+
+async function assignUsers( data ) {
+  let assignedData;
+  if ( data.coverage == 'store' ) {
+    if ( data?.type == 'cluster' ) {
+      let query = [
+        {
+          $addFields: {
+            cluster: { $toLower: '$clusterName' },
+          },
+        },
+        {
+          $match: {
+            clientId: data.clientId,
+            ...( !data?.upload ) ? { _id: new mongoose.Types.ObjectId( data.id ) } : { cluster: data.clusterName.toLowerCase() },
+          },
+        },
+        {
+          $project: {
+            stores: 1,
+            clusterName: 1,
+          },
+        },
+      ];
+      let clusterDetails = await clusterServices.aggregateCluster( query );
+      console.log( clusterDetails );
+      if ( clusterDetails.length ) {
+        if ( !data.upload ) {
+          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: clusterList } );
+          assignedData = await Promise.all( storeDetails.map( async ( store ) => {
+            let userDetails = await userService.findOne( { email: store.spocDetails?.[0]?.email, clientId: data.clientId } );
+            if ( !userDetails ) {
+              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',
+              teamName: clusterDetails?.[0]?.clusterName,
+            };
+            return userData;
+          } ) );
+        }
+      }
+    } else {
+      let query = [
+        {
+          $addFields: {
+            store: { $toLower: '$storeName' },
+          },
+        },
+        {
+          $match: {
+            clientId: data.clientId,
+            ...( !data.upload ) ? { _id: new mongoose.Types.ObjectId( data.id ) } : { store: data.storeName.toLowerCase() },
+          },
+        },
+      ];
+      let storeDetails = await storeService.aggregate( query );
+      if ( storeDetails.length ) {
+        let email = data?.upload ? 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 );
+        }
+        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?.upload ) ? { _id: new mongoose.Types.ObjectId( data.id ) } : { team: data.teamName.toLowerCase() },
+          },
+        },
+      ];
+      let teamDetails = await teamsServices.aggregateTeams( query );
+      if ( teamDetails.length ) {
+        if ( !data.upload ) {
+          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?.upload ) ? { _id: new mongoose.Types.ObjectId( data.id ) } : { userEmail: data.userEmail.toLowerCase() },
+          },
+        },
+      ];
+      let userDetails = await userService.aggregate( query );
+      if ( !userDetails.length ) {
+        let userData = {
+          userName: data.userEmail.split( '@' )[0],
+          email: data.userEmail,
+          clientId: data.clientId,
+        };
+        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',
+        };
+      }
+    }
+  }
+  if ( assignedData && !data.upload ) {
+    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 );
+    } ) );
+    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 ( Array.isArray( uploadData ) ) {
+        assignData.push( ...uploadData );
+      } else {
+        assignData.push( uploadData );
+      }
+    } ) );
+    return res.sendSuccess( { idList: [ ...new Set( assignData.map( ( item ) => item.assignId ) ) ], 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,6 +28,9 @@ 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,6 +26,7 @@ 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 } );
+  return model.taskAssignModel.updateOne( query, { $set: record }, { upsert: true } );
 };
 
 export const insertMany = async ( data = [] ) => {

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

@@ -0,0 +1,30 @@
+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 );
+}