tango-app-api-trax 3.3.1-beta-3 → 3.3.1-beta-4

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-trax",
-    "version": "3.3.1-beta-3",
+    "version": "3.3.1-beta-4",
     "description": "Trax",
     "main": "index.js",
     "type": "module",
@@ -26,7 +26,7 @@
         "mongodb": "^6.8.0",
         "nodemon": "^3.1.4",
         "path": "^0.12.7",
-        "tango-api-schema": "^2.2.24",
+        "tango-api-schema": "^2.2.32",
         "tango-app-api-middleware": "^3.1.50",
         "url": "^0.11.4",
         "winston": "^3.13.1",

package/src/controllers/teaxFlag.controller.js

@@ -2737,3 +2737,261 @@ export const checklistDropdownV1 = async ( req, res ) => {
     return res.sendError( { error: error }, 500 );
   }
 };
+
+export const flagTablesV2 = async ( req, res ) => {
+  try {
+    let requestData = req.body;
+    let fromDate = new Date( requestData.fromDate );
+    let toDate = new Date( requestData.toDate );
+    let userTimezoneOffset = toDate.getTimezoneOffset() * 60000;
+    toDate = new Date( toDate.getTime() - userTimezoneOffset );
+    toDate.setUTCHours( 23, 59, 59, 59 );
+    let result = {};
+
+    let findQuery = [];
+    let findAndQuery = [];
+    findAndQuery.push(
+        { client_id: requestData.clientId },
+        { $or: [ { store_id: { $in: requestData.storeId } }, { aiStoreList: { $in: requestData.storeId } } ] },
+        { date_iso: { $gte: fromDate } },
+        { date_iso: { $lte: toDate } },
+    );
+
+    if ( requestData?.filter === 'all' ) {
+      findAndQuery.push( { $or: [ { questionFlag: { $gte: 1 } }, { timeFlag: { $gte: 1 } }, { checkListType: { $in: [ 'customerunattended', 'mobileusagedetection', 'staffleftinthemiddle', 'storeopenandclose', 'uniformdetection' ] } } ] } );
+    } else if ( requestData?.filter === 'question' ) {
+      findAndQuery.push( { checkListType: 'custom' } );
+      findAndQuery.push( { questionFlag: { $gte: 1 } } );
+    } else if ( requestData?.filter === 'time' ) {
+      findAndQuery.push( { checkListType: 'custom' } );
+      findAndQuery.push( { timeFlag: { $gte: 1 } } );
+    } else if ( requestData?.filter === 'detection' ) {
+      findAndQuery.push( { checkListType: { $in: [ 'customerunattended', 'mobileusagedetection', 'staffleftinthemiddle', 'storeopenandclose', 'uniformdetection' ] } } );
+    }
+
+    findQuery.push( { $match: { $and: findAndQuery } } );
+
+    if ( requestData.searchValue && requestData.searchValue != '' ) {
+      findQuery.push( { $match: { $or: [ { checkListName: { $regex: requestData.searchValue, $options: 'i' } } ] } } );
+    }
+
+    findQuery.push( {
+      $project: {
+        sourceCheckList_id: 1,
+        checkListId: 1,
+        checkListName: 1,
+        coverage: 1,
+        storeCount: 1,
+        createdBy: 1,
+        createdByName: 1,
+        checklistStatus: 1,
+        timeFlag: 1,
+        questionFlag: 1,
+        questionCount: 1,
+        mobileDetectionFlag: 1,
+        storeOpenCloseFlag: 1,
+        uniformDetectionFlag: 1,
+        checkListType: 1,
+        scheduleRepeatedType: 1,
+        store_id: 1,
+        aiStoreList: 1,
+      },
+    } );
+
+    findQuery.push( {
+      $group: {
+        _id: '$sourceCheckList_id',
+        checkListName: { $last: '$checkListName' },
+        coverage: { $last: '$coverage' },
+        checkListChar: { $last: { $substr: [ '$checkListName', 0, 2 ] } },
+        sourceCheckList_id: { $last: '$sourceCheckList_id' },
+        checkListType: { $last: '$checkListType' },
+        storeCount: { $sum: 1 },
+        storeCountAi: { $max: '$storeCount' },
+        flaggedStores: {
+          $addToSet: {
+            $cond: [
+              {
+                $or: [
+                  { $gt: [ '$timeFlag', 0 ] },
+                  { $gt: [ '$questionFlag', 0 ] },
+                  { $gt: [ '$mobileDetectionFlag', 0 ] },
+                  { $gt: [ '$storeOpenCloseFlag', 0 ] },
+                  { $gt: [ '$uniformDetectionFlag', 0 ] },
+                  { $gt: [ '$customerUnattended', 0 ] },
+                  { $gt: [ '$staffLeftInTheMiddle', 0 ] },
+                ],
+              },
+              '$store_id',
+              '$$REMOVE',
+            ],
+          },
+        },
+        flagCount: {
+          $sum: {
+            $add: [ '$questionFlag', '$timeFlag' ],
+          },
+        },
+        submittedChecklist: {
+          $sum: {
+            $cond: [ { $eq: [ '$checklistStatus', 'submit' ] }, 1, 0 ],
+          },
+        },
+        questionFlag: {
+          $sum: '$questionFlag',
+        },
+        timeFlag: {
+          $sum: '$timeFlag',
+        },
+        questionCount: {
+          $sum: '$questionCount',
+        },
+        aiStoreList: { $max: '$aiStoreList' },
+        submittedQuestionCount: {
+          $sum: {
+            $cond: [ { $eq: [ '$checklistStatus', 'submit' ] }, '$questionCount', 0 ],
+          },
+        },
+      },
+    } );
+
+    findQuery.push( {
+      $project: {
+        assignedStores: '$storeCount',
+        assignedStoresAi: '$storeCountAi',
+        checkListName: 1,
+        coverage: 1,
+        checkListChar: 1,
+        sourceCheckList_id: 1,
+        checkListType: 1,
+        flagType: 1,
+        uniqueFlaggedStores: 1,
+        flaggedStores: { $size: '$flaggedStores' },
+        flagCount: 1,
+        questionCount: 1,
+        correctAnswers: { $subtract: [ '$submittedQuestionCount', '$questionFlag' ] },
+        customQuestionFlagCount: '$questionFlag',
+        customTimeFlagCount: '$timeFlag',
+        aiStoreList: 1,
+      },
+    } );
+
+    findQuery.push( {
+      $project: {
+        checkListName: 1,
+        coverage: 1,
+        checkListChar: 1,
+        sourceCheckList_id: 1,
+        checkListType: 1,
+        flagType: 1,
+        assignedStores: 1,
+        assignedStoresAi: 1,
+        flaggedStores: 1,
+        flagCount: 1,
+        uniqueFlaggedStores: 1,
+        complianceRate: {
+          $cond: {
+            if: { $eq: [ '$questionCount', 0 ] },
+            then: 0,
+            else: {
+              $round: [ { $multiply: [ { $divide: [ '$correctAnswers', '$questionCount' ] }, 100 ] }, 2 ],
+            },
+          },
+        },
+        customQuestionFlagCount: 1,
+        customTimeFlagCount: 1,
+        aiStoreList: 1,
+
+      },
+    } );
+
+    let getTotalCount = await processedchecklistService.aggregate( findQuery );
+    if ( !getTotalCount.length ) {
+      return res.sendError( { error: 'No Data Found' }, 204 );
+    }
+
+    if ( requestData.sortColumnName && requestData.sortColumnName != '' && requestData.sortBy && requestData.sortBy !='' ) {
+      findQuery.push( { $sort: { [requestData.sortColumnName]: requestData.sortBy } } );
+    } else {
+      findQuery.push( { $sort: { ['submittedChecklist']: -1 } } );
+    }
+
+    if ( !requestData.export ) {
+      let limit = parseInt( requestData?.limit ) || 10;
+      let skip = limit * ( requestData?.offset ) || 0;
+      findQuery.push( { $skip: skip }, { $limit: limit } );
+    }
+
+
+    let getChecklistPerformanceData = await processedchecklistService.aggregate( findQuery );
+
+    if ( getChecklistPerformanceData.length ) {
+      const detectionChecklists = getChecklistPerformanceData?.filter( ( val ) => val?.checkListType !== 'custom' );
+
+      if ( detectionChecklists?.length ) {
+        const detectionPayload = {
+          'fromDate': requestData.fromDate,
+          'toDate': requestData.toDate,
+          'storeId': requestData.storeId,
+          'clientId': requestData.clientId,
+        };
+
+        let LamdaURL = 'https://f65azvtljclaxp6l7rnx65cdmm0lcgvp.lambda-url.ap-south-1.on.aws/';
+        let resultData = await LamdaServiceCall( LamdaURL, detectionPayload );
+        if ( resultData ) {
+          if ( resultData.status_code == '200' ) {
+            for ( let index = 0; index < getChecklistPerformanceData.length; index++ ) {
+              if ( getChecklistPerformanceData[index].checkListType !== 'custom' ) {
+                getChecklistPerformanceData[index].coverage = 'Store';
+                getChecklistPerformanceData[index].flagCount = resultData?.[getChecklistPerformanceData[index]?.checkListType] || 0;
+                getChecklistPerformanceData[index].flaggedStores = resultData?.[`${getChecklistPerformanceData[index]?.checkListType}_flaggedstores`] || 0;
+                getChecklistPerformanceData[index].assignedStores = getChecklistPerformanceData[index]?.aiStoreList?.filter( ( element ) => requestData.storeId.includes( element ) )?.length || 0;
+                getChecklistPerformanceData[index].complianceRate = ( 100- ( getChecklistPerformanceData[index].flaggedStores / getChecklistPerformanceData[index].assignedStores ) * 100 );
+                getChecklistPerformanceData[index].complianceRate = Math.min( 100, Math.max( 0, getChecklistPerformanceData[index].complianceRate ) );
+                getChecklistPerformanceData[index].complianceRate = ( getChecklistPerformanceData[index].complianceRate % 1 === 0 ) ? getChecklistPerformanceData[index].complianceRate.toFixed( 0 ) : getChecklistPerformanceData[index].complianceRate.toFixed( 2 );
+              }
+            }
+          }
+        }
+      }
+    }
+
+    if ( requestData.export ) {
+      const exportdata = [];
+      getChecklistPerformanceData.forEach( ( element ) => {
+        const data = {
+          'Checklist Name': element.checkListName,
+          'Coverage': element.coverage || 'Store',
+          'Flag Type': element?.checkListType === 'custom' ? 'Question' : 'Detection',
+          'Assigned Stores': element?.assignedStores,
+          'Flagged Stores': element?.flaggedStores,
+          'Compliance': element?.complianceRate,
+          'Flagged Count': element?.flagCount,
+          'Question Flags': element?.customQuestionFlagCount,
+          'Not Submitted Flags': element?.customTimeFlagCount,
+        };
+        if ( requestData?.filter === 'question' ) {
+          delete data['Flagged Count'];
+          delete data['Not Submitted Flags'];
+        } else if ( requestData?.filter === 'time' ) {
+          delete data['Flagged Count'];
+          delete data['Question Flags'];
+        } else if ( requestData?.filter === 'detection' ) {
+          delete data['Not Submitted Flags'];
+          delete data['Question Flags'];
+        }
+        exportdata.push( data );
+      } );
+      return await download( exportdata, res );
+    }
+
+
+    result.totalCount = getTotalCount.length;
+    result.checklistPerformance = getChecklistPerformanceData;
+    return res.sendSuccess( result );
+  } catch ( error ) {
+    console.log( 'error =>', error );
+    logger.error( { error: error, message: req.query, function: 'checklistPerformance' } );
+    return res.sendError( { error: error }, 500 );
+  }
+};

package/src/controllers/trax.controller.js

@@ -2610,3 +2610,104 @@ export const selectAssign = async ( req, res ) => {
   }
 };
 
+export const checklistV2 = async ( req, res ) => {
+  try {
+    let limit = parseInt( req.query.limit ) || 10;
+    let offset = parseInt( req.query.offset - 1 ) || 0;
+    let page = offset * limit;
+    let query = [];
+    query.push(
+        {
+          $match: {
+            type: 'checklist',
+            client_id: req.query.clientId,
+            isdeleted: false,
+            ...( req.user.userType == 'client' && req.user.role != 'superadmin' ) ? { 'owner.value': { $in: [ req.user.email ] } } : {},
+          },
+        },
+    );
+
+    if ( req.query.search && req.query.search != '' ) {
+      req.query.search = req.query.search.replace( /([.*+?^=!:${}()|\[\]\/\\])/g, '\\$1' );
+      query.push( {
+        $match: {
+          checkListName: { $regex: new RegExp( req.query.search, 'i' ) },
+        },
+      } );
+    }
+
+    query.push(
+        {
+          $project: {
+            checkList: { $toLower: '$checkListName' },
+            checkListName: 1,
+            coverage: 1,
+            createdBy: 1,
+            userName: { $toLower: '$createdByName' },
+            createdByName: 1,
+            storeCount: 1,
+            createdAt: 1,
+            publish: 1,
+            checkListType: 1,
+            questionCount: 1,
+            checkListChar: { $substr: [ '$checkListName', 0, 2 ] },
+          },
+        },
+    );
+
+    if ( req.query.sortColumnName && req.query.sortColumnName != '' && req.query.sortBy != '' ) {
+      if ( req.query.sortColumnName == 'status' ) {
+        req.query.sortColumnName = 'publish';
+      }
+      if ( req.query.sortColumnName != 'publish' ) {
+        query.push( {
+          $addFields: { lowerName: { $toLower: `$${req.query.sortColumnName}` } },
+        } );
+        query.push( {
+          $sort: { lowerName: parseInt( req.query.sortBy ) },
+        } );
+      } else {
+        query.push( {
+          $sort: { publish: parseInt( req.query.sortBy ) },
+        } );
+      }
+    } else {
+      query.push(
+          { $sort: { createdAt: -1 } },
+      );
+    }
+
+    query.push( {
+      $facet: {
+        data: [
+          { $skip: page },
+          { $limit: limit },
+        ],
+        count: [
+          { $count: 'totalCount' },
+        ],
+      },
+    } );
+
+    let checkList = await checklistService.aggregate( query );
+
+    if ( !checkList[0].data.length ) {
+      return res.sendError( 'no data found', 204 );
+    }
+
+    checkList[0].data.forEach( ( item ) => {
+      if ( item.storeCount > 0 && item.storeCount <= 9 ) {
+        item.storeCount = '0' + item.storeCount;
+      }
+      if ( item.questionCount > 0 && item.questionCount <= 9 ) {
+        item.questionCount = '0' + item.questionCount;
+      }
+      item.createdAt = dayjs( item.createdAt ).format( 'DD MMM, YYYY' );
+    } );
+
+    return res.sendSuccess( { result: checkList[0].data, count: checkList[0].count[0].totalCount } );
+  } catch ( e ) {
+    logger.error( 'checklist V2 =>', e );
+    return res.sendError( e, 500 );
+  }
+};

package/src/controllers/traxDashboard.controllers.js

@@ -3641,3 +3641,166 @@ export async function sendAlert( req, res ) {
     return res.sendError( e, 500 );
   }
 }
+
+export const checklistPerformanceV2 = async ( req, res ) => {
+  try {
+    let requestData = req.body;
+    let fromDate = new Date( requestData.fromDate );
+    let toDate = new Date( requestData.toDate );
+    let userTimezoneOffset = toDate.getTimezoneOffset() * 60000;
+    toDate = new Date( toDate.getTime() - userTimezoneOffset );
+    toDate.setUTCHours( 23, 59, 59, 59 );
+    let result = {};
+
+    let findQuery = [];
+    let findAndQuery = [];
+    findAndQuery.push(
+        { checkListType: { $eq: 'custom' } },
+        { date_iso: { $gte: fromDate, $lte: toDate } },
+        { client_id: requestData.clientId },
+        { store_id: { $in: requestData.storeId } },
+    );
+
+    findQuery.push( { $match: { $and: findAndQuery } } );
+
+    if ( requestData.searchValue && requestData.searchValue != '' ) {
+      let checkListSearch = requestData.searchValue.split( ',' ).map( ( item ) => item.trim().toLowerCase() );
+      let query;
+      if ( checkListSearch.length > 1 ) {
+        findQuery.push( { $addFields: { cheklistlowercase: { $toLower: '$checkListName' } } } );
+        query = { cheklistlowercase: { $in: checkListSearch } };
+      } else {
+        query = { checkListName: { $regex: requestData.searchValue.trim(), $options: 'i' } };
+      }
+      findQuery.push( { $match: { $or: [ query ] } } );
+    }
+
+    findQuery.push( {
+      $group: {
+        _id: '$sourceCheckList_id',
+        sourceCheckList_id: { $last: '$sourceCheckList_id' },
+        checkListName: { $last: '$checkListName' },
+        coverage: { $last: '$coverage' },
+        checkListChar: { $last: { $substr: [ '$checkListName', 0, 2 ] } },
+        scheduleRepeatedType: { $last: '$scheduleRepeatedType' },
+        // storeCount: { $max: '$storeCount' },
+        storeCount: { $sum: 1 },
+        submittedChecklist: {
+          $sum: {
+            $cond: [ { $eq: [ '$checklistStatus', 'submit' ] }, 1, 0 ],
+          },
+        },
+        timeFlag: { $sum: '$timeFlag' },
+        questionFlagCount: { $sum: '$questionFlag' },
+        checkListType: { $last: '$checkListType' },
+        redo: { $sum: { $cond: [ { $eq: [ '$redoStatus', true ] }, 1, 0 ] } },
+        task: {
+          $sum: {
+            $reduce: {
+              input: '$questionAnswers',
+              initialValue: 0,
+              in: {
+                $add: [
+                  '$$value',
+                  {
+                    $reduce: {
+                      input: { $ifNull: [ '$$this.questions', [] ] },
+                      initialValue: 0,
+                      in: {
+                        $add: [
+                          '$$value',
+                          {
+                            $cond: [
+                              { $ifNull: [ '$$this.taskId', false ] },
+                              1,
+                              0,
+                            ],
+                          },
+                        ],
+                      },
+                    },
+                  },
+                ],
+              },
+            },
+          },
+        },
+      },
+    } );
+    findQuery.push( {
+      $project: {
+        _id: 1,
+        sourceCheckList_id: 1,
+        checkListName: 1,
+        checkListChar: 1,
+        coverage: {
+          $concat: [
+            { $toUpper: { $substr: [ { $ifNull: [ '$coverage', '' ] }, 0, 1 ] } },
+            { $substr: [ { $ifNull: [ '$coverage', '' ] }, 1, { $strLenCP: { $ifNull: [ '$coverage', '' ] } } ] },
+          ],
+        },
+        scheduleRepeatedType: {
+          $concat: [
+            { $toUpper: { $substr: [ '$scheduleRepeatedType', 0, 1 ] } }, // Capitalize the first letter
+            { $substr: [ '$scheduleRepeatedType', 1, { $strLenCP: '$scheduleRepeatedType' } ] }, // Append the rest of the string
+          ],
+        },
+        storeCount: 1,
+        submittedChecklist: 1,
+        flaggedChecklist: { $add: [ '$timeFlag', '$questionFlagCount' ] },
+        checkListType: 1,
+        redo: 1,
+        task: 1,
+      },
+    } );
+
+    if ( requestData.sortColumnName && requestData.sortColumnName != '' && requestData.sortBy && requestData.sortBy !='' ) {
+      findQuery.push( { $sort: { [requestData.sortColumnName]: requestData.sortBy } } );
+    } else {
+      findQuery.push( { $sort: { ['submittedChecklist']: -1 } } );
+    }
+
+    let limit = parseInt( requestData?.limit ) || 10;
+    let skip = limit * ( requestData?.offset ) || 0;
+
+    findQuery.push( {
+      $facet: {
+        data: [
+          { $skip: skip }, { $limit: limit },
+        ],
+        count: [
+          { $count: 'total' },
+        ],
+      },
+    } );
+    let getChecklistPerformanceData = await processedchecklistService.aggregate( findQuery );
+    if ( !getChecklistPerformanceData[0].data.length ) {
+      return res.sendError( 'no data found', 204 );
+    }
+
+    if ( requestData.export ) {
+      const exportdata = [];
+      getChecklistPerformanceData[0].data.forEach( ( element ) => {
+        exportdata.push( {
+          'Checklist Name': element.checkListName || '--',
+          'Coverage': element.coverage || '--',
+          'Scheduled': element.scheduleRepeatedType || '--',
+          'Assigned To': element.storeCount || '--',
+          'Submitted': element.submittedChecklist || '--',
+          'Flags': element.flaggedChecklist || '--',
+          'Tasks': element.task || '--',
+          'ReDo': element.redo || '--',
+        } );
+      } );
+      return await download( exportdata, res );
+    }
+
+    result.totalCount = getChecklistPerformanceData[0].count[0].total;
+    result.checklistPerformance = getChecklistPerformanceData[0].data;
+    return res.sendSuccess( result );
+  } catch ( error ) {
+    console.log( 'error =>', error );
+    logger.error( { error: error, message: req.query, function: 'checklistPerformance' } );
+    return res.sendError( { error: error }, 500 );
+  }
+};