tango-app-api-task 3.7.25 → 3.7.27

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-task",
-    "version": "3.7.25",
+    "version": "3.7.27",
     "description": "Task",
     "main": "index.js",
     "type": "module",
@@ -25,7 +25,7 @@
         "mongodb": "^6.10.0",
         "nodemon": "^3.1.7",
         "npm": "^10.9.2",
-        "tango-api-schema": "^2.5.32",
+        "tango-api-schema": "^2.5.70",
         "tango-app-api-middleware": "^3.6.8",
         "winston": "^3.17.0",
         "winston-daily-rotate-file": "^5.0.0"

package/src/controllers/task.controller.js

@@ -4472,6 +4472,37 @@ async function findAnswer( type ) {
       ];
       return answer;
       break;
+    case 'dropdown':
+      answer = [
+        {
+          'answer': '',
+          'sopFlag': false,
+          'validation': false,
+          'validationType': '',
+          'referenceImage': [],
+          'runAI': false,
+          'allowUploadfromGallery': false,
+          'descriptivetype': '',
+          'showLinked': false,
+          'linkedQuestion': 0,
+          'nestedQuestion': [],
+        },
+        {
+          'answer': '',
+          'sopFlag': false,
+          'validation': false,
+          'validationType': '',
+          'referenceImage': [],
+          'runAI': false,
+          'allowUploadfromGallery': false,
+          'descriptivetype': '',
+          'showLinked': false,
+          'linkedQuestion': 0,
+          'nestedQuestion': [],
+        },
+      ];
+      return answer;
+      break;
     default:
       return [];
   }
@@ -6634,6 +6665,9 @@ async function insertAItaskSingleProcessedTask( checkTask, inputBody, date, time
     newData.questionAnswers = [ questions ];
     newData.zoneName = inputBody.zoneName || '';
     newData.checkListType = 'task' || '';
+    if ( inputBody?.aiType ) {
+      newData.aiType = inputBody.aiType;
+    }
     let insertprocessdata = await taskProcessedService.insert( newData );
     await taskProcessedConfigService.insert( newData );
     console.log( '🚀 ~ insertAItaskSingleProcessedTask ~ insertprocessdata:', insertprocessdata );
@@ -7050,6 +7084,465 @@ export async function createAITaskGroup( req, res ) {
   }
 }
 
+
+export async function AITaskCreation( req, res ) {
+  try {
+    let inputBody = req.body;
+
+    inputBody.taskDescription = '';
+    // 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 );
+    }
+
+    if ( inputBody.taskAssigned == 'teams' ) {
+      let teamDetails = await teamsServices.findteams( { teamName: { $in: inputBody.userList }, clientId: inputBody.clientId }, { users: 1 } );
+      if ( teamDetails.length ) {
+        inputBody.userEmail = teamDetails.map( ( team ) => team.users.map( ( user ) => user.email ) );
+      }
+    }
+
+    let finduser;
+    // Step:2 User Validation
+    if ( inputBody.userEmail.length ) {
+      let userFind = [
+        {
+          $match: {
+            email: { $in: inputBody.userEmail },
+            clientId: inputBody.clientId,
+          },
+        },
+        {
+          $project: {
+            _id: 0,
+            userId: '$_id',
+            userName: 1,
+            userEmail: '$email',
+          },
+        },
+      ];
+      let finduserData = await userService.aggregate( userFind );
+      if ( finduserData && finduserData.length > 0 ) {
+        finduser = finduserData;
+      }
+    } 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.length ) {
+      return res.sendError( 'No user Found For this store', 500 );
+    }
+
+
+    if ( inputBody.approver && !inputBody.approver.length ) {
+      await Promise.all( finduser.map( async ( user ) => {
+        let teamList = await findteams( { users: { $elemMatch: { email: user.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}.`;
+    await Promise.all( finduser.map( async ( ele ) => {
+      let userDetails = userService.findOne( { _id: new mongoose.Types.ObjectId( ele.userId ) } );
+      if ( userDetails && userDetails.fcmToken ) {
+        const fcmToken = userDetails.fcmToken;
+        sendPushNotification( title, description, fcmToken );
+      }
+    } ) );
+
+    let scheduleEndData = dayjs.utc( `${date} ${time}`, 'YYYY-MM-DD hh:mm A' ).format();
+
+    if ( inputBody.taskValidity == 'min' ) {
+      scheduleEndData = dayjs.utc( `${date} ${time}`, 'YYYY-MM-DD hh:mm A' ).add( inputBody.taskValidity.time, 'miuntes' ).format();
+    }
+    if ( inputBody.taskValidity == 'hour' ) {
+      scheduleEndData = dayjs.utc( `${date} ${time}`, 'YYYY-MM-DD hh:mm A' ).add( inputBody.taskValidity.time, 'hour' ).format();
+    }
+    if ( inputBody.taskValidity == 'day' ) {
+      scheduleEndData = dayjs.utc( `${date} ${time}`, 'YYYY-MM-DD hh:mm A' ).add( inputBody.taskValidity.time, 'day' ).format();
+    }
+
+    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 );
+    }
+
+    if ( [ 'multiplechoicesingle', 'multiplechoicemultiple', 'dropdown' ].includes( inputBody?.answerType ) ) {
+      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': [],
+            'reason': inputBody.reason,
+            'detectionTime': inputBody.detectionTime,
+          };
+          optiondata.answer = option;
+          optionsResult.push( optiondata );
+        }
+        answer = optionsResult;
+      } else {
+        return res.sendError( 'please enter Valid Options', 500 );
+      }
+    }
+
+    if ( inputBody.reason ) {
+      answer[0].reason = inputBody.reason;
+      answer[0].detectionTime = inputBody.detectionTime;
+    }
+
+    // Check this Task Already Exist////
+    let checkTask = await taskService.findOne( { checkListName: inputBody.taskName } );
+    if ( checkTask ) {
+      let singleInsert = await insertAItaskProcessedTaskCreation( 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: scheduleEndData,
+        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 ( [ 'multiplechoicesingle', 'multiplechoicemultiple', 'dropdown' ].includes( inputBody?.answerType ) ) {
+        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': [],
+              'reason': inputBody.reason,
+              'detectionTime': inputBody.detectionTime,
+            };
+            optiondata.answer = option;
+            optionsResult.push( optiondata );
+          }
+          answer = optionsResult;
+        } else {
+          return res.sendError( 'please enter Valid Options', 500 );
+        }
+      }
+      let clientDetails = await clientService.findOne( { clientId: inputBody?.clientId }, { traxVideoUploadTimeLimit: 1 } );
+      data['videoUploadTimeLimit'] = clientDetails?.traxVideoUploadTimeLimit || 0;
+      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',
+            'allowMultiple': inputBody.multi,
+          },
+        ];
+
+        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 = [];
+        finduser.forEach( ( ele ) => {
+          userDetails = {
+            userName: ele.userName,
+            userEmail: ele.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: ele.userId,
+            assignId: storeData?._id,
+            country: storeData?.storeProfile?.country,
+            state: storeData?.storeProfile?.state,
+          };
+        } );
+
+        await taskAssignService.insertMany( userDetails );
+        await insertSingleProcessData( response?._id, false, { aiTask: true, aiType: inputBody.aiType } );
+        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 insertAItaskProcessedTaskCreation( 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',
+        'allowMultiple': inputBody.multi,
+      },
+    ];
+
+    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 oldData = getolddata.toObject();
+    delete oldData._id;
+    oldData.date_iso = new Date( dayjs( date, 'YYYY-MM-DD' ).format( 'YYYY-MM-DD' ) );
+    oldData.date_string = dayjs( date ).format( 'YYYY-MM-DD' );
+    oldData.scheduleStartTime_iso = date;
+    oldData.scheduleEndTime_iso = dayjs.utc( `${date} ${time}`, 'YYYY-MM-DD hh:mm A' ).format();
+    oldData.store_id = storeDetails.storeId;
+    oldData.storeName = storeDetails.storeName;
+    oldData.country = storeDetails.storeProfile.country;
+    oldData.checklistStatus = 'open';
+    oldData.timeFlagStatus = true;
+    oldData.checkListFrom = 'api';
+    oldData.createdAt = new Date();
+    oldData.updatedAt = new Date();
+    oldData.approvalStatus = false;
+    oldData.approvalEnable = true;
+    oldData.approvalTime = '';
+    oldData.approvalTime_string = '';
+    oldData.redoStatus = false;
+    oldData.approvalByName = '';
+    oldData.approvalByEmail = '';
+    oldData.questionAnswers = [ questions ];
+    oldData.zoneName = inputBody.zoneName || '';
+    oldData.checkListType = 'task' || '';
+    if ( inputBody.aiType ) {
+      oldData.aiType = inputBody.aiType;
+    }
+    let configDetails = await taskProcessedConfigService.insert( oldData );
+    let insertData = [];
+    finduser.forEach( ( user ) => {
+      let newData = oldData;
+      newData.userId = user.userId;
+      newData.userName = user.userName;
+      newData.userEmail = user.userEmail;
+      newData.checkListId = configDetails._id;
+      insertData.push( newData );
+    } );
+    let insertprocessdata = await taskProcessedService.insertMany( insertData );
+    console.log( '🚀 ~ insertAItaskSingleProcessedTask ~ insertprocessdata:', insertprocessdata );
+    if ( insertprocessdata ) {
+      if ( uniqueUsers && uniqueUsers.length>0 ) {
+        // updated Task Approver//
+        await taskService.updateOne( { _id: oldData.sourceCheckList_id }, { approver: uniqueUsers } );
+        for ( let k = 0; k < uniqueUsers.length; k++ ) {
+          let checkapprover = {
+            userEmail: uniqueUsers[k].email,
+            checkListId: oldData.sourceCheckList_id,
+            type: 'task',
+            client_id: oldData.client_id,
+            isDeleted: false,
+          };
+          let getapproverData = await traxApprover.findOne( checkapprover );
+          if ( !getapproverData ) {
+            let inserApproverData = {
+              userEmail: uniqueUsers[k].email,
+              checkListId: oldData.sourceCheckList_id,
+              type: 'task',
+              client_id: oldData.client_id,
+              isDeleted: false,
+            };
+            await traxApprover.create( inserApproverData );
+          }
+        }
+      }
+      return true;
+    } else {
+      return false;
+    }
+  } catch ( error ) {
+    logger.error( { error: error, function: 'insertSingleProcessedTask' } );
+    return false;
+  }
+}
+
 function mergeUnique( arr1 = [], arr2 = [], key = '_id' ) {
   const merged = [ ...arr1, ...arr2 ];
 

package/src/controllers/taskDashboard.controllers.js

@@ -1104,11 +1104,12 @@ export async function taskDetails( req, res ) {
       },
     ];
 
-    if ( req.body?.searchValue.trim().length ) {
+    if ( req.body?.searchValue?.trim()?.length ) {
+      const safeSearch = escapeRegex( req.body?.searchValue );
       query.push(
           {
             $match: {
-              checkListName: { $regex: req.body.searchValue, $options: 'i' },
+              checkListName: { $regex: safeSearch, $options: 'i' },
             },
           },
       );
@@ -1172,3 +1173,6 @@ export async function taskDetails( req, res ) {
     return res.sendError( e, 500 );
   }
 }
+function escapeRegex( text ) {
+  return text.replace( /[.*+?^${}()|[\]\\]/g, '\\$&' );
+}

package/src/routes/task.routes.js

@@ -44,6 +44,7 @@ taskRouter
     .post( '/breached-tasks', isAllowedInternalAPIHandler, validate( taskcreationvalidation ), taskController.breachedTasks )
     .get( '/getcoustemer', taskController.customertrial )
     .post( '/createTaskGroup', isAllowedInternalAPIHandler, validate( createTaskGroupvalidation ), taskController.createTaskGroup )
-    .post( '/createAITaskGroup', isAllowedInternalAPIHandler, validate( createTaskGroupvalidation ), taskController.createAITaskGroup );
+    .post( '/createAITaskGroup', isAllowedInternalAPIHandler, validate( createTaskGroupvalidation ), taskController.createAITaskGroup )
+    .post( '/AITaskCreation', isAllowedInternalAPIHandler, taskController.AITaskCreation );