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

package/src/controllers/storeBuilder.controller.js

@@ -1451,8 +1451,6 @@ export async function updateMissing( req, res ) {
 
     if ( !fixtureShelves.length ) return res.sendError( 'No shelves found for the fixture', 204 );
 
-    console.log('called')
-
     await Promise.all(
         fixtureShelves.map( async ( shelf ) => {
           const productMappings = await planoMappingService.find( { shelfId: shelf._id } );
@@ -1461,18 +1459,18 @@ export async function updateMissing( req, res ) {
             return { ...shelf.toObject(), products: [] };
           }
 
-          // const productIds = productMappings.map( ( mapping ) => mapping.productId );
-          // const products = await planoProductService.find( { _id: { $in: productIds } } );
-          // const productMap = new Map( products.map( ( product ) => [ product._id.toString(), product.toObject() ] ) );
+          const productIds = productMappings.map( ( mapping ) => mapping.productId );
+          const products = await planoProductService.find( { _id: { $in: productIds } } );
+          const productMap = new Map( products.map( ( product ) => [ product._id.toString(), product.toObject() ] ) );
 
           const currentDate = new Date( dayjs().format( 'YYYY-MM-DD' ) );
 
           await Promise.all(
               productMappings.map( async ( mapping ) => {
-                // const productData = productMap.get( mapping?.productId?.toString() );
-                // if ( !productData ) {
-                //   return { ...mapping.toObject(), status: '' };
-                // }
+                const productData = productMap.get( mapping.productId.toString() );
+                if ( !productData ) {
+                  return { ...mapping.toObject(), status: '' };
+                }
 
                 const mappingCompliance = await planoComplianceService.findOne( {
                   planoMappingId: mapping._id,
@@ -1486,7 +1484,7 @@ export async function updateMissing( req, res ) {
 
                 return {
                   ...mapping.toObject(),
-                  // ...productData,
+                  ...productData,
                 };
               } ),
           );
@@ -4509,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 );
+  }
+}