tango-app-api-task 3.6.2-bulktask-9 → 3.7.2-fairprice-1

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-task",
-    "version": "3.6.2-bulktask-9",
+    "version": "3.7.2-fairprice-1",
     "description": "Task",
     "main": "index.js",
     "type": "module",

package/src/controllers/task.controller.js

@@ -117,26 +117,26 @@ export async function createUpdateTask( req, res ) {
         for ( let i = 0; i < inputBody?.sections?.length; i++ ) {
           let section = inputBody.sections[i];
           section.questions.forEach( ( section ) => {
-            if ( section.questionReferenceImage && section.questionReferenceImage.length ) {
-              let image = [];
-              for ( let img of section.questionReferenceImage ) {
-                let imgUrl = decodeURIComponent( img.split( '?' )[0] );
-                let url = imgUrl.split( '/' );
-                url.splice( 0, 3 );
-                image.push( url.join( '/' ) );
-              }
-              section.questionReferenceImage = image;
-            }
-            section.answers.forEach( ( answer ) => {
-              if ( answer.referenceImage.length ) {
-                answer.referenceImage = answer.referenceImage.map( ( value ) => {
-                  let imgUrl = decodeURIComponent( value?.split( '?' )[0] );
-                  let url = imgUrl.split( '/' );
-                  url.splice( 0, 3 );
-                  return url.join( '/' );
-                } );
-              }
-            } );
+            // if ( section.questionReferenceImage && section.questionReferenceImage.length ) {
+            //   let image = [];
+            //   for ( let img of section.questionReferenceImage ) {
+            //     let imgUrl = decodeURIComponent( img.split( '?' )[0] );
+            //     let url = imgUrl.split( '/' );
+            //     url.splice( 0, 3 );
+            //     image.push( url.join( '/' ) );
+            //   }
+            //   section.questionReferenceImage = image;
+            // }
+            // section.answers.forEach( ( answer ) => {
+            //   if ( answer.referenceImage.length ) {
+            //     answer.referenceImage = answer.referenceImage.map( ( value ) => {
+            //       let imgUrl = decodeURIComponent( value?.split( '?' )[0] );
+            //       let url = imgUrl.split( '/' );
+            //       url.splice( 0, 3 );
+            //       return url.join( '/' );
+            //     } );
+            //   }
+            // } );
           } );
 
           sectionList.push( {
@@ -256,7 +256,8 @@ export async function createUpdateTask( req, res ) {
             },
             userType: req?.user?.userType || '',
           };
-          await insertOpenSearchData( JSON.parse( process.env.OPENSEARCH ).traxActivityLog, insertLogData );
+          // await insertOpenSearchData( JSON.parse( process.env.OPENSEARCH ).traxActivityLog, insertLogData );
+          insertOpenSearchData( JSON.parse( process.env.OPENSEARCH ).traxActivityLog, insertLogData );
         }
       } else {
         let logObj = {
@@ -275,7 +276,8 @@ export async function createUpdateTask( req, res ) {
           logDetails: {},
           userType: req?.user?.userType || '',
         };
-        await insertOpenSearchData( JSON.parse( process.env.OPENSEARCH ).traxActivityLog, logObj );
+        // await insertOpenSearchData( JSON.parse( process.env.OPENSEARCH ).traxActivityLog, logObj );
+        insertOpenSearchData( JSON.parse( process.env.OPENSEARCH ).traxActivityLog, logObj );
       }
 
       if ( inputBody?.submitType == 'save' ) {
@@ -295,7 +297,8 @@ export async function createUpdateTask( req, res ) {
           logDetails: {},
           userType: req?.user?.userType || '',
         };
-        await insertOpenSearchData( JSON.parse( process.env.OPENSEARCH ).traxActivityLog, logObj );
+        // await insertOpenSearchData( JSON.parse( process.env.OPENSEARCH ).traxActivityLog, logObj );
+        insertOpenSearchData( JSON.parse( process.env.OPENSEARCH ).traxActivityLog, logObj );
       }
       return res.sendSuccess( { checklistId: checkListId, message: message } );
     } else {
@@ -360,42 +363,42 @@ export async function taskDetails( req, res ) {
     let questionDetails = await taskQuestionService.find( query );
     if ( questionDetails.length ) {
       let sections = [];
-      let bucket = JSON.parse( process.env.BUCKET );
+      // let bucket = JSON.parse( process.env.BUCKET );
       questionDetails.forEach( ( item ) => {
-        item.question.forEach( async ( question ) => {
-          if ( question.questionReferenceImage && question.questionReferenceImage != '' && typeof question.questionReferenceImage == 'string' ) {
-            let inputData = {
-              Bucket: bucket.sop,
-              file_path: decodeURIComponent( question.questionReferenceImage ),
-            };
-            question.questionReferenceImage = await signedUrl( inputData );
-          } else {
-            if ( question.questionReferenceImage.length ) {
-              let image = [];
-              for ( let img of question.questionReferenceImage ) {
-                let inputData = {
-                  Bucket: bucket.sop,
-                  file_path: decodeURIComponent( img ),
-                };
-                image.push( await signedUrl( inputData ) );
-              }
-              question.questionReferenceImage = image;
-            }
-          }
-          question.answers.forEach( async ( answer ) => {
-            if ( answer.referenceImage.length > 0 ) {
-              let updatedImages = [];
-              for ( let refImage of answer.referenceImage ) {
-                let inputData = {
-                  Bucket: bucket.sop,
-                  file_path: decodeURIComponent( refImage ),
-                };
-                updatedImages.push( await signedUrl( inputData ) );
-              }
-              answer.referenceImage = updatedImages;
-            }
-          } );
-        } );
+        // item.question.forEach( async ( question ) => {
+        //   if ( question.questionReferenceImage && question.questionReferenceImage != '' && typeof question.questionReferenceImage == 'string' ) {
+        //     let inputData = {
+        //       Bucket: bucket.sop,
+        //       file_path: decodeURIComponent( question.questionReferenceImage ),
+        //     };
+        //     question.questionReferenceImage = await signedUrl( inputData );
+        //   } else {
+        //     if ( question.questionReferenceImage.length ) {
+        //       let image = [];
+        //       for ( let img of question.questionReferenceImage ) {
+        //         let inputData = {
+        //           Bucket: bucket.sop,
+        //           file_path: decodeURIComponent( img ),
+        //         };
+        //         image.push( await signedUrl( inputData ) );
+        //       }
+        //       question.questionReferenceImage = image;
+        //     }
+        //   }
+        //   question.answers.forEach( async ( answer ) => {
+        //     if ( answer.referenceImage.length > 0 ) {
+        //       let updatedImages = [];
+        //       for ( let refImage of answer.referenceImage ) {
+        //         let inputData = {
+        //           Bucket: bucket.sop,
+        //           file_path: decodeURIComponent( refImage ),
+        //         };
+        //         updatedImages.push( await signedUrl( inputData ) );
+        //       }
+        //       answer.referenceImage = updatedImages;
+        //     }
+        //   } );
+        // } );
         sections.push( {
           id: item._id,
           name: item.section,
@@ -4834,7 +4837,7 @@ export async function commonAiTask( req, res ) {
       locationCount: 1,
       ...( inputBody?.checkListId ) ? { referenceCheckListId: inputBody?.checkListId } : {},
       coverage: 'store',
-      checkListFrom: 'api',
+      checkListFrom: '',
     };
     data['approver'] = userAdmin;
     let answer = await findAnswer( inputBody?.answerType );
@@ -6075,3 +6078,344 @@ 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 );
+  }
+}

package/src/dtos/task.dto.js

@@ -82,3 +82,24 @@ 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( '' ),
+} );
+
+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,7 @@ 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 );