tango-app-api-task 3.7.2-multireff-3 → 3.7.5-halfshutter-2

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-task",
-    "version": "3.7.2-multireff-3",
+    "version": "3.7.5-halfshutter-2",
     "description": "Task",
     "main": "index.js",
     "type": "module",

package/src/controllers/task.controller.js

@@ -1528,6 +1528,9 @@ async function insertPCBulkV3( getCLconfig, checklistId, updatedchecklist, date,
         element4.coverage = getCLconfig?.coverage;
         element4.checkListFrom = getCLconfig?.checkListFrom;
         element4.zoneName = getCLconfig?.zoneName || '';
+        element4.rawImageUpload = getCLconfig?.rawImageUpload || false;
+        element4.rawVideoUpload = getCLconfig?.rawVideoUpload || false;
+        element4.videoUploadTimeLimit = getCLconfig?.videoUploadTimeLimit || 0;
         if ( inputBody && inputBody?.streamId ) {
           element4.streamId = inputBody?.streamId;
         }
@@ -5981,6 +5984,19 @@ async function insertStoreHygienetaskSingleProcessedTask( checkTask, inputBody,
     newData.checkListType = 'task' || '';
     let insertprocessdata = await taskProcessedService.insert( newData );
     if ( insertprocessdata ) {
+      if ( response?.approver.length ) {
+        let inputData = [];
+        response?.approver.forEach( ( ele ) => {
+          inputData.push( {
+            userEmail: ele.email,
+            checkListId: response._id,
+            type: 'task',
+            client_id: inputBody.clientId,
+            checkListName: data?.checkListName || '',
+          } );
+        } );
+        await traxApprover.insertMany( inputData );
+      }
       return true;
     } else {
       return false;
@@ -6078,3 +6094,818 @@ async function insertEyetestSingleProcessedTask( checkTask, inputBody, date, tim
     return false;
   }
 }
+
+export async function createTaskGroup( req, res ) {
+  try {
+    let inputBody = req.body;
+
+    // inputBody.clientId = 11;
+    inputBody.taskDescription = '';
+    let userId;
+    let storeData = await storeService.findOne( { storeName: inputBody.storeName, clientId: inputBody.clientId, status: 'active' }, { storeId: 1, storeName: 1, storeProfile: 1, spocDetails: 1 } );
+    if ( !storeData ) {
+      return res.sendError( 'Store Not Found', 500 );
+    }
+
+    // let url = JSON.parse( process.env.LAMBDAURL );
+    // let dailychecklistId = new mongoose.Types.ObjectId( url.dailystoreChecklistId );
+    // let KSAchecklistId = new mongoose.Types.ObjectId( url.KSAchecklist );
+    // let UAEchecklistId = new mongoose.Types.ObjectId( url.UAEchecklist );
+    // let singaporechecklistId = new mongoose.Types.ObjectId( url.singaporechecklist );
+    // let finduser = await checklistassignconfigModel.findOne( { checkListId: { $in: [ dailychecklistId, KSAchecklistId, UAEchecklistId, singaporechecklistId ] }, store_id: storeData.storeId } );
+    let finduser;
+    if ( inputBody.userEmail ) {
+      let userFind = [
+        {
+          $match: {
+            email: inputBody.userEmail,
+            clientId: inputBody.clientId,
+          },
+        },
+        {
+          $project: {
+            _id: 0,
+            userId: '$_id',
+            userName: 1,
+            userEmail: '$email',
+          },
+        },
+      ];
+      let finduserData = await userService.aggregate( userFind );
+      // console.log( 'finduserData =>', finduserData );
+      if ( finduserData && finduserData.length > 0 ) {
+        finduser = finduserData[0];
+      } else {
+        // Create User//
+        let params = {
+          userName: inputBody.userEmail.split( '@' )[0],
+          email: inputBody.userEmail,
+          mobileNumber: inputBody?.mobileNumber || '0000000000',
+          clientId: inputBody.clientId,
+          role: 'user',
+          password: '5dqFKAJj29PsV6P+kL+3Dw==',
+          isActive: true,
+          userType: 'client',
+          rolespermission: [
+            {
+              featureName: 'Global',
+              modules: [
+                {
+                  name: 'Store',
+                  isAdd: false,
+                  isEdit: false,
+
+                },
+                {
+                  name: 'User',
+                  isAdd: false,
+                  isEdit: false,
+
+                },
+                {
+                  name: 'Camera',
+                  isAdd: false,
+                  isEdit: false,
+
+                },
+                {
+                  name: 'Configuration',
+                  isAdd: false,
+                  isEdit: false,
+
+                },
+                {
+                  name: 'Subscription',
+                  isAdd: false,
+                  isEdit: false,
+
+                },
+                {
+                  name: 'Billing',
+                  isAdd: false,
+                  isEdit: false,
+
+                },
+              ],
+            },
+            {
+              featurName: 'TangoEye',
+              modules: [
+                {
+                  name: 'ZoneTag',
+                  isAdd: false,
+                  isEdit: false,
+
+                },
+              ],
+            },
+            {
+              featurName: 'TangoTrax',
+              modules: [
+                {
+                  name: 'checklist',
+                  isAdd: false,
+                  isEdit: false,
+
+                },
+                {
+                  name: 'Task',
+                  isAdd: false,
+                  isEdit: false,
+
+                },
+              ],
+            },
+          ],
+        };
+        let response = await userService.create( params );
+        if ( response ) {
+          finduser = [ { userId: response._id, userName: response.userName, userEmail: response.email } ];
+        }
+      }
+    } else {
+      // get Store Spoc
+      finduser = [ { userId: storeData.spocDetails[0]._id, userName: storeData.spocDetails[0].name, userEmail: storeData.spocDetails[0].email } ];
+    }
+
+    // return finduser;
+    // console.log( 'finduser =>', finduser );
+    if ( !finduser ) {
+      return res.sendError( 'No user Found For this store', 500 );
+    }
+
+    userId = finduser.userId;
+    inputBody.userName = finduser.userName;
+    inputBody.userEmail = finduser.userEmail;
+    let teamList = await findteams( { users: { $elemMatch: { email: finduser.userEmail } } } );
+
+    inputBody.approver = '';
+    for ( let team of teamList ) {
+      for ( let user of team.Teamlead ) {
+        inputBody.approver = user.email + ',' + inputBody.approver;
+      }
+    }
+    inputBody.approver = inputBody.approver.replace( /,$/, '' );
+    let title = `New Task Alert ${inputBody.taskName}-${storeData.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 ${storeData.storeName}. Please complete it before the due date of ${date}.`;
+    let userDetails = await userService.findOne( { _id: new mongoose.Types.ObjectId( finduser.userId ) } );
+    if ( userDetails && userDetails.fcmToken ) {
+      const fcmToken = userDetails.fcmToken;
+      await sendPushNotification( title, description, fcmToken );
+    }
+    const inputDateTime = dayjs.utc( `${date} ${time}`, 'YYYY-MM-DD hh:mm A' );
+    const currentTime = dayjs.utc();
+    if ( inputDateTime.isBefore( currentTime ) ) {
+      return res.sendError( 'The input date-time is before the current time.', 500 );
+    }
+
+    let creatorData = await userService.findOne( { clientId: inputBody.clientId, role: 'superadmin', userType: 'client', isActive: true } );
+    if ( !creatorData ) {
+      return res.sendError( 'Invalid Creator Details', 500 );
+    }
+    let creator = [ { _id: creatorData._id, userName: creatorData.userName, userEmail: creatorData.email } ];
+
+    let approverList = inputBody?.approver.split( ',' );
+    let userAdmin = await userService.find( { clientId: inputBody.clientId, email: { $in: approverList }, userType: 'client', isActive: true }, { name: '$userName', email: 1 } );
+    if ( userAdmin && userAdmin.length === 0 ) {
+      userAdmin = creator;
+    }
+
+    if ( req.body && req.body.referenceImage && req.body.referenceImage.length > 3 ) {
+      return res.sendError( 'Maximum 3 referenceImage only allowed', 500 );
+    }
+
+    let answer = await findAnswer( inputBody?.answerType );
+    if ( answer.length == 0 ) {
+      return res.sendError( 'please enter Valid AnswerType', 500 );
+    }
+
+    // Check this Task Already Exist////
+    let checkTask = await taskService.findOne( { checkListName: inputBody.taskName } );
+    if ( checkTask ) {
+      let singleInsert = await insertStoreHygienetaskSingleProcessedTask( checkTask, inputBody, date, time, storeData, finduser, answer );
+      if ( singleInsert ) {
+        return res.sendSuccess( 'Task created successfully' );
+      } else {
+        return res.sendError( 'something went wrong, please try again', 500 );
+      }
+    } else {
+      let data = {
+        // checkListName: `${inputBody.taskName}(${storeData.storeName}-${dayjs().format( 'YYYY-MM-DD' )}-${inputBody.zoneName ? inputBody.zoneName : ''})`,
+        checkListName: inputBody.taskName,
+        checkListDescription: inputBody.taskDescription,
+        createdBy: creator[0]._id,
+        createdByName: creator[0].userName,
+        publish: true,
+        questionCount: 1,
+        storeCount: 1,
+        scheduleDate: date,
+        scheduleEndTime: time,
+        scheduleEndTimeISO: dayjs.utc( `${date} ${time}`, 'YYYY-MM-DD hh:mm A' ).format(),
+        priorityType: 'high',
+        client_id: inputBody.clientId,
+        checkListType: 'task',
+        publishDate: new Date(),
+        locationCount: 1,
+        ...( inputBody?.checkListId ) ? { referenceCheckListId: inputBody?.checkListId } : {},
+        coverage: 'store',
+        checkListFrom: 'api',
+        zoneName: inputBody.zoneName || '',
+        checkListType: 'task',
+      };
+      data['approver'] = userAdmin;
+
+      if ( inputBody?.answerType === 'multiplechoicesingle' || inputBody?.answerType === 'multiplechoicemultiple' ) {
+        if ( inputBody?.options && inputBody?.options.length > 0 ) {
+          let optionsResult = [];
+          let optionList = inputBody?.options.split( ',' );
+          for ( let option of optionList ) {
+            let optiondata = {
+              'answer': '',
+              'sopFlag': false,
+              'validation': false,
+              'validationType': '',
+              'referenceImage': [],
+              'runAI': false,
+              'allowUploadfromGallery': false,
+              'descriptivetype': '',
+              'showLinked': false,
+              'linkedQuestion': 0,
+              'nestedQuestion': [],
+            };
+            optiondata.answer = option;
+            optionsResult.push( optiondata );
+          }
+          answer = optionsResult;
+        } else {
+          return res.sendError( 'please enter Valid Options', 500 );
+        }
+      }
+
+      let response = await taskService.create( data );
+      if ( response?.approver.length ) {
+        let inputData = [];
+        response?.approver.forEach( ( ele ) => {
+          inputData.push( {
+            userEmail: ele.email,
+            checkListId: response._id,
+            type: 'task',
+            client_id: inputBody.clientId,
+            checkListName: data?.checkListName || '',
+          } );
+        } );
+        await traxApprover.insertMany( inputData );
+      }
+
+      if ( response?._id ) {
+        let question = [
+          {
+            'qno': 1,
+            'qname': inputBody.question,
+            'answerType': inputBody?.answerType || 'yes/no',
+            'runAI': false,
+            'runAIDescription': '',
+            'allowUploadfromGallery': false,
+            'linkType': false,
+            'questionReferenceImage': [],
+            'answers': answer,
+            'descriptivetype': 'text',
+          },
+        ];
+
+        let images = [];
+        for ( let imgpath of req.body.referenceImage ) {
+          let configURL = JSON.parse( process.env.BUCKET );
+          let inputData = {
+            Bucket: configURL.aiTraxoutput,
+            Key: imgpath,
+          };
+          let output = await getObject( inputData );
+          let image = {
+            data: output.Body,
+            name: imgpath,
+            mimetype: output.ContentType,
+          };
+          let uplaodedImage = await uploadmultiImage( image );
+          let imgUrl = decodeURIComponent( uplaodedImage?.imgUrl.split( '?' )[0] );
+          let url = imgUrl.split( '/' );
+          if ( url.includes( 'https:' ) || url.includes( 'http:' ) ) {
+            url.splice( 0, 3 );
+          }
+          images.push( url.join( '/' ) );
+        }
+        question[0].questionReferenceImage = images;
+
+        if ( inputBody?.answerType === 'image' || inputBody?.answerType === 'descriptiveImage' || inputBody?.answerType === 'multipleImage' ) {
+          answer[0].referenceImage = question[0].questionReferenceImage;
+        }
+
+        question = {
+          checkListId: response?._id,
+          question: question,
+          section: 'Section 1',
+          checkList: data.checkListName,
+          client_id: inputBody.clientId,
+        };
+        await taskQuestionService.create( question );
+
+        let userDetails = {
+          userName: inputBody.userName,
+          userEmail: inputBody.userEmail,
+          store_id: storeData.storeId,
+          storeName: storeData.storeName,
+          city: storeData?.storeProfile?.city,
+          checkFlag: true,
+          checkListId: response?._id,
+          checkListName: data.checkListName,
+          client_id: inputBody.clientId,
+          userId: userId,
+          assignId: storeData?._id,
+        };
+        await taskAssignService.create( userDetails );
+        await insertSingleProcessData( response?._id );
+        return res.sendSuccess( 'Task created successfully' );
+      }
+    }
+  } catch ( e ) {
+    console.log( 'e =>', e );
+    logger.error( { function: 'createTaskGroup', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+
+async function insertAItaskSingleProcessedTask( checkTask, inputBody, date, time, storeDetails, finduser, answer, userAdmin ) {
+  try {
+    let getquestion = await taskQuestionService.findOne( { checkListId: checkTask._id } );
+    let getolddata = await taskProcessedService.findOne( { sourceCheckList_id: checkTask._id } );
+    let getoldConfigdata = await taskService.findOne( { _id: checkTask._id } );
+
+    const uniqueUsers = mergeUnique( getoldConfigdata.approver, userAdmin, '_id' );
+    // Question Patten Making
+    let question = [
+      {
+        'qno': 1,
+        'qname': inputBody.question,
+        'answerType': inputBody?.answerType || 'yes/no',
+        'runAI': false,
+        'runAIDescription': '',
+        'allowUploadfromGallery': false,
+        'linkType': false,
+        'questionReferenceImage': [],
+        'answers': answer,
+        'descriptivetype': 'text',
+      },
+    ];
+
+    let images = [];
+    for ( let imgpath of inputBody.referenceImage ) {
+      let configURL = JSON.parse( process.env.BUCKET );
+      let inputData = {
+        Bucket: configURL.aiTraxoutput,
+        Key: imgpath,
+      };
+      let output = await getObject( inputData );
+      let image = {
+        data: output.Body,
+        name: imgpath,
+        mimetype: output.ContentType,
+      };
+      let uplaodedImage = await uploadmultiImage( image );
+      let imgUrl = decodeURIComponent( uplaodedImage?.imgUrl.split( '?' )[0] );
+      let url = imgUrl.split( '/' );
+      if ( url.includes( 'https:' ) || url.includes( 'http:' ) ) {
+        url.splice( 0, 3 );
+      }
+      images.push( url.join( '/' ) );
+    }
+    question[0].questionReferenceImage = images;
+
+    if ( inputBody?.answerType === 'image' || inputBody?.answerType === 'descriptiveImage' || inputBody?.answerType === 'multipleImage' ) {
+      answer[0].referenceImage = question[0].questionReferenceImage;
+    }
+
+    let questions = {
+      questions: question,
+      sectionName: getquestion.section,
+      section_id: getquestion._id,
+    };
+
+    let newData = getolddata.toObject();
+    delete newData._id;
+    newData.date_iso = new Date( dayjs( date, 'YYYY-MM-DD' ).format( 'YYYY-MM-DD' ) );
+    newData.date_string = dayjs( date ).format( 'YYYY-MM-DD' );
+    newData.scheduleStartTime_iso = date;
+    newData.scheduleEndTime_iso = dayjs.utc( `${date} ${time}`, 'YYYY-MM-DD hh:mm A' ).format();
+    newData.store_id = storeDetails.storeId;
+    newData.storeName = storeDetails.storeName;
+    newData.country = storeDetails.storeProfile.country;
+    newData.userId = finduser.userId;
+    newData.userName = finduser.userName;
+    newData.userEmail = finduser.userEmail;
+    newData.checklistStatus = 'open';
+    newData.timeFlagStatus = true;
+    newData.checkListFrom = 'api';
+    newData.createdAt = new Date();
+    newData.updatedAt = new Date();
+    newData.questionAnswers = [ questions ];
+    newData.zoneName = inputBody.zoneName || '';
+    newData.checkListType = 'task' || '';
+    let insertprocessdata = await taskProcessedService.insert( newData );
+    if ( insertprocessdata ) {
+      if ( uniqueUsers && uniqueUsers.length>0 ) {
+        // updated Task Approver//
+        await taskService.updateOne( { _id: newData.sourceCheckList_id }, { approver: uniqueUsers } );
+        for ( let k = 0; k < uniqueUsers.length; k++ ) {
+          let checkapprover = {
+            userEmail: uniqueUsers[k].email,
+            checkListId: newData.sourceCheckList_id,
+            type: 'task',
+            client_id: newData.client_id,
+            isDeleted: false,
+          };
+          let getapproverData = await traxApprover.findOne( checkapprover );
+          if ( !getapproverData ) {
+            let inserApproverData = {
+              userEmail: uniqueUsers[k].email,
+              checkListId: newData.sourceCheckList_id,
+              type: 'task',
+              client_id: newData.client_id,
+              isDeleted: false,
+            };
+            await traxApprover.create( inserApproverData );
+          }
+        }
+      }
+      return true;
+    } else {
+      return false;
+    }
+  } catch ( error ) {
+    logger.error( { error: error, function: 'insertSingleProcessedTask' } );
+    return false;
+  }
+}
+
+export async function createAITaskGroup( req, res ) {
+  try {
+    let inputBody = req.body;
+
+    inputBody.taskDescription = '';
+    let userId;
+    // Step:1 Store Validation
+    let storeData = await storeService.findOne( { storeName: inputBody.storeName, clientId: inputBody.clientId, status: 'active' }, { storeId: 1, storeName: 1, storeProfile: 1, spocDetails: 1 } );
+    if ( !storeData ) {
+      return res.sendError( 'Store Not Found', 500 );
+    }
+
+    let finduser;
+    // Step:2 User Validation
+    if ( inputBody.userEmail ) {
+      let userFind = [
+        {
+          $match: {
+            email: inputBody.userEmail,
+            clientId: inputBody.clientId,
+          },
+        },
+        {
+          $project: {
+            _id: 0,
+            userId: '$_id',
+            userName: 1,
+            userEmail: '$email',
+          },
+        },
+      ];
+      let finduserData = await userService.aggregate( userFind );
+      // console.log( 'finduserData =>', finduserData );
+      if ( finduserData && finduserData.length > 0 ) {
+        finduser = finduserData[0];
+      } else {
+        // Create User//
+        let params = {
+          userName: inputBody.userEmail.split( '@' )[0],
+          email: inputBody.userEmail,
+          mobileNumber: inputBody?.mobileNumber || '0000000000',
+          clientId: inputBody.clientId,
+          role: 'user',
+          password: '5dqFKAJj29PsV6P+kL+3Dw==',
+          isActive: true,
+          userType: 'client',
+          rolespermission: [
+            {
+              featureName: 'Global',
+              modules: [
+                {
+                  name: 'Store',
+                  isAdd: false,
+                  isEdit: false,
+
+                },
+                {
+                  name: 'User',
+                  isAdd: false,
+                  isEdit: false,
+
+                },
+                {
+                  name: 'Camera',
+                  isAdd: false,
+                  isEdit: false,
+
+                },
+                {
+                  name: 'Configuration',
+                  isAdd: false,
+                  isEdit: false,
+
+                },
+                {
+                  name: 'Subscription',
+                  isAdd: false,
+                  isEdit: false,
+
+                },
+                {
+                  name: 'Billing',
+                  isAdd: false,
+                  isEdit: false,
+
+                },
+              ],
+            },
+            {
+              featurName: 'TangoEye',
+              modules: [
+                {
+                  name: 'ZoneTag',
+                  isAdd: false,
+                  isEdit: false,
+
+                },
+              ],
+            },
+            {
+              featurName: 'TangoTrax',
+              modules: [
+                {
+                  name: 'checklist',
+                  isAdd: false,
+                  isEdit: false,
+
+                },
+                {
+                  name: 'Task',
+                  isAdd: false,
+                  isEdit: false,
+
+                },
+              ],
+            },
+          ],
+        };
+        let response = await userService.create( params );
+        if ( response ) {
+          finduser = [ { userId: response._id, userName: response.userName, userEmail: response.email } ];
+        }
+      }
+    } else {
+      // get Store Spoc
+      if ( storeData.spocDetails[0].email && storeData.spocDetails[0].email !='' ) {
+        finduser ={ userId: storeData.spocDetails[0]._id, userName: storeData.spocDetails[0].name, userEmail: storeData.spocDetails[0].email };
+      } else {
+        return res.sendError( 'store spoc email invalid', 500 );
+      }
+    }
+
+    // return finduser;
+    // console.log( 'finduser =>', finduser );
+    if ( !finduser ) {
+      return res.sendError( 'No user Found For this store', 500 );
+    }
+
+    userId = finduser.userId;
+    inputBody.userName = finduser.userName;
+    inputBody.userEmail = finduser.userEmail;
+    if ( inputBody.approver && !inputBody.approver.length ) {
+      let teamList = await findteams( { users: { $elemMatch: { email: finduser.userEmail } } } );
+      // console.log( 'teamList =>', teamList );
+      if ( teamList && teamList.length>0 ) {
+        for ( let team of teamList ) {
+          for ( let user of team.Teamlead ) {
+            inputBody.approver.push( user.email );
+          }
+        }
+      }
+    }
+
+    // Send Push Notification
+    // inputBody.approver = inputBody.approver.replace( /,$/, '' );
+    let title = `New Task Alert ${inputBody.taskName}-${storeData.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 ${storeData.storeName}. Please complete it before the due date of ${date}.`;
+    let userDetails = await userService.findOne( { _id: new mongoose.Types.ObjectId( finduser.userId ) } );
+    if ( userDetails && userDetails.fcmToken ) {
+      const fcmToken = userDetails.fcmToken;
+      await sendPushNotification( title, description, fcmToken );
+    }
+
+    const inputDateTime = dayjs.utc( `${date} ${time}`, 'YYYY-MM-DD hh:mm A' );
+    const currentTime = dayjs.utc();
+    if ( inputDateTime.isBefore( currentTime ) ) {
+      return res.sendError( 'The input date-time is before the current time.', 500 );
+    }
+
+    let creatorData = await userService.findOne( { clientId: inputBody.clientId, role: 'superadmin', userType: 'client', isActive: true } );
+    if ( !creatorData ) {
+      return res.sendError( 'Invalid Creator Details', 500 );
+    }
+    let creator = [ { _id: creatorData._id, userName: creatorData.userName, userEmail: creatorData.email } ];
+
+    let userAdmin;
+    if ( inputBody.approver && inputBody.approver.length ) {
+      userAdmin = await userService.find( { clientId: inputBody.clientId, email: { $in: inputBody.approver }, userType: 'client', isActive: true }, { name: '$userName', email: 1 } );
+      // console.log( 'userAdmin 1=>', userAdmin );
+      if ( userAdmin && userAdmin.length === 0 ) {
+        userAdmin = creator;
+      }
+      // console.log( 'userAdmin 2=>', userAdmin );
+    }
+
+    if ( req.body && req.body.referenceImage && req.body.referenceImage.length > 3 ) {
+      return res.sendError( 'Maximum 3 referenceImage only allowed', 500 );
+    }
+
+    let answer = await findAnswer( inputBody?.answerType );
+    if ( answer.length == 0 ) {
+      return res.sendError( 'please enter Valid AnswerType', 500 );
+    }
+
+    // Check this Task Already Exist////
+    let checkTask = await taskService.findOne( { checkListName: inputBody.taskName } );
+    if ( checkTask ) {
+      let singleInsert = await insertAItaskSingleProcessedTask( checkTask, inputBody, date, time, storeData, finduser, answer, userAdmin );
+      if ( singleInsert ) {
+        return res.sendSuccess( 'Task created successfully' );
+      } else {
+        return res.sendError( 'something went wrong, please try again', 500 );
+      }
+    } else {
+      let data = {
+        // checkListName: `${inputBody.taskName}(${storeData.storeName}-${dayjs().format( 'YYYY-MM-DD' )}-${inputBody.zoneName ? inputBody.zoneName : ''})`,
+        checkListName: inputBody.taskName,
+        checkListDescription: inputBody.taskDescription,
+        createdBy: creator[0]._id,
+        createdByName: creator[0].userName,
+        publish: true,
+        questionCount: 1,
+        storeCount: 1,
+        scheduleDate: date,
+        scheduleEndTime: time,
+        scheduleEndTimeISO: dayjs.utc( `${date} ${time}`, 'YYYY-MM-DD hh:mm A' ).format(),
+        priorityType: 'high',
+        client_id: inputBody.clientId,
+        checkListType: 'task',
+        publishDate: new Date(),
+        locationCount: 1,
+        ...( inputBody?.checkListId ) ? { referenceCheckListId: inputBody?.checkListId } : {},
+        coverage: 'store',
+        checkListFrom: 'api',
+        zoneName: inputBody.zoneName || '',
+        checkListType: 'task',
+      };
+      data['approver'] = userAdmin;
+
+      if ( inputBody?.answerType === 'multiplechoicesingle' || inputBody?.answerType === 'multiplechoicemultiple' ) {
+        if ( inputBody?.options && inputBody?.options.length > 0 ) {
+          let optionsResult = [];
+          let optionList = inputBody?.options.split( ',' );
+          for ( let option of optionList ) {
+            let optiondata = {
+              'answer': '',
+              'sopFlag': false,
+              'validation': false,
+              'validationType': '',
+              'referenceImage': [],
+              'runAI': false,
+              'allowUploadfromGallery': false,
+              'descriptivetype': '',
+              'showLinked': false,
+              'linkedQuestion': 0,
+              'nestedQuestion': [],
+            };
+            optiondata.answer = option;
+            optionsResult.push( optiondata );
+          }
+          answer = optionsResult;
+        } else {
+          return res.sendError( 'please enter Valid Options', 500 );
+        }
+      }
+
+      let response = await taskService.create( data );
+      if ( response?.approver.length ) {
+        let inputData = [];
+        response?.approver.forEach( ( ele ) => {
+          inputData.push( {
+            userEmail: ele.email,
+            checkListId: response._id,
+            type: 'task',
+            client_id: inputBody.clientId,
+            checkListName: data?.checkListName || '',
+          } );
+        } );
+        await traxApprover.insertMany( inputData );
+      }
+
+      if ( response?._id ) {
+        let question = [
+          {
+            'qno': 1,
+            'qname': inputBody.question,
+            'answerType': inputBody?.answerType || 'yes/no',
+            'runAI': false,
+            'runAIDescription': '',
+            'allowUploadfromGallery': false,
+            'linkType': false,
+            'questionReferenceImage': [],
+            'answers': answer,
+            'descriptivetype': 'text',
+          },
+        ];
+
+        let images = [];
+        for ( let imgpath of req.body.referenceImage ) {
+          let configURL = JSON.parse( process.env.BUCKET );
+          let inputData = {
+            Bucket: configURL.aiTraxoutput,
+            Key: imgpath,
+          };
+          let output = await getObject( inputData );
+          // / Check Bucket
+          console.log( 'output =>', output );
+          let image = {
+            data: output.Body,
+            name: imgpath,
+            mimetype: output.ContentType,
+          };
+          let uplaodedImage = await uploadmultiImage( image );
+          let imgUrl = decodeURIComponent( uplaodedImage?.imgUrl.split( '?' )[0] );
+          let url = imgUrl.split( '/' );
+          if ( url.includes( 'https:' ) || url.includes( 'http:' ) ) {
+            url.splice( 0, 3 );
+          }
+          images.push( url.join( '/' ) );
+        }
+        question[0].questionReferenceImage = images;
+
+        if ( inputBody?.answerType === 'image' || inputBody?.answerType === 'descriptiveImage' || inputBody?.answerType === 'multipleImage' ) {
+          answer[0].referenceImage = question[0].questionReferenceImage;
+        }
+
+        question = {
+          checkListId: response?._id,
+          question: question,
+          section: 'Section 1',
+          checkList: data.checkListName,
+          client_id: inputBody.clientId,
+        };
+        await taskQuestionService.create( question );
+
+        let userDetails = {
+          userName: inputBody.userName,
+          userEmail: inputBody.userEmail,
+          store_id: storeData.storeId,
+          storeName: storeData.storeName,
+          city: storeData?.storeProfile?.city,
+          checkFlag: true,
+          checkListId: response?._id,
+          checkListName: data.checkListName,
+          client_id: inputBody.clientId,
+          userId: userId,
+          assignId: storeData?._id,
+        };
+        await taskAssignService.create( userDetails );
+        await insertSingleProcessData( response?._id );
+        return res.sendSuccess( 'Task created successfully' );
+      }
+    }
+  } catch ( e ) {
+    console.log( 'e =>', e );
+    logger.error( { function: 'createTaskGroup', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+
+function mergeUnique( arr1 = [], arr2 = [], key = '_id' ) {
+  const merged = [ ...arr1, ...arr2 ];
+
+  return Array.from(
+      new Map(
+          merged.map( ( item ) => [ item[key]?.toString?.() ?? item[key], item ] ),
+      ).values(),
+  );
+}

package/src/dtos/task.dto.js

@@ -82,3 +82,25 @@ export const StoreHygienetaskvalidation = {
 export const eyeTesttaskvalidation = {
   body: eyeTesttaskSchema,
 };
+
+
+export const createTaskGroupSchema = Joi.object().keys( {
+  storeName: Joi.string().required(),
+  taskName: Joi.string().required(),
+  question: Joi.string().required(),
+  answerType: Joi.string().required(),
+  clientId: Joi.string().required(),
+  options: Joi.string().optional().allow( '' ),
+  scheduleDate: Joi.string().optional().allow( '' ),
+  scheduleEndTime: Joi.string().optional().allow( '' ),
+  referenceImage: Joi.array().optional().allow( '' ),
+  zoneName: Joi.string().optional().allow( '' ),
+  userEmail: Joi.string().optional().allow( '' ),
+  mobileNumber: Joi.string().optional().allow( '' ),
+  approverList: Joi.array().optional().allow( '' ),
+  approver: Joi.array().optional().allow( '' ),
+} );
+
+export const createTaskGroupvalidation = {
+  body: createTaskGroupSchema,
+};

package/src/routes/task.routes.js

@@ -2,7 +2,7 @@
 import * as taskController from '../controllers/task.controller.js';
 import { isAllowedSessionHandler, validate, accessVerification, isAllowedClient, isAllowedInternalAPIHandler, getAssinedStore } from 'tango-app-api-middleware';
 import express from 'express';
-import { aitaskvalidation, StoreHygienetaskvalidation, eyeTesttaskvalidation, commonAiTaskvalidation, taskcreationvalidation, gettaskvalidation } from '../dtos/task.dto.js';
+import { aitaskvalidation, StoreHygienetaskvalidation, eyeTesttaskvalidation, commonAiTaskvalidation, taskcreationvalidation, gettaskvalidation, createTaskGroupvalidation } from '../dtos/task.dto.js';
 export const taskRouter = express.Router();
 
 taskRouter
@@ -42,6 +42,8 @@ taskRouter
     .post( '/taskcreation', isAllowedInternalAPIHandler, validate( taskcreationvalidation ), taskController.taskcreation )
     .get( '/getTask', isAllowedInternalAPIHandler, validate( gettaskvalidation ), taskController.getTask )
     .post( '/breached-tasks', isAllowedInternalAPIHandler, validate( taskcreationvalidation ), taskController.breachedTasks )
-    .get( '/getcoustemer', taskController.customertrial );
+    .get( '/getcoustemer', taskController.customertrial )
+    .post( '/createTaskGroup', isAllowedInternalAPIHandler, validate( createTaskGroupvalidation ), taskController.createTaskGroup )
+    .post( '/createAITaskGroup', isAllowedInternalAPIHandler, validate( createTaskGroupvalidation ), taskController.createAITaskGroup );
 
 

package/src/service/approver.service.js

@@ -15,3 +15,7 @@ export const insertMany = async ( data = [] ) => {
 export const find = async ( query ={}, field={} ) => {
   return model.traxApproverModel.find( query, field );
 };
+
+export const findOne = async ( query ={}, field={} ) => {
+  return model.traxApproverModel.findOne( query, field );
+};