tango-app-api-store-builder 1.0.0-beta-134 → 1.0.0-beta-136

package/src/controllers/storeBuilder.controller.js

@@ -2644,7 +2644,7 @@ export async function storeFixturesv2( req, res ) {
             { storeId: { $in: req.body.id } },
           ],
         },
-        { storeId: 1, storeName: 1, planoId: '$_id', productResolutionLevel: 1, scanType: 1, clientId: 1, validateShelfSections: 1 },
+        { storeId: 1, storeName: 1, planoId: '$_id', productResolutionLevel: 1, scanType: 1, clientId: 1, validateShelfSections: 1, planoProgress: 1 },
     );
 
     if ( !planograms?.length ) return res.sendError( 'No data found', 204 );
@@ -2669,7 +2669,6 @@ export async function storeFixturesv2( req, res ) {
                         floorId: floor._id,
                         associatedElementType: element.elementType,
                         associatedElementNumber: element.elementNumber,
-                        fixtureType: 'wall',
                       }, { shelfcount: 0 }, { fixtureNumber: 1 } );
 
                       const fixturesWithStatus = await Promise.all(
@@ -2765,7 +2764,10 @@ export async function storeFixturesv2( req, res ) {
 
                 const centerFixtures = await storeFixtureService.find( {
                   floorId: floor._id,
-                  fixtureType: 'floor',
+                  $and: [
+                    { associatedElementType: { $exists: false } },
+                    { associatedElementNumber: { $exists: false } },
+                  ],
                 } );
 
                 const centerFixturesWithStatus = await Promise.all(
@@ -2990,7 +2992,6 @@ export async function storeFixturesTaskv2( req, res ) {
                         floorId: floor._id,
                         associatedElementType: element.elementType,
                         associatedElementNumber: element.elementNumber,
-                        fixtureType: 'wall',
                       }, { shelfcount: 0 }, { fixtureNumber: 1 } );
 
                       const fixturesWithStatus = await Promise.all(
@@ -3012,7 +3013,7 @@ export async function storeFixturesTaskv2( req, res ) {
 
                             const compliance = await planoTaskComplianceService.findOne( {
                               fixtureId: fixture._id,
-                              type: req.body?.type ? req.body.type : 'fixture',
+                              type: req.body?.type ? req.body.type : 'fixture', date_string: req.body.date,
                             }, { status: 1, answers: 1, taskType: 1 } );
 
                             const shelves = await fixtureShelfService.findAndSort( { fixtureId: fixture._id }, { }, { shelfNumber: 1 } );
@@ -3048,10 +3049,13 @@ export async function storeFixturesTaskv2( req, res ) {
                                   issue?.Details?.some( ( detail ) => detail.status === 'disagree' ),
                                 ),
                               );
-                              if ( hasDisagree || compliance?.taskType == 'redo' ) {
+                              if ( hasDisagree ) {
                                 redoCount++;
                                 disabled = false;
                               }
+                              if ( compliance?.taskType == 'redo' ) {
+                                disabled = false;
+                              }
                             }
 
                             return {
@@ -3084,7 +3088,10 @@ export async function storeFixturesTaskv2( req, res ) {
 
                 const centerFixtures = await storeFixtureService.find( {
                   floorId: floor._id,
-                  fixtureType: 'floor',
+                  $and: [
+                    { associatedElementType: { $exists: false } },
+                    { associatedElementNumber: { $exists: false } },
+                  ],
                 } );
 
                 const centerFixturesWithStatus = await Promise.all(
@@ -3106,7 +3113,7 @@ export async function storeFixturesTaskv2( req, res ) {
 
                       const compliance = await planoTaskComplianceService.findOne( {
                         fixtureId: fixture._id,
-                        type: req.body?.type ? req.body.type : 'fixture',
+                        type: req.body?.type ? req.body.type : 'fixture', date_string: req.body.date,
                       }, { status: 1, answers: 1, taskType: 1 } );
 
                       const shelves = await fixtureShelfService.findAndSort( { fixtureId: fixture._id }, { }, { shelfNumber: 1 } );
@@ -3142,10 +3149,13 @@ export async function storeFixturesTaskv2( req, res ) {
                           ),
                         );
 
-                        if ( hasDisagree || compliance.taskType == 'redo' ) {
+                        if ( hasDisagree ) {
                           redoCount++;
                           disabled = false;
                         }
+                        if ( compliance.taskType == 'redo' ) {
+                          disabled = false;
+                        }
                       }
 
                       return {
@@ -3288,6 +3298,7 @@ export async function planoList( req, res ) {
                 dateString: { $last: '$date_string' },
                 checklistStatus: { $last: '$checklistStatus' },
                 taskId: { $last: '$_id' },
+                scheduleEndTime_iso: { $last: '$scheduleEndTime_iso' },
               },
             },
             {
@@ -3299,6 +3310,16 @@ export async function planoList( req, res ) {
                     status: '$checklistStatus',
                     date: '$dateString',
                     floorId: '$_id.floorId',
+                    endTime: '$scheduleEndTime_iso',
+                    breach: {
+                      $cond: {
+                        if: {
+                          $gte: [ '$scheduleEndTime_iso', new Date() ],
+                        },
+                        then: false,
+                        else: true,
+                      },
+                    },
                   },
                 },
                 taskIds: { $push: '$taskId' },
@@ -3555,28 +3576,31 @@ export async function planoList( req, res ) {
         },
       } );
     }
-    if ( inputData?.filter?.taskPending?.length && inputData?.filter?.taskPending != 'all' ) {
-      let andQuery = [];
+    if ( inputData?.filter?.taskPending?.length && inputData?.filter?.taskPending !== 'all' ) {
+      let andQuery = [ {
+        'planoTask.taskStatus': {
+          $elemMatch: {
+            type: inputData.filter.taskPending,
+            status: 'submit',
+          },
+        },
+      } ];
 
-      if ( inputData.filter.taskPending == 'layout' ) {
+      if ( inputData.filter.taskPending === 'layout' ) {
         andQuery.push(
-            { 'planoTask.taskStatus.type': 'layout' },
-            { 'planoTask.taskStatus.status': 'submit' },
             { 'taskDetails.layoutStatus': 'pending' },
         );
       }
-      if ( inputData.filter.taskPending == 'fixture' ) {
+
+      if ( inputData.filter.taskPending === 'fixture' ) {
         andQuery.push(
-            { 'planoTask.taskStatus.type': 'fixture' },
-            { 'planoTask.taskStatus.status': 'submit' },
             { 'taskDetails.fixtureStatus': 'pending' },
         );
       }
-      if ( inputData.filter.taskPending == 'vm' ) {
+
+      if ( inputData.filter.taskPending === 'vm' ) {
         andQuery.push(
-            { 'planoTask.taskStatus.type': 'vm' },
             { 'taskDetails.vmStatus': 'pending' },
-            { 'planoTask.taskStatus.status': 'submit' },
         );
       }
 
@@ -3587,6 +3611,27 @@ export async function planoList( req, res ) {
       } );
     }
 
+    if ( inputData?.filter?.flag?.length ) {
+      let andQuery = [];
+      andQuery.push(
+          {
+            'planoTask.taskStatus': {
+              $elemMatch: {
+                type: { $in: inputData.filter.flag },
+                status: { $ne: 'submit' },
+                breach: true,
+              },
+            },
+          },
+          { 'taskDetails.layoutStatus': 'pending' },
+      );
+      query.push( {
+        $match: {
+          $and: andQuery,
+        },
+      } );
+    }
+
     let orQuery = [];
 
     if ( inputData.filter.status.length ) {
@@ -3598,10 +3643,8 @@ export async function planoList( req, res ) {
         orQuery.push( { $and: [ { 'taskDetails.fixtureStatus': 'pending' }, { 'planoTask.taskStatus.type': 'fixture' }, { 'planoTask.taskStatus.status': 'submit' } ] } );
         orQuery.push( { $and: [ { 'taskDetails.vmStatus': 'pending' }, { 'planoTask.taskStatus.type': 'vm' }, { 'planoTask.taskStatus.status': 'submit' } ] } );
       }
-      if ( inputData.filter.status.includes( 'complete' ) ) {
-        orQuery.push( { 'taskDetails.layoutStatus': 'complete' } );
-        orQuery.push( { 'taskDetails.fixtureStatus': 'complete' } );
-        orQuery.push( { 'taskDetails.vmStatus': 'complete' } );
+      if ( inputData.filter.status.includes( 'completed' ) ) {
+        orQuery.push( { $and: [ { 'taskDetails.layoutStatus': 'complete' }, { 'taskDetails.fixtureStatus': 'complete' }, { 'taskDetails.vmStatus': 'complete' } ] } );
       }
       if ( inputData.filter.status.includes( 'yetToAssign' ) ) {
         orQuery.push( { $expr: { $eq: [ { $size: '$planoTask' }, 0 ] } } );
@@ -3643,16 +3686,23 @@ export async function planoList( req, res ) {
       },
     } );
 
-    let planoDetails = await planoService.aggregate( query );
+    const [ planoDetails, planoIdList ] = await Promise.all( [
+
+      await planoService.aggregate( query ),
+      await planoService.find( { clientId: inputData.clientId,
+        storeId: { $in: storeDetails } }, { _id: 1 } ),
+    ] );
+
 
     if ( !planoDetails[0].data.length ) {
       return res.sendError( 'No data found', 204 );
     }
 
+
     let taskQuery = [
       {
         $match: {
-          planoId: { $in: planoDetails?.[0]?.planoList?.[0]?.idList },
+          planoId: { $in: planoIdList.map( ( ele ) => ele._id ) },
           isPlano: true,
           date_iso: { $lte: new Date( dayjs().format( 'YYYY-MM-DD' ) ) },
         },
@@ -3789,11 +3839,11 @@ export async function planoList( req, res ) {
       },
     ];
 
-    pendingDetails = await planoTaskComplianceService.aggregate( query );
+    pendingDetails = await planoTaskComplianceService.aggregate( taskQuery );
     let result = {
       data: planoDetails[0].data,
       count: planoDetails?.[0]?.count?.[0]?.total || 0,
-      pendingDetails: [ { ...pendingDetails?.[0], allStores: planoDetails?.[0]?.count?.[0]?.total || 0 } ],
+      pendingDetails: [ { ...pendingDetails?.[0], allStores: planoIdList?.length || 0 } ],
     };
     return res.sendSuccess( result );
   } catch ( e ) {
@@ -3801,3 +3851,335 @@ export async function planoList( req, res ) {
     return res.sendError( e, 500 );
   }
 }
+
+export async function getTaskDetails( req, res ) {
+  try {
+    if ( !req.query.planoId ) {
+      return res.sendError( 'PlanoId is required', 400 );
+    }
+    let query = [
+      {
+        $match: {
+          planoId: new mongoose.Types.ObjectId( req.query.planoId ),
+          isPlano: true,
+          date_iso: { $lte: new Date( dayjs().format( 'YYYY-MM-DD' ) ) },
+        },
+      },
+      {
+        $group: {
+          _id: { type: '$planoType', floorId: '$floorId' },
+          dateString: { $last: '$date_string' },
+          checklistStatus: { $last: '$checklistStatus' },
+          taskId: { $last: '$_id' },
+          redoStatus: { $last: '$redoStatus' },
+          scheduleEndTime_iso: { $last: '$scheduleEndTime_iso' },
+        },
+      },
+      {
+        $group: {
+          _id: null,
+          taskStatus: {
+            $push: {
+              type: '$_id.type',
+              status: '$checklistStatus',
+              date: '$dateString',
+              floorId: '$_id.floorId',
+              redoStatus: '$redoStatus',
+              endTime: '$scheduleEndTime_iso',
+              breach: {
+                $cond: {
+                  if: {
+                    $gte: [ '$scheduleEndTime_iso', new Date() ],
+                  },
+                  then: false,
+                  else: true,
+                },
+              },
+            },
+          },
+          taskIds: { $push: '$taskId' },
+        },
+      },
+      {
+        $lookup: {
+          from: 'planotaskcompliances',
+          let: {
+            task: '$taskIds',
+          },
+          pipeline: [
+            {
+              $match: {
+                $expr: {
+                  $and: [
+                    { $eq: [ '$planoId', new mongoose.Types.ObjectId( req.query.planoId ) ] },
+                    { $in: [ '$taskId', '$$task' ] },
+                    { $eq: [ '$status', 'incomplete' ] },
+                  ],
+                },
+              },
+            },
+            { $sort: { _id: -1 } },
+            {
+              $set: {
+                hasPendingIssues: {
+                  $anyElementTrue: {
+                    $map: {
+                      input: {
+                        $reduce: {
+                          input: '$answers',
+                          initialValue: [],
+                          in: {
+                            $concatArrays: [
+                              '$$value',
+                              {
+                                $reduce: {
+                                  input: { $ifNull: [ '$$this.issues', [] ] },
+                                  initialValue: [],
+                                  in: {
+                                    $concatArrays: [
+                                      '$$value',
+                                      { $ifNull: [ '$$this.Details', [] ] },
+                                    ],
+                                  },
+                                },
+                              },
+                            ],
+                          },
+                        },
+                      },
+                      as: 'detail',
+                      in: {
+                        $or: [
+                          { $eq: [ '$$detail.status', 'pending' ] },
+                        ],
+                      },
+                    },
+                  },
+                },
+              },
+            },
+            {
+              $group: {
+                _id: '$floorId',
+                layoutCount: {
+                  $sum: { $cond: [ { $eq: [ '$type', 'layout' ] }, 1, 0 ] },
+                },
+                fixtureCount: {
+                  $sum: { $cond: [ { $eq: [ '$type', 'fixture' ] }, 1, 0 ] },
+                },
+                vmCount: {
+                  $sum: { $cond: [ { $eq: [ '$type', 'vm' ] }, 1, 0 ] },
+                },
+                layoutPending: {
+                  $sum: {
+                    $cond: [
+                      { $and: [ { $eq: [ '$type', 'layout' ] }, '$hasPendingIssues' ] },
+                      1,
+                      0,
+                    ],
+                  },
+                },
+                fixturePending: {
+                  $sum: {
+                    $cond: [
+                      { $and: [ { $eq: [ '$type', 'fixture' ] }, '$hasPendingIssues' ] },
+                      1,
+                      0,
+                    ],
+                  },
+                },
+                vmPending: {
+                  $sum: {
+                    $cond: [
+                      { $and: [ { $eq: [ '$type', 'vm' ] }, '$hasPendingIssues' ] },
+                      1,
+                      0,
+                    ],
+                  },
+                },
+              },
+            },
+            {
+              $group: {
+                _id: null,
+                layoutCount: { $sum: '$layoutCount' },
+                fixtureCount: { $sum: '$fixtureCount' },
+                vmCount: { $sum: '$vmCount' },
+                completeLayout: {
+                  $sum: {
+                    $cond: {
+                      if: {
+                        $and: [
+                          { '$gt': [ '$layoutCount', 0 ] },
+                          { '$gt': [ '$layoutPending', 0 ] },
+                          { '$gt': [ '$fixtureCount', 0 ] },
+                          { '$gt': [ '$fixturePending', 0 ] },
+                          { '$gt': [ '$vmCount', 0 ] },
+                          { '$gt': [ '$fixturePending', 0 ] },
+                        ],
+                      },
+                      then: 1,
+                      else: 0,
+                    },
+                  },
+                },
+                layoutPending: { $sum: '$layoutPending' },
+                fixturePending: { $sum: '$fixturePending' },
+                vmPending: { $sum: '$vmPending' },
+              },
+            },
+            {
+              $project: {
+                _id: 0,
+                layoutStatus: {
+                  $cond: {
+                    if: {
+                      $and: [
+                        { $gt: [ '$layoutCount', 0 ] },
+                        { $eq: [ '$layoutPending', 0 ] },
+                      ],
+                    },
+                    then: 'complete',
+                    else: {
+                      $cond: {
+                        if: {
+                          $and: [
+                            {
+                              $gt: [ '$layoutCount', 0 ],
+                            },
+                            {
+                              $gt: [
+                                '$layoutPending',
+                                0,
+                              ],
+                            },
+                          ],
+                        },
+                        then: 'pending',
+                        else: '',
+                      },
+                    },
+                  },
+                },
+                fixtureStatus: {
+                  $cond: {
+                    if: {
+                      $and: [
+                        { $gt: [ '$fixtureCount', 0 ] },
+                        {
+                          $eq: [ '$fixturePending', 0 ],
+                        },
+                      ],
+                    },
+                    then: 'complete',
+                    else: {
+                      $cond: {
+                        if: {
+                          $and: [
+                            {
+                              $gt: [
+                                '$fixtureCount',
+                                0,
+                              ],
+                            },
+                            {
+                              $gt: [
+                                '$fixturePending',
+                                0,
+                              ],
+                            },
+                          ],
+                        },
+                        then: 'pending',
+                        else: '',
+                      },
+                    },
+                  },
+                },
+                vmStatus: {
+                  $cond: {
+                    if: {
+                      $and: [
+                        { $gt: [ '$vmCount', 0 ] },
+                        { $eq: [ '$vmPending', 0 ] },
+                      ],
+                    },
+                    then: 'complete',
+                    else: {
+                      $cond: {
+                        if: {
+                          $and: [
+                            { $gt: [ '$vmCount', 0 ] },
+                            { $gt: [ '$vmPending', 0 ] },
+                          ],
+                        },
+                        then: 'pending',
+                        else: '',
+                      },
+                    },
+                  },
+                },
+                layoutPending: 1,
+                fixturePending: 1,
+                vmPending: 1,
+                layoutCount: 1,
+                fixtureCount: 1,
+                vmCount: 1,
+                completeLayout: 1,
+              },
+            },
+          ],
+          as: 'taskDetails',
+        },
+      },
+      {
+        $project: {
+          _id: 0,
+          taskStatus: {
+            $map: {
+              input: '$taskStatus',
+              as: 'task',
+              in: {
+                type: '$$task.type',
+                status: '$$task.status',
+                date: '$$task.date',
+                floorId: '$$task.floorId',
+                redoStatus: '$$task.redoStatus',
+                endTime: '$$task.endTime',
+                breach: '$$task.breach',
+                feedbackStatus: {
+                  $switch: {
+                    branches: [
+                      {
+                        case: { $eq: [ '$$task.type', 'layout' ] },
+                        then: { $arrayElemAt: [ '$taskDetails.layoutStatus', 0 ] },
+                      },
+                      {
+                        case: { $eq: [ '$$task.type', 'fixture' ] },
+                        then: { $arrayElemAt: [ '$taskDetails.fixtureStatus', 0 ] },
+                      },
+                      {
+                        case: { $eq: [ '$$task.type', 'vm' ] },
+                        then: { $arrayElemAt: [ '$taskDetails.vmStatus', 0 ] },
+                      },
+                    ],
+                    default: '',
+                  },
+                },
+              },
+            },
+          },
+        },
+      },
+
+    ];
+
+    let taskInfo = await planotaskService.aggregate( query );
+    let disabledInfo = taskInfo?.[0]?.taskStatus?.filter( ( ele ) => ( ( ele.feedbackStatus && ele.feedbackStatus != 'complete' ) || ele.status != 'submit' ) && !ele?.breach );
+    console.log( disabledInfo );
+    return res.sendSuccess( { taskDetails: taskInfo?.[0]?.taskStatus, disabled: disabledInfo?.length ? true : false } );
+  } catch ( e ) {
+    logger.error( { functionName: 'getTaskDetails', error: e } );
+    return res.sendError( e, 500 );
+  }
+}

package/src/controllers/task.controller.js

@@ -301,7 +301,11 @@ export async function createTask( req, res ) {
                 }
                 await planoService.updateOne( { _id: planoDetails?._id }, { $set: { planoProgress } } );
                 let currDate = dayjs().add( j, 'day' );
-                let insertData = { ...taskData, date_string: currDate.format( 'YYYY-MM-DD' ), date_iso: new Date( currDate.format( 'YYYY-MM-DD' ) ), scheduleStartTime_iso: dayjs.utc( `${currDate.format( 'YYYY-MM-DD' )} 12:00 AM`, 'YYYY-MM-DD hh:mm A' ).format() };
+                let time = '12:00 AM';
+                if ( currDate.format( 'YYYY-MM-DD' ) == dayjs().format( 'YYYY-MM-DD' ) ) {
+                  time = dayjs().format( 'hh:mm A' );
+                }
+                let insertData = { ...taskData, date_string: currDate.format( 'YYYY-MM-DD' ), date_iso: new Date( currDate.format( 'YYYY-MM-DD' ) ), scheduleStartTime_iso: dayjs.utc( `${currDate.format( 'YYYY-MM-DD' )} ${time}`, 'YYYY-MM-DD hh:mm A' ).format() };
                 await processedService.updateOne( { date_string: currDate.format( 'YYYY-MM-DD' ), store_id: insertData.store_id, userEmail: insertData.userEmail, planoId: insertData.planoId, sourceCheckList_id: task._id, ...( taskData?.floorId ) ? { floorId: taskData.floorId }:{} }, insertData );
               }
             }
@@ -589,7 +593,6 @@ export async function updateAnswers( req, res ) {
 export async function updateAnswersv2( req, res ) {
   try {
     let taskDetails = await processedService.findOne( { _id: new mongoose.Types.ObjectId( req.body.taskId ) } );
-    console.log( taskDetails );
     if ( !taskDetails ) {
       return res.sendError( 'No data found', 204 );
     }

package/src/routes/script.routes.js

@@ -31,4 +31,5 @@ scriptRouter
     .post( '/updateExcelPlanogram', scriptController.updateExcelPlanogram )
     .post( '/recorrectTaskData', scriptController.recorrectTaskData )
     .post( '/migrateCrest', scriptController.migrateCrestv1 )
+    .post( '/updatePlanoMappings', scriptController.updatePlanoMappings )
 ;

package/src/routes/storeBuilder.routes.js

@@ -44,9 +44,10 @@ storeBuilderRouter
     .post( '/checkPlanoExist', isAllowedSessionHandler, storeBuilderController.checkPlanoExist )
     .post( '/storeLayoutElements', isAllowedSessionHandler, storeBuilderController.storeLayoutElements )
     .post( '/qrScan', storeBuilderController.qrScan )
-    .post( '/storeFixturesV2', validate( validateDtos.storeList ), storeBuilderController.storeFixturesv2 )
-    .post( '/fixtureShelfDetailsv2', validate( validateDtos.fixtureShelfProduct ), storeBuilderController.fixtureShelfProductv2 )
-    .post( '/storeFixturesTaskv2', storeBuilderController.storeFixturesTaskv2 );
+    .post( '/storeFixturesV2', isAllowedSessionHandler, validate( validateDtos.storeList ), storeBuilderController.storeFixturesv2 )
+    .post( '/fixtureShelfDetailsv2', isAllowedSessionHandler, validate( validateDtos.fixtureShelfProduct ), storeBuilderController.fixtureShelfProductv2 )
+    .post( '/storeFixturesTaskv2', isAllowedSessionHandler, storeBuilderController.storeFixturesTaskv2 );
 
 storeBuilderRouter
-    .post( '/planoList', isAllowedSessionHandler, storeBuilderController.planoList );
+    .post( '/planoList', isAllowedSessionHandler, storeBuilderController.planoList )
+    .get( '/taskDetails', isAllowedSessionHandler, storeBuilderController.getTaskDetails );

package/src/service/fixtureShelf.service.js

@@ -47,3 +47,7 @@ export async function upsertOne( query, record ) {
       { upsert: true, new: true },
   );
 }
+
+export async function updateMany( query, record ) {
+  return model.fixtureShelfModel.updateMany( query, { $set: record } );
+}

package/src/service/planoTask.service.js

@@ -7,6 +7,9 @@ export async function create( data ) {
 export async function updateOne( query={}, record={} ) {
   return model.planoTaskCompliance.updateOne( query, { $set: record }, { upsert: true } );
 }
+export async function updateMany( query={}, record={} ) {
+  return model.planoTaskCompliance.updateMany( query, { $set: record } );
+}
 export async function updateOnefilters( query={}, record={}, arrayfilter=[] ) {
   return model.planoTaskCompliance.findOneAndUpdate( query, record, { arrayFilters: arrayfilter, returnDocument: 'after' } );
 }