tango-app-api-task 3.2.1-beta-30 → 3.2.1-beta-32

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-task",
-    "version": "3.2.1-beta-30",
+    "version": "3.2.1-beta-32",
     "description": "Task",
     "main": "index.js",
     "type": "module",

package/src/controllers/task.controller.js

@@ -264,9 +264,29 @@ 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 query = {
+        checkListId: storechecklistdetails._id,
+        ...( storechecklistdetails.coverage == 'store' ) ? { $or: [ { store_id: { $exists: true } }, { clusterName: { $exists: true } } ] } : { $or: [ { userEmail: { $exists: true } }, { teamName: { $exists: true } } ] },
+      };
+      let assignList = await taskAssignService.find( query, { _id: 1, store_id: 1, clusterName: 1, userEmail: 1, teamName: 1, assignId: 1 } );
+      let singleAssign;
+      let groupAssign;
+      if ( storechecklistdetails.coverage == 'store' ) {
+        singleAssign = assignList.filter( ( item ) => typeof item?.store_id != 'undefined' && item?.store_id != '' ).map( ( item ) => {
+          return { id: item.assignId, type: 'store' };
+        } );
+        groupAssign = assignList.filter( ( item ) => typeof item?.clusterName != 'undefined' && item?.clusterName != '' ).map( ( item ) => {
+          return { id: item.assignId, type: 'cluster' };
+        } );
+      } else {
+        singleAssign = assignList.filter( ( item ) => typeof item?.userEmail != 'undefined' && item?.userEmail !='' ).map( ( item ) => {
+          return { id: item.assignId, type: 'user' };
+        } );
+        groupAssign = assignList.filter( ( item ) => typeof item?.teamName != 'undefined' && item?.teamName != '' ).map( ( item ) => {
+          return { id: item.assignId, type: 'teams' };
+        } );
+      }
+      result.checkListDetails = { ...result.checkListDetails, ...{ sections: sectionList }, singleAssign, groupAssign };
     }
     return res.sendSuccess( result );
   } catch ( e ) {
@@ -435,6 +455,179 @@ export async function validateUser( req, res ) {
   }
 };
 
+export const validateUserv1 = async ( req, res ) => {
+  try {
+    if ( !req.body.assignedUsers.length ) {
+      return res.sendError( 'Please Enter user Details', 400 );
+    }
+
+    let assignDetails = req.body.assignedUsers;
+
+    if ( req.body.coverage == 'store' ) {
+      const duplicateStore = assignDetails.reduce( ( acc, obj ) => {
+        if ( !acc[obj.storeName.toLowerCase()] ) {
+          acc[obj.storeName.toLowerCase()] = {
+            email: [ obj.userEmail.toLowerCase() ],
+            count: 1,
+          };
+        } else {
+          if ( acc[obj.storeName.toLowerCase()] ) {
+            if ( acc[obj.storeName.toLowerCase()].email.includes( obj.userEmail.toLowerCase() ) ) {
+              acc[obj.storeName.toLowerCase()].count++;
+            } else {
+              acc[obj.storeName.toLowerCase()].email.push( obj.userEmail.toLowerCase() );
+            }
+          }
+        }
+        return acc;
+      }, {} );
+
+      const duplicateStores = Object.keys( duplicateStore ).filter( ( storeName ) => duplicateStore[storeName].count > 1 );
+      if ( duplicateStores.length ) {
+        return res.sendSuccess( { validate: false, ExistsEmail: duplicateStores, message: 'Store and email is duplicated' } );
+      }
+    } else {
+      const duplicateUser = assignDetails.reduce( ( acc, obj ) => {
+        if ( !acc[obj.userEmail.toLowerCase()] ) {
+          acc[obj.userEmail.toLowerCase()] = {
+            name: [ obj.userName.toLowerCase() ],
+            count: 1,
+          };
+        } else {
+          if ( acc[obj.userEmail.toLowerCase()] ) {
+            if ( acc[obj.userEmail.toLowerCase()].name.includes( obj.userName.toLowerCase() ) ) {
+              acc[obj.userEmail.toLowerCase()].count++;
+            } else {
+              acc[obj.userEmail.toLowerCase()].name.push( obj.userEmail.toLowerCase() );
+            }
+          }
+        }
+        return acc;
+      }, {} );
+
+      const duplicateUsers = Object.keys( duplicateUser ).filter( ( storeName ) => duplicateUser[storeName].count > 1 );
+      if ( duplicateUsers.length ) {
+        return res.sendSuccess( { validate: false, ExistsEmail: duplicateUsers, message: 'Email is Duplicated' } );
+      }
+    }
+
+    if ( req.body.hasOwnProperty( 'addSingle' ) ) {
+      let checkExists = await taskAssignService.findOne( { userEmail: assignDetails[0]?.userEmail, storeName: assignDetails[0]?.storeName, checkListId: req.body.id } );
+      if ( checkExists ) {
+        return res.sendError( 'User already Exists', 400 );
+      }
+    }
+
+    let userEmailList = assignDetails.map( ( item ) => item.userEmail.toLowerCase() );
+    let storeList = assignDetails.map( ( item ) => item?.storeName?.toLowerCase() );
+
+    let userQuery = [
+      {
+        $project: {
+          newEmail: { $toLower: '$email' },
+          isActive: 1,
+          clientId: 1,
+        },
+      },
+      {
+        $match: {
+          newEmail: { $in: userEmailList },
+          isActive: true,
+          clientId: req.body.clientId,
+        },
+      },
+    ];
+
+    let emailCheckQuery = [
+      {
+        $project: {
+          newEmail: { $toLower: '$email' },
+          isActive: 1,
+          clientId: 1,
+        },
+      },
+      {
+        $match: {
+          newEmail: { $in: userEmailList },
+          isActive: true,
+          clientId: { $ne: req.body.clientId },
+        },
+      },
+    ];
+
+    let storeQuery = [
+      {
+        $project: {
+          'storeName': { $toLower: '$storeName' },
+          'clientId': 1,
+          'storeProfile.city': 1,
+          'status': 1,
+          'storeId': 1,
+        },
+      },
+      {
+        $match: {
+          clientId: req.body.clientId,
+          storeName: { $in: storeList },
+        },
+      },
+    ];
+
+    let [ userDetails, storeDetails, existEmail ] = await Promise.all( [
+      await userService.aggregate( userQuery ),
+      await storeService.aggregate( storeQuery ),
+      await userService.aggregate( emailCheckQuery ),
+    ] );
+
+    existEmail = existEmail.map( ( ele ) => ele.newEmail );
+    let existUserEmail = userDetails.map( ( ele ) => ele.newEmail );
+    let newUserList = userEmailList.filter( ( ele ) => !existUserEmail.includes( ele ) && !existEmail.includes( ele ) );
+    let inActiveStores = storeDetails.filter( ( ele ) => ele.status == 'deactive' ).map( ( ele ) => ele.storeName );
+
+    let existsStore = storeDetails.map( ( ele ) => ele?.storeName );
+    let newStoreList = storeList.filter( ( ele ) => ele != null && !existsStore.includes( ele.toLowerCase() ) );
+    if ( req.body.coverage == 'store' ) {
+      assignDetails.forEach( ( item ) => {
+        let getStoreId = storeDetails.find( ( store ) => store.storeName.toLowerCase() == item.storeName.toLowerCase() );
+        if ( getStoreId ) {
+          item._id = getStoreId._id;
+          item.storeId = getStoreId.storeId;
+        }
+      } );
+    } else {
+      assignDetails.forEach( ( item ) => {
+        let getUserId = userDetails.find( ( user ) => user.newEmail.toLowerCase() == item.userEmail.toLowerCase() );
+        if ( getUserId ) {
+          item._id = getUserId._id;
+        }
+      } );
+    }
+
+    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 );
+    }
+    if ( req.body.coverage == 'user' ) {
+      await Promise.all( newUserList.map( async ( ele ) => {
+        let findUserIndex = assignDetails.findIndex( ( item ) => item?.userEmail?.toLowerCase() == ele?.toLowerCase() );
+        if ( findUserIndex != -1 ) {
+          let data = {
+            userName: assignDetails[findUserIndex]?.userName,
+            email: ele,
+            mobileNumber: assignDetails[findUserIndex]?.mobileNumber,
+            clientId: req.body.clientId,
+          };
+          let response = await createUser( data );
+          assignDetails[findUserIndex]._id = response._id;
+        }
+      } ) );
+    }
+    return res.sendSuccess( { validate: true, data: assignDetails } );
+  } catch ( e ) {
+    logger.error( 'validateUser 2=>', e );
+    return res.sendError( e, 500 );
+  }
+};
+
 async function uploadUser( req, res ) {
   try {
     let inputBody = req.body;
@@ -565,45 +758,29 @@ 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 } } ];
-    if ( req.query?.search?.trim() && req.query?.search?.trim() != '' ) {
-      let searchValue = req.query.search;
-      searchValue = searchValue.split( ',' ).map( ( item ) => item.trim().toLowerCase() );
-      if ( searchValue.length > 1 ) {
-        query.push( { $addFields: { storeLower: { $toLower: '$storeName' } } } );
-        query.push( { $match: { storeLower: { $in: searchValue } } } );
-      } else {
-        query.push( { $match: { storeName: { $regex: req.query.search.trim(), $options: 'i' } } } );
-      }
-    }
+    let query = [ { $match: { checkListId: new ObjectId( req.query.taskId ), isdeleted: false } }, { $sort: { _id: -1 } } ];
 
     let taskDetails = await taskAssignService.aggregate( query );
-
-    if ( !taskDetails[0].data.length ) {
+    if ( !taskDetails.length ) {
       return res.sendError( 'No data found', 204 );
     }
 
     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,
+              _id: ele.assignId,
               userName: item.spocDetails?.[0]?.name,
               userEmail: item.spocDetails?.[0]?.email,
-              store_id: item?.storeId,
+              storeId: item?.storeId,
               storeName: item?.storeName,
               userPhone: item.spocDetails?.[0]?.phone,
               city: ele?.city,
@@ -619,10 +796,10 @@ export async function userDetails( req, res ) {
           let teamUserDetails = await userService.find( { _id: { $in: teamDetails.users.map( ( item ) => item.userId ) } } );
           teamUserDetails.forEach( ( item ) => {
             userDetails.push( {
-              id: ele._id,
+              _id: ele.assignId,
               userName: item.userName,
               userEmail: item.email,
-              store_id: ele?.storeId,
+              storeId: ele?.storeId,
               storeName: ele?.storeName,
               userPhone: item?.mobileNumber,
               city: ele?.city,
@@ -634,10 +811,10 @@ export async function userDetails( req, res ) {
         }
       } else {
         userDetails.push( {
-          id: ele._id,
+          _id: ele.assignId,
           userName: ele.userName,
           userEmail: ele.userEmail,
-          store_id: ele?.store_id,
+          storeId: ele?.store_id,
           storeName: ele?.storeName,
           userPhone: ele.userPhone,
           city: ele.city,
@@ -648,9 +825,9 @@ export async function userDetails( req, res ) {
       }
     } ) );
 
-    return res.sendSuccess( { count: userDetails.length, storeList, userList, users: limitedData } );
+    return res.sendSuccess( { count: userDetails.length, userDetails } );
   } catch ( e ) {
-    logger.error( { functionName: 'userDetails', error: e, message: req.body } );
+    logger.error( 'userDetails =>', e );
     return res.sendError( e, 500 );
   }
 };
@@ -729,20 +906,6 @@ 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 );
-      } ) );
-    }
     let storeConfigDetails = await taskAssignService.find( { checkListId: inputBody._id, checkFlag: true }, { _id: 0, store_id: 1, userEmail: 1, storeName: 1 } );
     if ( inputBody.submitType == 'publish' ) {
       let taskName = checklistDetails.checkListName;
@@ -916,6 +1079,10 @@ export async function insertSingleProcessData( checklistId ) {
 
 async function insertPCBulkV3( getCLconfig, checklistId, updatedchecklist, date, startTimeIso, endTimeIso, insertdata ) {
   let getquestionQuery = [];
+  if ( dayjs( getCLconfig.publishDate ).format( 'YYYY-MM-DD' ) != dayjs( date ).format( 'YYYY-MM-DD' ) ) {
+    let todayDate = `${dayjs( date ).format( 'YYYY-MM-DD' )} 00:00 AM`;
+    startTimeIso = dayjs( todayDate, 'YYYY-MM-DD HH:mm A' );
+  }
   getquestionQuery.push( {
     $match: {
       checkListId: new ObjectId( checklistId ),
@@ -3341,6 +3508,68 @@ export async function uploadmultiImage( images ) {
   }
 };
 
+async function assignUsers( data ) {
+  let assignedData;
+  if ( data?.type == 'cluster' ) {
+    let clusterDetails = await clusterServices.findcluster( { clientId: data.clientId, _id: new mongoose.Types.ObjectId( data.id ) } );
+    if ( clusterDetails.length ) {
+      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 userData = {
+          storeId: store.storeId,
+          storeName: store.storeName,
+          userName: store.spocDetails?.[0]?.name,
+          userEmail: store.spocDetails?.[0]?.email,
+          clusterName: clusterDetails?.[0]?.clusterName,
+          id: clusterDetails?.[0]?._id,
+        };
+        return userData;
+      } ) );
+    }
+  } else {
+    let teamDetails = await teamsServices.findteams( { clientId: data.clientId, _id: new mongoose.Types.ObjectId( data.id ) } );
+    if ( teamDetails.length ) {
+      let userIdList = teamDetails[0].users.map( ( ele ) => ele.userId );
+      let userDetails = await userService.find( { _id: userIdList } );
+      assignedData = userDetails.map( ( user ) => {
+        let userData = {
+          userName: user.userName,
+          userEmail: user.email,
+          teamName: teamDetails?.[0]?.teamName,
+          id: teamDetails?.[0]?._id,
+        };
+        return userData;
+      } );
+    }
+  }
+  return assignedData;
+}
+
+export async function customertrial( params ) {
+  try {
+    // let inputData = {
+    //   Bucket: 'tango-trax-audit',
+    //   file_path: 'trail/59-147/b1c5b15c0133dec0c45640d923fda221_10_09_59_000_24_01_2025_false.mp4',
+    // };
+    // let url = await signedUrl( inputData );
+    // console.log( url );
+
+
+    let inputData = {
+      Bucket: 'tango-trax-audit',
+      Key: 'hygiene/16-01-2025/11-2212/11-2212_13d76f2dd3ea3123aa476a885893c9fd_labelled.jpeg',
+    };
+
+
+    let url = await getObject( inputData );
+    console.log( url );
+  } catch ( e ) {
+    logger.error( 'uploadImage =>', e );
+    return e;
+  }
+};
+
 export async function taskAssign( req, res ) {
   try {
     if ( !req.body.taskId ) {
@@ -3357,343 +3586,128 @@ export async function taskAssign( req, res ) {
     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 );
-    //     }
-    //   }
-    // }
+    let uniqueArr = [];
 
     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 );
-        }
+      if ( uploadData.length ) {
+        uniqueArr.push( ...uploadData );
       }
     } ) );
 
+    if ( uniqueArr.length ) {
+      if ( req.body.coverage == 'store' ) {
+        uniqueArr = uniqueArr.reduce( ( acc, obj ) => {
+          if ( acc[obj.storeName] ) {
+            acc[obj.storeName].clusterName += ',' + obj.clusterName;
+          } else {
+            acc[obj.storeName] = { ...obj };
+          }
+          return acc;
+        }, {} );
+
+        uniqueArr= Object.values( uniqueArr );
+      } else {
+        uniqueArr = uniqueArr.reduce( ( acc, obj ) => {
+          if ( acc[obj.userEmail] ) {
+            acc[obj.userEmail].teamName += ','+ obj.teamName;
+          } else {
+            acc[obj.userEmail] = { ...obj };
+          }
+          return acc;
+        }, {} );
+        uniqueArr = Object.values( uniqueArr );
+      }
+    }
 
-    return res.sendSuccess( { count: assignList.length, assignList } );
+    return res.sendSuccess( { count: uniqueArr.length, uniqueArr } );
   } catch ( e ) {
-    logger.error( { functionName: 'checklistAssign', error: e } );
+    logger.error( { functionName: 'taskAssign', 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?.id ) ? { _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?.id ) ? { _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',
-        };
-      }
+export async function updateAssign( req, res ) {
+  try {
+    if ( !req.body.assignedList.length && !req.body.assignedGroup.length ) {
+      return res.sendError( 'No data found', 204 );
     }
-  } else {
-    if ( data.type == 'teams' ) {
-      let query = [
-        {
-          $addFields: {
-            team: { $toLower: '$teamName' },
-          },
-        },
-        {
-          $match: {
-            clientId: data.clientId,
-            ...( data?.id ) ? { _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 taskDetails = await taskService.findOne( { _id: req.body.taskId, client_id: req.body.clientId } );
+    if ( !taskDetails ) {
+      return res.sendError( 'No data found', 204 );
+    }
+    req.body.assignedGroup = [ ...new Set( req.body.assignedGroup.map( ( item ) => item.id ) ) ];
+    req.body.assignedGroup = req.body.assignedGroup.map( ( ele ) => {
+      return { id: ele };
+    } );
+    await taskAssignService.deleteMany( { checkListId: req.body.taskId } );
+    let assignedUserList = [];
+    await Promise.all( req.body.assignedList.map( async ( assign ) => {
       let query = [
         {
           $addFields: {
-            userEmail: { $toLower: '$email' },
+            emailToLower: { $toLower: '$email' },
           },
         },
         {
           $match: {
-            clientId: data.clientId,
-            ...( data?.id ) ? { _id: new mongoose.Types.ObjectId( data.id ) } : { userEmail: data.userEmail.toLowerCase() },
+            clientId: req.body.clientId,
+            emailToLower: assign.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',
+          userName: assign.userName,
+          email: assign.userEmail,
+          mobileNumber: assign?.phone || '',
+          clientId: req.body.clientId,
         };
+        userDetails = await createUser( userData );
       }
-    }
-  }
-
-  // console.log( assignedData, 'test', data );
-  if ( assignedData && 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,
+      let data = {
+        ...assign,
+        store_id: assign?.storeId,
+        client_id: req.body.clientId,
+        checkListId: req.body.taskId,
+        coverage: req.body.coverage,
+        assignId: assign._id,
+        userId: userDetails._id,
+        checkListName: taskDetails.checkListName,
       };
-      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 );
-        }
+      delete data._id;
+      assignedUserList.push( data );
+    } ) );
+    await Promise.all( req.body.assignedGroup.map( async ( assign ) => {
+      let groupDetails;
+      if ( req.body.coverage == 'store' ) {
+        groupDetails = await clusterServices.findOneCluster( { _id: assign.id } );
+      } else {
+        groupDetails = await teamsServices.findOneTeams( { _id: assign.id } );
+      }
+      if ( groupDetails ) {
+        let groupData = {
+          client_id: req.body.clientId,
+          checkListId: req.body.taskId,
+          coverage: req.body.coverage,
+          assignId: assign.id,
+          checkListName: taskDetails.checkListName,
+          ...( req.body.coverage == 'store' ) ? { clusterName: groupDetails?.clusterName } : { teamName: groupDetails?.teamName },
+        };
+        assignedUserList.push( groupData );
       }
     } ) );
-    return res.sendSuccess( { idList: [ ...new Set( assignData.map( ( item ) => item?.assignId?.toString() ) ) ], assignData } );
+    await taskAssignService.insertMany( assignedUserList );
+    return res.sendSuccess( 'Assign details updated successfully' );
   } catch ( e ) {
-    logger.error( { functionName: 'assignTaskUser', error: e } );
+    logger.error( { functionName: 'updateAssign', error: e } );
     return res.sendError( e, 500 );
   }
 }
 
-export async function customertrial( params ) {
-  try {
-    // let inputData = {
-    //   Bucket: 'tango-trax-audit',
-    //   file_path: 'trail/59-147/b1c5b15c0133dec0c45640d923fda221_10_09_59_000_24_01_2025_false.mp4',
-    // };
-    // let url = await signedUrl( inputData );
-    // console.log( url );
-
-
-    let inputData = {
-      Bucket: 'tango-trax-audit',
-      Key: 'hygiene/16-01-2025/11-2212/11-2212_13d76f2dd3ea3123aa476a885893c9fd_labelled.jpeg',
-    };
-
-
-    let url = await getObject( inputData );
-    console.log( url );
-  } catch ( e ) {
-    logger.error( 'uploadImage =>', e );
-    return e;
-  }
-};
-

package/src/routes/task.routes.js

@@ -10,7 +10,7 @@ taskRouter
     .post( '/delete/:taskIds', isAllowedSessionHandler, isAllowedClient, accessVerification( { userType: [ 'tango', 'client' ], access: [ { featureName: 'TangoTrax', name: 'Task', permissions: [ 'isEdit' ] } ] } ), taskController.deleteTask )
     .get( '/details', isAllowedSessionHandler, isAllowedClient, accessVerification( { userType: [ 'tango', 'client' ], access: [ { featureName: 'TangoTrax', name: 'Task', permissions: [] } ] } ), taskController.taskDetails )
     .get( '/userDetails', isAllowedSessionHandler, isAllowedClient, accessVerification( { userType: [ 'tango', 'client' ], access: [ { featureName: 'TangoTrax', name: 'Task', permissions: [] } ] } ), taskController.userDetails )
-    .post( '/upload', isAllowedSessionHandler, isAllowedClient, accessVerification( { userType: [ 'tango', 'client' ], access: [ { featureName: 'TangoTrax', name: 'Task', permissions: [ 'isEdit' ] } ] } ), taskController.validateUser )
+    .post( '/upload', isAllowedSessionHandler, isAllowedClient, accessVerification( { userType: [ 'tango', 'client' ], access: [ { featureName: 'TangoTrax', name: 'Task', permissions: [ 'isEdit' ] } ] } ), taskController.validateUserv1 )
     .post( '/uploadImage', isAllowedSessionHandler, isAllowedClient, accessVerification( { userType: [ 'tango', 'client' ], access: [ { featureName: 'TangoTrax', name: 'Task', permissions: [ 'isEdit' ] } ] } ), taskController.uploadImage )
     .post( '/config', isAllowedSessionHandler, isAllowedClient, accessVerification( { userType: [ 'tango', 'client' ], access: [ { featureName: 'TangoTrax', name: 'Task', permissions: [ 'isEdit' ] } ] } ), taskController.taskConfig )
     .post( '/reinitiate', isAllowedSessionHandler, accessVerification( { userType: [ 'tango', 'client' ], access: [ { featureName: 'TangoTrax', name: 'Task', permissions: [ 'isEdit' ] } ] } ), taskController.reinitiateTask )
@@ -30,10 +30,11 @@ taskRouter
     .post( '/createaiChecklist', isAllowedInternalAPIHandler, taskController.createAiChecklist )
     .post( '/createaiTask', isAllowedInternalAPIHandler, taskController.createAiTask )
     .post( '/assign', isAllowedSessionHandler, taskController.taskAssign )
-    .post( '/assignUpload', isAllowedSessionHandler, taskController.assignTaskUser )
+    // .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 )
-    .get( '/getcoustemer', taskController.customertrial );
+    .get( '/getcoustemer', taskController.customertrial )
+    .post( '/updateAssign', isAllowedSessionHandler, taskController.updateAssign );