tango-app-api-store-builder 1.0.0-beta-186 → 1.0.0-beta-188

package/package.json

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

package/src/controllers/fixtureTemplate.controller.js

@@ -8,6 +8,7 @@ import * as processedTaskService from '../service/processedTaskservice.js';
 import * as fixtureShelfService from '../service/fixtureShelf.service.js';
 import * as vmService from '../service/planoVm.service.js';
 import * as templateLogService from '../service/templateLog.service.js';
+import * as storeLayoutService from '../service/storeBuilder.service.js';
 import { createTask } from './task.controller.js';
 import mongoose from 'mongoose';
 import dayjs from 'dayjs';
@@ -79,6 +80,8 @@ export async function updateTemplate( req, res ) {
     let checkstoreMapped = await storeFixtureService.findOne( { fixtureConfigId: req.params.templateId } );
     if ( checkstoreMapped ) {
       inputData.isEdited = true;
+    } else {
+      inputData.isEdited = false;
     }
     await fixtureConfigService.updateOne( { _id: req.params.templateId }, inputData );
     return res.sendSuccess( 'Fixture template details updated successfully' );
@@ -689,14 +692,40 @@ export async function TemplateStoresList( req, res ) {
     },
     {
       $group: {
-        _id: '$storeId',
+        _id: { store: '$storeId', floor: '$floorId' },
         storeName: { $first: '$storeName' },
         planoId: { $first: '$planoId' },
         storeId: { $first: '$storeId' },
         floorId: { $first: '$floorId' },
       },
     },
-
+    {
+      $lookup: {
+        from: 'storelayouts',
+        let: { floor: '$floorId' },
+        pipeline: [
+          {
+            $match: {
+              $expr: {
+                $eq: [ '$_id', '$$floor' ],
+              },
+            },
+          },
+          {
+            $project: {
+              floorName: 1,
+            },
+          },
+        ],
+        as: 'floorDetails',
+      },
+    },
+    {
+      $unwind: {
+        path: '$floorDetails',
+        preserveNullAndEmptyArrays: true,
+      },
+    },
 
     );
     if ( inputData.showlookup ) {
@@ -725,6 +754,8 @@ export async function TemplateStoresList( req, res ) {
               floorId: 1,
               spocName: { $ifNull: [ '$storeData.spocDetails.name', '' ] },
               spocEmail: { $ifNull: [ '$storeData.spocDetails.email', '' ] },
+              floorDetails: 1,
+              _id: '$_id.store',
             },
           },
       );
@@ -785,8 +816,34 @@ export async function TemplateStoresList( req, res ) {
       );
     }
 
-
-    let response = await storeFixtureService.aggregate( query );
+    let floorQuery = [
+      {
+        $match: {
+          clientId: req.body.clientId,
+        },
+      },
+      {
+        $group: {
+          _id: '$storeId',
+          count: { $sum: 1 },
+        },
+      },
+      {
+        $match: {
+          count: { $gt: 1 },
+        },
+      },
+      {
+        $project: {
+          _id: 0,
+          store: '$_id',
+        },
+      },
+    ];
+    const [ response, floorDetails ] = await Promise.all( [
+      storeFixtureService.aggregate( query ),
+      storeLayoutService.aggregate( floorQuery ),
+    ] );
 
     if ( !req.body.export && !response.length ) {
       return res.sendError( 'No data found', 204 );
@@ -794,6 +851,7 @@ export async function TemplateStoresList( req, res ) {
     let result = {
       count: count.length || 0,
       data: response || [],
+      doubleStore: floorDetails?.map( ( ele ) => ele.store ) ?? [],
     };
     if ( !req.body.export ) {
       return res.sendSuccess( result );
@@ -1399,18 +1457,46 @@ export async function getTemplateStoreList( req, res ) {
       },
       {
         $group: {
-          _id: '$storeName',
+          _id: { store: '$storeName', floor: '$floorId' },
           storeId: { $first: '$storeId' },
           updatedAt: { $first: '$updatedAt' },
-          planoId: { $push: '$planoId' },
+          planoId: { $first: '$planoId' },
         },
       },
       {
         $project: {
-          storeName: '$_id',
+          storeName: '$_id.store',
           storeId: 1,
           updatedAt: 1,
           planoId: 1,
+          floorId: '$_id.floor',
+        },
+      },
+      {
+        $lookup: {
+          from: 'storelayouts',
+          let: { floor: '$floorId' },
+          pipeline: [
+            {
+              $match: {
+                $expr: {
+                  $eq: [ '$_id', '$$floor' ],
+                },
+              },
+            },
+            {
+              $project: {
+                floorName: 1,
+              },
+            },
+          ],
+          as: 'floorDetails',
+        },
+      },
+      {
+        $unwind: {
+          path: '$floorDetails',
+          preserveNullAndEmptyArrays: true,
         },
       },
       {
@@ -1471,7 +1557,8 @@ export async function getTemplateStoreList( req, res ) {
           planoId: 1,
           storeDetails: { $ifNull: [ { $arrayElemAt: [ '$storeDetails.storeProfile', 0 ] }, {} ] },
           clusterDetails: { $ifNull: [ { $arrayElemAt: [ '$clusterDetails.clusterName', 0 ] }, {} ] },
-          clusterDetails: { $ifNull: [ { $arrayElemAt: [ '$clusterDetails.clusterName', 0 ] }, {} ] },
+          floorId: 1,
+          floorName: { $ifNull: [ '$floorDetails.floorName', '' ] },
         },
       },
     ];
@@ -1499,14 +1586,36 @@ export async function getTemplateStoreList( req, res ) {
           },
         },
     );
-
-    let getStoreDetails = await storeFixtureService.aggregate( query );
+    let floorQuery = [
+      {
+        $group: {
+          _id: '$storeId',
+          count: { $sum: 1 },
+        },
+      },
+      {
+        $match: {
+          count: { $gt: 1 },
+        },
+      },
+      {
+        $project: {
+          _id: 0,
+          store: '$_id',
+        },
+      },
+    ];
+    const [ getStoreDetails, floorDetails ] = await Promise.all( [
+      storeFixtureService.aggregate( query ),
+      storeLayoutService.aggregate( floorQuery ),
+    ] );
     if ( !getStoreDetails[0].data.length ) {
       return res.sendError( 'No data found', 204 );
     }
     let result = {
       count: getStoreDetails?.[0]?.count?.[0]?.total || 0,
       data: getStoreDetails?.[0]?.data || [],
+      doubleFloorStores: floorDetails?.map( ( ele ) => ele.store ) || [],
     };
     let status = templateDetails.isEdited ? 'Yet to publish' : 'Published';
     result.data.forEach( ( ele ) => {

package/src/controllers/managePlano.controller.js

@@ -1052,10 +1052,18 @@ export async function getRolloutFeedback( req, res ) {
 
           resultMap[type] = data;
 
+          let taskId = [];
+          if ( req.body.taskId ) {
+            taskId.push( new mongoose.Types.ObjectId( req.body.taskId ) );
+          }
+          if ( req.body.refTaskId ) {
+            taskId.push( new mongoose.Types.ObjectId( req.body.refTaskId ) );
+          }
+
           const comments = await planoGlobalCommentService.find( {
             planoId: new mongoose.Types.ObjectId( req.body.planoId ),
             floorId: new mongoose.Types.ObjectId( req.body.floorId ),
-            taskId: { $in: [ new mongoose.Types.ObjectId( req.body.taskId ), new mongoose.Types.ObjectId( req.body.req.body.refTaskId ) ] },
+            ...( taskId.length && { taskId: { $in: taskId } } ),
             taskType: type,
           } );
           commentMap[type] = comments;
@@ -1147,10 +1155,12 @@ export async function getRolloutFeedbackv2( req, res ) {
     }
     response.vmRolloutData = await Promise.all( response.vmRolloutData.map( async ( ele ) => {
       ele.storeFixtureList = await Promise.all( ele.storeFixtureList.map( async ( fixt ) => {
-        fixt.FixtureData.vmConfig = await Promise.all( fixt.FixtureData.vmConfig.map( async ( config ) => {
-          let vmDetails = await planoVmService.findOne( { _id: config.vmId }, { vmType: 1, vmName: 1 } );
-          return { ...config, vmType: vmDetails.vmType, vmName: vmDetails.vmName };
-        } ) );
+        if ( fixt?.FixtureData?.vmConfig?.length ) {
+          fixt.FixtureData.vmConfig = await Promise.all( fixt?.FixtureData?.vmConfig?.map( async ( config ) => {
+            let vmDetails = await planoVmService.findOne( { _id: config.vmId }, { vmType: 1, vmName: 1 } );
+            return { ...config, vmType: vmDetails.vmType, vmName: vmDetails.vmName };
+          } ) );
+        }
         return fixt;
       } ) );
       return ele;

package/src/controllers/storeBuilder.controller.js

@@ -2657,7 +2657,7 @@ export async function storeFixturesv2( req, res ) {
     const storeLayout = await Promise.all(
         planograms.map( async ( planogram ) => {
           const floors = await storeBuilderService.find(
-              { planoId: planogram._id },
+              { planoId: planogram._id, ...( req.body?.floorId && { _id: req.body.floorId } ) },
               { floorName: 1, layoutPolygon: 1, planoId: 1, isEdited: 1, planoProgress: 1 },
           );
 
@@ -5011,33 +5011,50 @@ export async function getRolloutDetails( req, res ) {
       const orCondition = [];
 
       if ( req.body.filter.status.includes( 'yetToAssign' ) ) {
-        orCondition.push( {
-          $expr: {
-            $lt: [ { $size: '$taskDetails' }, 2 ],
-          },
-        },
-        {
-          $and: [
-            { taskDetails: { $elemMatch: { type: 'merchRollout', status: 'submit' } } },
-            { $or: [
-              { 'taskFeedback.fixtureStatus': 'disagree' },
-              { $and: [ { merchEditedCount: { $ne: 0 } }, { $expr: {
-                $eq: [ { $size: { $objectToArray: '$taskFeedback' } }, 0 ],
-              } } ] },
-            ] },
-          ],
-        },
-        {
-          $and: [
-            { taskDetails: { $elemMatch: { type: 'vmRollout', status: 'submit' } } },
-            { $or: [
-              { 'taskFeedback.vmStatus': 'disagree' },
-              { $and: [ { vmEditedCount: { $ne: 0 } }, { $expr: {
-                $eq: [ { $size: { $objectToArray: '$taskFeedback' } }, 0 ],
-              } } ] },
-            ] },
-          ],
-        },
+        orCondition.push(
+            {
+              $or: [
+                {
+                  $and: [
+                    { taskDetails: { $elemMatch: { type: 'merchRollout', status: 'submit' } } },
+                    { merchEditedCount: { $ne: 0 } },
+                  ],
+                },
+                {
+                  $and: [
+                    { taskDetails: { $elemMatch: { type: 'vmRollout', status: 'submit' } } },
+                    { vmEditedCount: { $ne: 0 } },
+                  ],
+                },
+                {
+                  $expr: {
+                    $lt: [ { $size: '$taskDetails' }, 2 ],
+                  },
+                },
+              ],
+            },
+            {
+              $and: [
+                { taskDetails: { $elemMatch: { type: 'merchRollout', status: 'submit' } } },
+                { $or: [
+                  { 'taskFeedback.fixtureStatus': 'disagree' },
+                  { $and: [ { merchEditedCount: { $ne: 0 } }, { $expr: {
+                    $eq: [ { $size: { $objectToArray: '$taskFeedback' } }, 0 ],
+                  } } ] },
+                ] },
+              ],
+            },
+            {
+              $and: [
+                { taskDetails: { $elemMatch: { type: 'vmRollout', status: 'submit' } } },
+                { $or: [
+                  { 'taskFeedback.vmStatus': 'disagree' },
+                  { $and: [ { vmEditedCount: { $ne: 0 } }, { $expr: {
+                    $eq: [ { $size: { $objectToArray: '$taskFeedback' } }, 0 ],
+                  } } ] },
+                ] },
+              ],
+            },
         );
       }
 

package/src/dtos/validation.dtos.js

@@ -45,7 +45,9 @@ export const updateFloor = {
 };
 
 export const storeListSchema = joi.object( {
-  id: joi.array().items( joi.any() ).min( 1 ).required(),
+  id: joi.array().items( joi.any() ).min( 1 ).optional(),
+  planoId: joi.string().optional(),
+  floorId: joi.string().optional(),
   treeView: joi.boolean().optional(),
 } );