tango-app-api-store-builder 1.0.0-beta-157 → 1.0.0-beta-159

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-store-builder",
-    "version": "1.0.0-beta-157",
+    "version": "1.0.0-beta-159",
     "description": "storeBuilder",
     "main": "index.js",
     "type": "module",

package/src/controllers/fixtureTemplate.controller.js

@@ -178,6 +178,7 @@ export async function duplicateTemplate( req, res ) {
     templateDetails = templateDetails.toObject();
     delete templateDetails._id;
     templateDetails.fixtureName = newFixtureName;
+    templateDetails.status = 'draft';
     let duplicateDetails = await fixtureConfigService.create( templateDetails );
     return res.sendSuccess( { message: 'Fixture template duplicated successfully', id: duplicateDetails._id } );
   } catch ( e ) {

package/src/controllers/managePlano.controller.js

@@ -307,7 +307,7 @@ function buildPipelineByType( type, planoId, floorId, filterByStatus, filterByAp
     pipeline.push( { $sort: { _id: -1 } } );
   }
 
-
+  console.log( pipeline );
   return pipeline;
 }
 
@@ -890,5 +890,60 @@ export async function getPlanoRevisionById( req, res ) {
     res.sendError( 'Failed to fetch plano revision', 500 );
   }
 }
+export async function getRolloutFeedback( req, res ) {
+  try {
+    const taskTypes = req.body.filterByTask && req.body.filterByTask.length > 0 ? req.body.filterByTask : [ 'merchRollout', 'vmRollout' ];
+    const filterByStatus = req.body.filterByStatus || [];
+    const filterByApprovalStatus = req.body.filterByApprovalStatus || '';
+    const resultMap = {};
+    const commentMap = {};
+    await Promise.all(
+        taskTypes.map( async ( type, index ) => {
+          console.log( type );
+          const pipeline = buildPipelineByType( type, req.body.planoId, req.body.floorId, filterByStatus, filterByApprovalStatus, req.body.showtask );
+
+          let data = await planoTaskService.aggregate( pipeline );
+          console.log( data );
+          if ( filterByApprovalStatus && filterByApprovalStatus !== '' ) {
+            console.log( '-------------1', filterByApprovalStatus );
+            data.forEach( ( element ) => {
+              element.answers?.forEach( ( ans ) => {
+                ans.issues = ans.issues?.filter(
+                    ( issue ) => issue.Details && issue.Details.length > 0,
+                );
+              } );
+              element.answers = element.answers?.filter(
+                  ( ans ) => ans.issues && ans.issues.length > 0,
+              );
+            } );
+            data = data.filter(
+                ( element ) => element.answers && element.answers.length > 0,
+            );
+          }
+
+
+          resultMap[type] = data;
+
+          const comments = await planoGlobalCommentService.find( {
+            planoId: new mongoose.Types.ObjectId( req.body.planoId ),
+            floorId: new mongoose.Types.ObjectId( req.body.floorId ),
+            taskType: type,
+          } );
+          commentMap[type] = comments;
+        } ),
+    );
+    const response = {
+      merchRolloutData: resultMap['merchRollout'] || [],
+      vmRolloutData: resultMap['vmRollout'] || [],
+      merchRolloutComment: commentMap['merchRollout'] || [],
+      vmRolloutComment: commentMap['vmRollout'] || [],
+    };
+
+    res.sendSuccess( response );
+  } catch ( e ) {
+    logger.error( { functionName: 'getRolloutFeedback', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
 
 

package/src/controllers/planoLibrary.controller.js

@@ -123,24 +123,6 @@ async function getMaxFixtureLibCode() {
 export async function createFixture( req, res ) {
   try {
     let FixLibCode = await getMaxFixtureLibCode();
-    let query = [
-      {
-        $addFields: {
-          fixtureCategoryLower: { $toLower: '$fixtureCategory' },
-        },
-      },
-      {
-        $match: {
-          'clientId': req.body.clientId,
-          'fixtureCategoryLower': req.body.fixtureCategory.toLowerCase(),
-          'fixtureWidth.value': 10,
-        },
-      },
-    ];
-    let fixLibDetails = await planoLibraryService.aggregate( query );
-    if ( fixLibDetails.length ) {
-      return res.sendError( `Fixture Name ${req.body.fixtureCategory} already Exists`, 400 );
-    }
     let data ={
       clientId: req.body.clientId,
       fixtureCategory: req.body.fixtureCategory,
@@ -184,7 +166,7 @@ export async function updateFixture( req, res ) {
           'clientId': req.body.clientId,
           'fixtureCategoryLower': req.body.fixtureCategory.toLowerCase(),
           'fixtureWidth.value': req.body.fixtureWidth.value,
-          '_id': { $ne: req.params.fixtureId },
+          '_id': { $ne: new ObjectId( req.params.fixtureId ) },
         },
       },
     ];
@@ -200,7 +182,6 @@ export async function updateFixture( req, res ) {
     await planoLibraryService.updateOne( { _id: req.params.fixtureId }, fixtureData );
     return res.sendSuccess( 'Fixture library details updated successfully' );
   } catch ( e ) {
-    console.log( e );
     logger.error( { functionName: 'updateFixture', error: e } );
     return res.sendError( e, 500 );
   }
@@ -541,6 +522,7 @@ export async function duplicateFixture( req, res ) {
     fixtureLibDetails.fixtureCategory = newFixName;
     let FixLibCode = await getMaxFixtureLibCode();
     fixtureLibDetails.fixtureLibCode = FixLibCode;
+    fixtureLibDetails.status = 'draft';
     let duplicateData = await planoLibraryService.create( fixtureLibDetails );
     return res.sendSuccess( { message: 'Fixture duplicated successfully', id: duplicateData._id } );
   } catch ( e ) {
@@ -1252,6 +1234,7 @@ export async function duplicateVmLib( req, res ) {
       }
     }
     vmDetails.vmName = newVMName;
+    vmDetails.status = 'draft';
     vmDetails.vmLibCode = await getMaxVMLibCode();
     let duplicateData = await vmService.create( vmDetails );
     return res.sendSuccess( { message: 'VM duplicated successfully', id: duplicateData._id } );

package/src/controllers/script.controller.js

@@ -7400,7 +7400,7 @@ export async function migrateCrestv1( req, res ) {
       clientId: '11',
       $and: [
         { storeName: req.body.storeName },
-        // { storeName: { $in: [ 'LKST1324', 'LKST495' ] } },
+        // { storeName: { $in: ['LKST98', 'LKST682', 'ST185', 'ST36', 'LKST1193'] } },
         // { storeName: { $nin: [ 'LKST98', 'LKST1193' ] } },
       ],
     };
@@ -7430,15 +7430,15 @@ export async function migrateCrestv1( req, res ) {
 
       const existingPlanogram = await planoService.findOne( { storeName: storeData.storeName } );
 
-      // if ( existingPlanogram ) {
-      //   const checkTaskSubmitted = await planoTaskService.findOne( { planoId: existingPlanogram.toObject()._id } );
+      if ( existingPlanogram ) {
+        const checkTaskSubmitted = await planoTaskService.findOne( { planoId: existingPlanogram.toObject()._id } );
 
-      //   const checkTaskCreated = await processedTaskService.findOne( { storeName: storeData.storeName, date_string: dayjs().format( 'YYYY-MM-DD' ), isPlano: true } );
+        const checkTaskCreated = await processedTaskService.findOne( { storeName: storeData.storeName, date_string: dayjs().format( 'YYYY-MM-DD' ), isPlano: true } );
 
-      //   if ( checkTaskSubmitted || checkTaskCreated ) {
-      //     continue;
-      //   }
-      // }
+        if ( checkTaskSubmitted || checkTaskCreated ) {
+          continue;
+        }
+      }
 
 
       if ( existingPlanogram?.toObject()?._id && mongoose.Types.ObjectId.isValid( existingPlanogram?.toObject()?._id ) ) {

package/src/controllers/storeBuilder.controller.js

@@ -1467,7 +1467,7 @@ export async function updateMissing( req, res ) {
 
           await Promise.all(
               productMappings.map( async ( mapping ) => {
-                const productData = productMap.get( mapping?.productId?.toString() );
+                const productData = productMap.get( mapping.productId.toString() );
                 if ( !productData ) {
                   return { ...mapping.toObject(), status: '' };
                 }
@@ -4507,3 +4507,833 @@ export async function getPlanoUser( req, res ) {
     return res.sendError( e, 500 );
   }
 }
+
+export async function getRolloutDetails( req, res ) {
+  try {
+    let page = req?.body?.offset || 1;
+    let limit = req.body?.limit || 10;
+    let skip = ( page -1 ) * limit;
+    let storeDetails = await storeService.find( { clientId: req.body.clientId, status: 'active' }, { storeId: 1 } );
+    storeDetails = storeDetails.map( ( ele ) => ele.storeId );
+    let query = [
+      {
+        $match: {
+          clientId: req.body.clientId,
+          planoProgress: 100,
+          storeId: { $in: storeDetails },
+        },
+      },
+      {
+        $lookup: {
+          from: 'storefixtures',
+          let: { floor: '$_id' },
+          pipeline: [
+            {
+              $match: {
+                $expr: {
+                  $eq: [ '$floorId', '$$floor' ],
+                },
+              },
+            },
+            {
+              $group: {
+                _id: '',
+                fixtureCount: { $sum: 1 },
+                vmCount: { $sum: { $size: '$vmConfig' } },
+                fixtureCapacity: { $sum: '$fixtureCapacity' },
+              },
+            },
+          ],
+          as: 'fixtureDetails',
+        },
+      },
+      { $unwind: { path: '$fixtureDetails', preserveNullAndEmptyArrays: true } },
+      {
+        $project: {
+          _id: 0,
+          planoId: 1,
+          layoutName: 1,
+          floorId: '$_id',
+          floorNumber: 1,
+          floorName: 1,
+          planoProgress: 1,
+          fixtureCount: '$fixtureDetails.fixtureCount',
+          vmCount: '$fixtureDetails.vmCount',
+          fixtureCapacity: '$fixtureDetails.fixtureCapacity',
+          storeId: 1,
+          storeName: 1,
+          lastUpdate: '$updatedAt',
+        },
+      },
+      {
+        $lookup: {
+          from: 'processedtasks',
+          let: { floorId: '$floorId' },
+          pipeline: [
+            {
+              $match: {
+                $expr: {
+                  $and: [
+                    { $lte: [ '$date_iso', new Date( dayjs().format( 'YYYY-MM-DD' ) ) ] },
+                    { $eq: [ '$floorId', '$$floorId' ] },
+                    { $eq: [ '$isPlano', true ] },
+                    { $in: [ '$planoType', [ 'merchRollout', 'vmRollout' ] ] },
+                  ],
+                },
+              },
+            },
+            {
+              $sort: { _id: -1 },
+            },
+            {
+              $group: {
+                _id: '$planoType',
+                type: { $first: '$planoType' },
+                status: { $first: '$checklistStatus' },
+                taskId: { $last: '$_id' },
+                scheduleEndTime_iso: { $last: '$scheduleEndTime_iso' },
+              },
+            },
+            {
+              $project: {
+                _id: 0,
+                type: 1,
+                status: 1,
+                taskId: 1,
+                breach: {
+                  $cond: {
+                    if: {
+                      $gte: [ '$scheduleEndTime_iso', new Date() ],
+                    },
+                    then: false,
+                    else: true,
+                  },
+                },
+              },
+            },
+          ],
+          as: 'taskDetails',
+        },
+      },
+      {
+        $lookup: {
+          from: 'planotaskcompliances',
+          let: { floorId: '$floorId', taskId: '$taskDetails.taskId' },
+          pipeline: [
+            {
+              $match: {
+                $expr: {
+                  $and: [
+                    { $eq: [ '$floorId', '$$floorId' ] },
+                    { $in: [ '$taskId', '$$taskId' ] },
+                    { $in: [ '$type', [ 'merchRollout', 'vmRollout' ] ] },
+                    { $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' ] },
+                        ],
+                      },
+                    },
+                  },
+                },
+                hasDisagreeIssues: {
+                  $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', 'disagree' ] },
+                        ],
+                      },
+                    },
+                  },
+                },
+              },
+            },
+            {
+              $group: {
+                _id: '$floorId',
+                merchCount: {
+                  $sum: { $cond: [ { $eq: [ '$type', 'merchRollout' ] }, 1, 0 ] },
+                },
+                vmCount: {
+                  $sum: { $cond: [ { $eq: [ '$type', 'vmRollout' ] }, 1, 0 ] },
+                },
+                merchPending: {
+                  $sum: {
+                    $cond: [
+                      { $and: [ { $eq: [ '$type', 'merchRollout' ] }, '$hasPendingIssues' ] },
+                      1,
+                      0,
+                    ],
+                  },
+                },
+                vmPending: {
+                  $sum: {
+                    $cond: [
+                      { $and: [ { $eq: [ '$type', 'vmRollout' ] }, '$hasPendingIssues' ] },
+                      1,
+                      0,
+                    ],
+                  },
+                },
+                merchDisagree: {
+                  $sum: {
+                    $cond: [
+                      { $and: [ { $eq: [ '$type', 'merchRollout' ] }, '$hasDisagreeIssues' ] },
+                      1,
+                      0,
+                    ],
+                  },
+                },
+                vmDisagree: {
+                  $sum: {
+                    $cond: [
+                      { $and: [ { $eq: [ '$type', 'vmRollout' ] }, '$hasDisagreeIssues' ] },
+                      1,
+                      0,
+                    ],
+                  },
+                },
+              },
+            },
+            {
+              $project: {
+                _id: 0,
+                fixtureStatus: {
+                  $switch: {
+                    branches: [
+                      {
+                        case: { $and: [ { $gt: [ '$merchCount', 0 ] }, { $gt: [ '$merchPending', 0 ] } ] },
+                        then: 'merchPending',
+                      },
+                      {
+                        case: { $and: [ { $gt: [ '$merchCount', 0 ] }, { $gt: [ '$merchDisagree', 0 ] } ] },
+                        then: 'merchDisagree',
+                      },
+                    ],
+                    default: '',
+                  },
+                },
+                vmStatus: {
+                  $switch: {
+                    branches: [
+                      {
+                        case: { $and: [ { $gt: [ '$vmCount', 0 ] }, { $gt: [ '$vmPending', 0 ] } ] },
+                        then: 'vmPending',
+                      },
+                      {
+                        case: { $and: [ { $gt: [ '$vmCount', 0 ] }, { $gt: [ '$vmDisagree', 0 ] } ] },
+                        then: 'vmDisagree',
+                      },
+                    ],
+                    default: '',
+                  },
+                },
+              },
+            },
+          ],
+          as: 'taskFeedback',
+        },
+      },
+    ];
+
+    if ( req.body?.filter?.type == 'rollout' ) {
+      query.push( {
+        $match: {
+          $expr: {
+            $gt: [ { $size: '$taskDetails' }, 0 ],
+          },
+        },
+      } );
+    }
+    if ( [ 'vm', 'merch' ].includes( req.body?.filter?.type ) ) {
+      let andCondition;
+      if ( req.body.filter.type == 'merch' ) {
+        andCondition = [
+          {
+            taskDetails: { $elemMatch: { type: 'merchRollout', status: 'submit' } },
+          },
+          {
+            compliance: { $elemMatch: { feedbackStatus: 'merchPending' } },
+          },
+        ];
+      } else {
+        andCondition = [
+          {
+            taskDetails: { $elemMatch: { type: 'vmRollout', status: 'submit' } },
+          },
+          {
+            compliance: { $elemMatch: { feedbackStatus: 'vmPending' } },
+          },
+        ];
+      }
+
+      query.push( {
+        $match: {
+          $and: andCondition,
+        },
+      } );
+    }
+
+    if ( req.body.filter?.type == 'flag' ) {
+      query.push( {
+        $match: {
+          $and: [
+            {
+              taskDetails: { $elemMatch: { breach: true } },
+            },
+          ],
+        },
+      } );
+    }
+
+    let extraCondition = [];
+
+    if ( req.body.searchValue ) {
+      extraCondition.push( {
+        $match: {
+          storeName: { $regex: req.body.searchValue, $options: 'i' },
+        },
+      } );
+    }
+
+    extraCondition.push(
+        { $skip: skip },
+        { $limit: limit },
+    );
+
+    if ( req.body.sortColumnName && req.body.sortBy ) {
+      query.push(
+          { $sort: { [req.body.sortColumnName]: req.body.sortBy } },
+      );
+    }
+
+
+    query.push( {
+      $facet: {
+        totalStore: [
+          {
+            $group: {
+              _id: '',
+              storeList: { $addToSet: '$storeId' },
+            },
+          },
+          {
+            $project: {
+              _id: 0,
+              count: { $size: '$storeList' },
+            },
+          },
+        ],
+        rollOutStore: [
+          {
+            $match: {
+              $expr: { $gt: [ { $size: '$taskDetails' }, 0 ] },
+            },
+          },
+          { $count: 'count' },
+        ],
+        merchPending: [
+          {
+            $match: {
+              $and: [
+                {
+                  taskDetails: {
+                    $elemMatch: { type: 'merchRollout', status: 'submit' },
+                  },
+                },
+                {
+                  compliance: {
+                    $elemMatch: { feedbackStatus: 'merchPending' },
+                  },
+                },
+              ],
+            },
+          },
+          { $count: 'count' },
+        ],
+        vmPending: [
+          {
+            $match: {
+              $and: [
+                {
+                  taskDetails: {
+                    $elemMatch: { type: 'vmRollout', status: 'submit' },
+                  },
+                },
+                {
+                  compliance: {
+                    $elemMatch: { feedbackStatus: 'vmPending' },
+                  },
+                },
+              ],
+            },
+          },
+          { $count: 'count' },
+        ],
+        flag: [
+          {
+            $match: {
+              taskDetails: {
+                $elemMatch: { breach: true },
+              },
+            },
+          },
+          { $count: 'count' },
+        ],
+        doubleFloorStore: [
+          {
+            $group: {
+              _id: '$storeId',
+              count: { $sum: 1 },
+            },
+          },
+          {
+            $match: {
+              count: { $gt: 1 },
+            },
+          },
+          {
+            $group: {
+              _id: '',
+              doubleFloorList: { $addToSet: '$_id' },
+            },
+          },
+          {
+            $project: {
+              doubleFloorList: 1,
+            },
+          },
+        ],
+        data: extraCondition,
+        count: [
+          ...extraCondition,
+          { $count: 'total' },
+        ],
+      },
+    } );
+
+
+    let rolloutDetails = await storeBuilderService.aggregate( query );
+    let result = {
+      cardData: {
+        totalStore: rolloutDetails?.[0]?.totalStore?.[0]?.count || 0,
+        rolloutStore: rolloutDetails?.[0]?.rollOutStore?.[0]?.count || 0,
+        merchPendingStore: rolloutDetails?.[0]?.merchPending?.[0]?.count || 0,
+        vmPendingStore: rolloutDetails?.[0]?.vmPending?.[0]?.count || 0,
+        flagStore: rolloutDetails?.[0]?.flag?.[0]?.count || 0,
+        flagStore: rolloutDetails?.[0]?.flag?.[0]?.count || 0,
+        doubleFloorStore: rolloutDetails?.[0]?.doubleFloorStore?.[0]?.doubleFloorList || [],
+      },
+      tableData: {
+        count: rolloutDetails?.[0]?.count?.[0]?.total || 0,
+        data: rolloutDetails?.[0]?.data || 0,
+      },
+    };
+    return res.sendSuccess( result );
+  } catch ( e ) {
+    logger.error( { functionName: 'getRolloutDetails', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+
+export async function getRolloutTaskDetails( 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' ) ) },
+          floorId: new mongoose.Types.ObjectId( req.query.floorId ),
+          planoType: { $in: [ 'merchRollout', 'vmRollout' ] },
+        },
+      },
+      {
+        $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' ] },
+                    { $in: [ '$type', [ 'merchRollout', 'vmRollout' ] ] },
+                  ],
+                },
+              },
+            },
+            { $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' ] },
+                        ],
+                      },
+                    },
+                  },
+                },
+                hasDisagreeIssues: {
+                  $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', 'disagree' ] },
+                        ],
+                      },
+                    },
+                  },
+                },
+              },
+            },
+            {
+              $group: {
+                _id: '$floorId',
+                merchCount: {
+                  $sum: { $cond: [ { $eq: [ '$type', 'merchRollout' ] }, 1, 0 ] },
+                },
+                vmCount: {
+                  $sum: { $cond: [ { $eq: [ '$type', 'vmRollout' ] }, 1, 0 ] },
+                },
+                merchPending: {
+                  $sum: {
+                    $cond: [
+                      { $and: [ { $eq: [ '$type', 'merchRollout' ] }, '$hasPendingIssues' ] },
+                      1,
+                      0,
+                    ],
+                  },
+                },
+                vmPending: {
+                  $sum: {
+                    $cond: [
+                      { $and: [ { $eq: [ '$type', 'vmRollout' ] }, '$hasPendingIssues' ] },
+                      1,
+                      0,
+                    ],
+                  },
+                },
+                merchDisagree: {
+                  $sum: {
+                    $cond: [
+                      { $and: [ { $eq: [ '$type', 'merchRollout' ] }, '$hasDisagreeIssues' ] },
+                      1,
+                      0,
+                    ],
+                  },
+                },
+                vmDisagree: {
+                  $sum: {
+                    $cond: [
+                      { $and: [ { $eq: [ '$type', 'vmRollout' ] }, '$hasDisagreeIssues' ] },
+                      1,
+                      0,
+                    ],
+                  },
+                },
+              },
+            },
+            {
+              $project: {
+                _id: 0,
+                merchStatus: {
+                  $cond: {
+                    if: {
+                      $and: [
+                        { $gt: [ '$merchCount', 0 ] },
+                        { $eq: [ '$merchPending', 0 ] },
+                        { $eq: [ '$merchDisagree', 0 ] },
+                      ],
+                    },
+                    then: 'complete',
+                    else: {
+                      $cond: {
+                        if: {
+                          $and: [
+                            {
+                              $gt: [ '$merchCount', 0 ],
+                            },
+                            {
+                              $gt: [
+                                '$merchPending',
+                                0,
+                              ],
+                            },
+                          ],
+                        },
+                        then: 'pending',
+                        else: {
+                          $cond: {
+                            if: {
+                              $and: [
+                                {
+                                  $gt: [ '$merchCount', 0 ],
+                                },
+                                {
+                                  $gt: [
+                                    '$merchDisagree',
+                                    0,
+                                  ],
+                                },
+                              ],
+                            },
+                            then: 'disagree',
+                            else: '',
+                          },
+                        },
+                      },
+                    },
+                  },
+                },
+                vmStatus: {
+                  $cond: {
+                    if: {
+                      $and: [
+                        { $gt: [ '$vmCount', 0 ] },
+                        { $eq: [ '$vmPending', 0 ] },
+                        { $eq: [ '$vmDisagree', 0 ] },
+                      ],
+                    },
+                    then: 'complete',
+                    else: {
+                      $cond: {
+                        if: {
+                          $and: [
+                            { $gt: [ '$vmCount', 0 ] },
+                            { $gt: [ '$vmPending', 0 ] },
+                          ],
+                        },
+                        then: 'pending',
+                        else: {
+                          $cond: {
+                            if: {
+                              $and: [
+                                {
+                                  $gt: [ '$vmCount', 0 ],
+                                },
+                                {
+                                  $gt: [
+                                    '$vmDisagree',
+                                    0,
+                                  ],
+                                },
+                              ],
+                            },
+                            then: 'disagree',
+                            else: '',
+                          },
+                        },
+                      },
+                    },
+                  },
+                },
+              },
+            },
+          ],
+          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', 'merchRollout' ] },
+                        then: { $arrayElemAt: [ '$taskDetails.merchStatus', 0 ] },
+                      },
+                      {
+                        case: { $eq: [ '$$task.type', 'vmRollout' ] },
+                        then: { $arrayElemAt: [ '$taskDetails.vmStatus', 0 ] },
+                      },
+                    ],
+                    default: '',
+                  },
+                },
+              },
+            },
+          },
+        },
+      },
+
+    ];
+
+    let taskInfo = await planotaskService.aggregate( query );
+    const [ merchCount, vmCount ] = await Promise.all( [
+      await layoutService.count( { _id: req.query.floorId, isMerchEdited: true } ),
+      await layoutService.count( { _id: req.query.floorId, isVmEdited: true } ),
+    ] );
+    return res.sendSuccess( { taskDetails: taskInfo, merchCount, vmCount } );
+  } catch ( e ) {
+    logger.error( { functionName: 'getTaskDetails', error: e } );
+    return res.sendError( e, 500 );
+  }
+}

package/src/controllers/task.controller.js

@@ -1,4 +1,3 @@
-import * as taskService from '../service/task.service.js';
 import * as processedService from '../service/processedTaskservice.js';
 import * as storeService from '../service/store.service.js';
 import * as processedChecklistService from '../service/processedchecklist.service.js';
@@ -11,7 +10,7 @@ import * as checklistService from '../service/checklist.service.js';
 import timeZone from 'dayjs/plugin/timezone.js';
 import * as planoProductService from '../service/planoProduct.service.js';
 import mongoose from 'mongoose';
-// const ObjectId = mongoose.Types.ObjectId;
+const ObjectId = mongoose.Types.ObjectId;
 import * as floorService from '../service/storeBuilder.service.js';
 import * as planoStaticService from '../service/planoStaticData.service.js';
 import * as assignService from '../service/assignService.service.js';
@@ -128,10 +127,13 @@ export async function createTask( req, res ) {
       await processedService.updateOne( { _id: req.body.taskId }, { checklistStatus: 'open', redoStatus: true, date_iso: new Date( dayjs().format( 'YYYY-MM-DD' ) ), scheduleStartTime_iso: dayjs.utc( '12:00 AM', 'hh:mm A' ).format(), scheduleEndTime_iso: dayjs.utc( scheduleEndTime, 'hh:mm A' ).format(), date_string: dayjs().format( 'YYYY-MM-DD' ), date_iso: new Date( dayjs().format( 'YYYY-MM-DD' ) ) } );
       return res.sendSuccess( 'Task redo triggered successfully' );
     } else {
-      let taskDetails = await taskService.find( { isPlano: true, client_id: req.body.clientId, ...( req.body.checkListName )? { checkListName: req.body.checkListName } : {} } );
-      if ( !taskDetails.length ) {
-        return res.sendError( 'No data found', 204 );
+      if ( !req.body?.checkListName ) {
+        return res.sendError( 'ChecklistName is required', 400 );
       }
+      // let taskDetails = await taskService.find( { isPlano: true, ...( req.body.checkListName )? { checkListName: req.body.checkListName } : {} } );
+      // if ( !taskDetails.length ) {
+      //   return res.sendError( 'No data found', 204 );
+      // }
       let userDetails;
       let storeList;
       let endDate;
@@ -200,104 +202,113 @@ export async function createTask( req, res ) {
           await createUser( userData );
         }
       }
-      await Promise.all( taskDetails.map( async ( task ) => {
-        let splitName = task?.checkListName.split( ' ' );
-        splitName.pop();
-        let data = {
-          client_id: req.body.clientId,
-          date_iso: new Date( dayjs().format( 'YYYY-MM-DD' ) ),
-          date_string: dayjs().format( 'YYYY-MM-DD' ),
-          sourceCheckList_id: task._id,
-          checkListName: task.checkListName,
-          checkListId: task._id,
-          scheduleStartTime: '12:00 AM',
-          scheduleEndTime: scheduleEndTime,
-          scheduleStartTime_iso: dayjs.utc( '12:00 AM', 'hh:mm A' ).format(),
-          scheduleEndTime_iso: dayjs.utc( endDate, 'YYYY-MM-DD hh:mm A' ).format(),
-          allowedOverTime: false,
-          allowedStoreLocation: req.body?.geoFencing || false,
-          createdBy: req?.user?._id || task?.createdBy,
-          createdByName: req?.user?.userName || task?.createdByName,
-          questionAnswers: [],
-          isdeleted: false,
-          questionCount: 0,
-          storeCount: 0,
-          locationCount: 0,
-          checkListType: 'task',
-          country: '',
-          store_id: '',
-          storeName: '',
-          userId: '',
-          userName: '',
-          userEmail: '',
-          checklistStatus: 'open',
-          timeFlagStatus: true,
-          timeFlag: 0,
-          questionFlag: 0,
-          mobileDetectionFlag: 0,
-          storeOpenCloseFlag: 0,
-          reinitiateStatus: false,
-          markasread: false,
-          uniformDetectionFlag: 0,
-          scheduleRepeatedType: 'daily',
-          approvalStatus: false,
-          approvalEnable: false,
-          redoStatus: false,
-          isPlano: true,
-          planoType: splitName.length == 1 ? splitName[0].toLowerCase() : splitName[0].toLowerCase() + splitName[2],
-        };
-        let query = [
-          {
-            $addFields: {
-              store: { $toLower: '$storeName' },
-            },
+      // await Promise.all( taskDetails.map( async ( task ) => {
+      let taskId = new ObjectId();
+      let [ first ] = req.body?.checkListName.split( ' ' );
+      first = first.toLowerCase();
+      if ( req.body?.checkListName.toLowerCase().includes( 'rollout' ) ) {
+        if ( req.body.checkListName.toLowerCase().includes( 'visual' ) ) {
+          first = 'vmRollout';
+        } else {
+          first = 'merchRollout';
+        }
+      }
+      let data = {
+        client_id: req.body.clientId,
+        date_iso: new Date( dayjs().format( 'YYYY-MM-DD' ) ),
+        date_string: dayjs().format( 'YYYY-MM-DD' ),
+        sourceCheckList_id: taskId,
+        checkListName: req.body.checkListName,
+        checkListId: taskId,
+        scheduleStartTime: '12:00 AM',
+        scheduleEndTime: scheduleEndTime,
+        scheduleStartTime_iso: dayjs.utc( '12:00 AM', 'hh:mm A' ).format(),
+        scheduleEndTime_iso: dayjs.utc( endDate, 'YYYY-MM-DD hh:mm A' ).format(),
+        allowedOverTime: false,
+        allowedStoreLocation: req.body?.geoFencing || false,
+        createdBy: req?.user?._id,
+        createdByName: req?.user?.userName,
+        questionAnswers: [],
+        isdeleted: false,
+        questionCount: 0,
+        storeCount: 0,
+        locationCount: 0,
+        checkListType: 'task',
+        country: '',
+        store_id: '',
+        storeName: '',
+        userId: '',
+        userName: '',
+        userEmail: '',
+        checklistStatus: 'open',
+        timeFlagStatus: true,
+        timeFlag: 0,
+        questionFlag: 0,
+        mobileDetectionFlag: 0,
+        storeOpenCloseFlag: 0,
+        reinitiateStatus: false,
+        markasread: false,
+        uniformDetectionFlag: 0,
+        scheduleRepeatedType: 'daily',
+        approvalStatus: false,
+        approvalEnable: false,
+        redoStatus: false,
+        isPlano: true,
+        planoType: first,
+      };
+      let query = [
+        {
+          $addFields: {
+            store: { $toLower: '$storeName' },
           },
-          {
-            $match: {
-              clientId: req.body.clientId,
-              store: { $in: storeList },
-            },
+        },
+        {
+          $match: {
+            clientId: req.body.clientId,
+            store: { $in: storeList },
           },
-        ];
+        },
+      ];
 
-        let storeDetails = await storeService.aggregate( query );
-        await Promise.all( storeDetails.map( async ( store ) => {
-          let getUserEmail = req.body.stores.find( ( ele ) => ele.store.toLowerCase() == store.storeName.toLowerCase() );
-          let planoDetails = await planoService.findOne( { storeName: store.storeName } );
-          if ( planoDetails ) {
-            const [ floorDetails, floorCount ] = await Promise.all( [
-              await floorService.find( { planoId: planoDetails._id, ...( req.body?.floorId ) ? { _id: req.body?.floorId }:{} }, { _id: 1, floorName: 1 } ),
-              await floorService.count( { planoId: planoDetails._id } ),
-            ] );
-            for ( let i=0; i<floorDetails.length; i++ ) {
-              if ( getUserEmail ) {
-                let query = [
-                  {
-                    $addFields: {
-                      emailLower: { $toLower: '$email' },
-                    },
+      let storeDetails = await storeService.aggregate( query );
+      await Promise.all( storeDetails.map( async ( store ) => {
+        let getUserEmail = req.body.stores.find( ( ele ) => ele.store.toLowerCase() == store.storeName.toLowerCase() );
+        let planoDetails = await planoService.findOne( { storeName: store.storeName } );
+        if ( planoDetails ) {
+          const [ floorDetails, floorCount ] = await Promise.all( [
+            await floorService.find( { planoId: planoDetails._id, ...( req.body?.floorId ) ? { _id: req.body?.floorId }:{} }, { _id: 1, floorName: 1 } ),
+            await floorService.count( { planoId: planoDetails._id } ),
+          ] );
+          for ( let i=0; i<floorDetails.length; i++ ) {
+            if ( getUserEmail ) {
+              let query = [
+                {
+                  $addFields: {
+                    emailLower: { $toLower: '$email' },
                   },
-                  {
-                    $match: {
-                      clientId: req.body.clientId,
-                      emailLower: getUserEmail.email.toLowerCase(),
-                    },
+                },
+                {
+                  $match: {
+                    clientId: req.body.clientId,
+                    emailLower: getUserEmail.email.toLowerCase(),
                   },
-                ];
-                userDetails = await userService.aggregate( query );
-                userDetails = userDetails[0];
-              }
-              let taskData = { ...data };
-              if ( floorCount > 1 ) {
-                taskData.checkListName = taskData.checkListName +' - '+ floorDetails[i].floorName;
-              }
-              taskData.floorId = floorDetails[i]._id;
-              taskData.store_id = store.storeId;
-              taskData.storeName = store.storeName;
-              taskData.userId = userDetails._id;
-              taskData.userName = userDetails.userName;
-              taskData.userEmail = userDetails.email;
-              taskData.planoId = planoDetails?._id;
+                },
+              ];
+              userDetails = await userService.aggregate( query );
+              userDetails = userDetails[0];
+            }
+            let taskData = { ...data };
+            if ( floorCount > 1 ) {
+              taskData.checkListName = taskData.checkListName +' - '+ floorDetails[i].floorName;
+            }
+            taskData.floorId = floorDetails[i]._id;
+            taskData.store_id = store.storeId;
+            taskData.storeName = store.storeName;
+            taskData.userId = userDetails._id;
+            taskData.userName = userDetails.userName;
+            taskData.userEmail = userDetails.email;
+            taskData.planoId = planoDetails?._id;
+            if ( !req.body?.checkListName.toLowerCase().includes( 'rollout' ) ) {
               let planoProgress = req.body.checkListName == 'Fixture Verification' ? 50 : req.body.checkListName == 'VM Verification' ? 75 : 25;
               if ( req.body?.checkListName && req.body.checkListName == 'Layout Verification' ) {
                 await planoTaskService.deleteMany( { planoId: planoDetails?._id, floorId: taskData?.floorId } );
@@ -308,19 +319,17 @@ export async function createTask( req, res ) {
                 await planoTaskService.deleteMany( { planoId: planoDetails?._id, floorId: taskData?.floorId, type: type } );
               }
               await floorService.updateOne( { _id: taskData?.floorId }, { planoProgress } );
-              for ( let j=0; j<req.body.days; j++ ) {
-                let currDate = dayjs().add( j, 'day' );
-                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 );
-              }
             }
+            // for ( let j=0; j<req.body.days; j++ ) {
+            let currDate = dayjs();
+            let 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, planoType: taskData.planoType, ...( taskData?.floorId ) ? { floorId: taskData.floorId }:{} }, insertData );
+            // }
           }
-        } ) );
+        }
       } ) );
+      // } ) );
       return res.sendSuccess( 'Task created successfully' );
     }
   } catch ( e ) {
@@ -528,13 +537,13 @@ export async function updateStatus( req, res ) {
       email: req.user.email,
       comment: req.body.comments,
     };
-    if ( req.body.status == 'inprogress' ) {
-      await processedService.updateOne( { planoId: taskDetails.planoId, userEmail: taskDetails.userEmail, store_id: taskDetails.store_id, ...( taskDetails?.floorId ) ? { floorId: taskDetails.floorId } : {}, date_iso: { $gt: new Date( dayjs().format( 'YYYY-MM-DD' ) ) } }, { checklistStatus: 'inprogress', startTime_string: timeString } );
-    }
+    // if ( req.body.status == 'inprogress' ) {
+    //   await processedService.updateOne( { planoId: taskDetails.planoId, userEmail: taskDetails.userEmail, store_id: taskDetails.store_id, ...( taskDetails?.floorId ) ? { floorId: taskDetails.floorId } : {}, date_iso: { $gt: new Date( dayjs().format( 'YYYY-MM-DD' ) ) } }, { checklistStatus: 'inprogress', startTime_string: timeString } );
+    // }
     await processedService.updateOne( { _id: req.body.taskId }, { checklistStatus: req.body.status, ...( req.body.status == 'inprogress' ) ? { startTime_string: timeString } : { submitTime_string: timeString }, comments: { $push: comments } } );
-    if ( req.body.status == 'submit' ) {
-      await processedService.deleteMany( { planoId: taskDetails.planoId, userEmail: taskDetails.userEmail, store_id: taskDetails.store_id, ...( taskDetails?.floorId ) ? { floorId: taskDetails.floorId } : {}, date_iso: { $gt: new Date( dayjs().format( 'YYYY-MM-DD' ) ) } } );
-    }
+    // if ( req.body.status == 'submit' ) {
+    //   await processedService.deleteMany( { planoId: taskDetails.planoId, userEmail: taskDetails.userEmail, store_id: taskDetails.store_id, ...( taskDetails?.floorId ) ? { floorId: taskDetails.floorId } : {}, date_iso: { $gt: new Date( dayjs().format( 'YYYY-MM-DD' ) ) } } );
+    // }
     let vmTask = await planoTaskService.find(
         {
           planoId: new mongoose.Types.ObjectId( taskDetails.planoId ),
@@ -1019,3 +1028,12 @@ export async function redoTask( req, res ) {
     return res.sendError( e, 500 );
   }
 }
+
+export async function revokeTask( req, res ) {
+  try {
+    await processedService.deleteMany( { checklistName: req.body.checkListName, date_string: dayjs().format( 'YYYY-MM-DD' ), planoId: req.body.planoId, floorId: req.body.floorId } );
+  } catch ( e ) {
+    logger.error( { functionName: 'revokeTask', error: e } );
+    return res.sendError( e, 500 );
+  }
+}

package/src/dtos/validation.dtos.js

@@ -110,6 +110,7 @@ export const updateFixtureSchema = joi.object( {
   status: joi.string().required(),
   fixtureCapacity: joi.number().required(),
   isBodyEnabled: joi.boolean().required(),
+  clientId: joi.string().required(),
 } );
 
 export const fixtureIdSchema = joi.object( {

package/src/routes/managePlano.routes.js

@@ -20,4 +20,5 @@ managePlanoRouter
     .post( '/getGlobalComment', isAllowedSessionHandler, managePlanoController.getGlobalComment )
     .post( '/createRevision', managePlanoController.createPlanoRevision )
     .post( '/getRevisions', managePlanoController.getAllPlanoRevisions )
-    .post( '/getRevisionData', managePlanoController.getPlanoRevisionById );
+    .post( '/getRevisionData', managePlanoController.getPlanoRevisionById )
+    .post( '/getRolloutFeedback', managePlanoController.getRolloutFeedback );

package/src/routes/storeBuilder.routes.js

@@ -51,4 +51,6 @@ storeBuilderRouter
 storeBuilderRouter
     .post( '/planoList', isAllowedSessionHandler, storeBuilderController.planoList )
     .get( '/taskDetails', isAllowedSessionHandler, storeBuilderController.getTaskDetails )
-    .get( '/getPlanoUser', isAllowedSessionHandler, storeBuilderController.getPlanoUser );
+    .get( '/getPlanoUser', isAllowedSessionHandler, storeBuilderController.getPlanoUser )
+    .post( '/planoRolloutList', isAllowedSessionHandler, storeBuilderController.getRolloutDetails )
+    .get( '/getRolloutTaskDetails', isAllowedSessionHandler, storeBuilderController.getRolloutTaskDetails );