tango-app-api-store-builder 1.0.16 → 1.0.17

package/src/controllers/storeBuilder.controller.js

@@ -1,7 +1,7 @@
 import * as storeBuilderService from '../service/storeBuilder.service.js';
 import * as storeService from '../service/store.service.js';
 import * as planoService from '../service/planogram.service.js';
-import { logger, fileUpload, signedUrl, sendMessageToQueue, getOpenSearchData } from 'tango-app-api-middleware';
+import { logger, fileUpload, signedUrl, sendMessageToQueue, getOpenSearchData, download } from 'tango-app-api-middleware';
 import dayjs from 'dayjs';
 import customParseFormat from 'dayjs/plugin/customParseFormat.js';
 import utc from 'dayjs/plugin/utc.js';
@@ -26,6 +26,7 @@ import * as planoMappingDuplicateService from '../service/planoMappingDuplicate.
 import * as fixtureConfigDuplicateService from '../service/fixtureConfigDuplicate.service.js';
 import * as planoVmDuplicateService from '../service/planoVmDuplicate.service.js';
 import advancedFormat from 'dayjs/plugin/advancedFormat.js';
+import * as planoRevisionService from '../service/planoRevision.service.js';
 
 dayjs.extend( advancedFormat );
 dayjs.extend( utc );
@@ -2780,7 +2781,7 @@ export async function storeFixturesv2( req, res ) {
             { storeId: { $in: req.body.id } },
           ],
         },
-        { storeId: 1, storeName: 1, planoId: '$_id', productResolutionLevel: 1, scanType: 1, clientId: 1, validateShelfSections: 1 },
+        { storeId: 1, storeName: 1, planoId: '$_id', productResolutionLevel: 1, scanType: 1, clientId: 1, validateShelfSections: 1, layoutName: 1 },
     );
 
     if ( !planograms?.length ) return res.sendError( 'No data found', 204 );
@@ -2791,7 +2792,7 @@ export async function storeFixturesv2( req, res ) {
         planograms.map( async ( planogram ) => {
           const floors = await storeBuilderService.find(
               { planoId: planogram._id, ...( req.body?.floorId && { _id: req.body.floorId } ) },
-              { floorName: 1, layoutPolygon: 1, planoId: 1, isEdited: 1, planoProgress: 1, updatedAt: 1 },
+              { floorName: 1, layoutPolygon: 1, planoId: 1, isEdited: 1, planoProgress: 1, updatedAt: 1, verificationStatus: 1, rolloutStatus: 1 },
           );
 
           const floorsWithFixtures = await Promise.all(
@@ -2839,7 +2840,7 @@ export async function storeFixturesv2( req, res ) {
 
                             const shelfDetails = await Promise.all(
                                 shelves.map( async ( shelf ) => {
-                                  const productDetails = await planoMappingService.find( { fixtureId: fixture._id, shelfId: shelf.toObject(), type: 'product' }, { _id: 1 } );
+                                  const productDetails = await planoMappingService.find( { fixtureId: fixture._id, shelfId: shelf._id, type: 'product' }, { _id: 1 } );
                                   let productIdList = productDetails.map( ( ele ) => ele._id );
                                   let complianceQuery = [
                                     {
@@ -2866,7 +2867,7 @@ export async function storeFixturesv2( req, res ) {
                                   let complianceStatus = await planoComplianceService.aggregate( complianceQuery );
                                   const compliance = complianceStatus?.[0]?.status?.length ? ( ( complianceStatus?.[0]?.status?.length != shelf.productPerShelf ) || complianceStatus?.[0]?.status.includes( 'misplaced' ) ) ? 'improper' : 'proper' : 'improper';
 
-                                  const vmCount = await planoMappingService.count( { fixtureId: fixture._id, shelfId: shelf.toObject(), type: 'vm' } );
+                                  const vmCount = await planoMappingService.count( { fixtureId: fixture._id, shelfId: shelf._id, type: 'vm' } );
 
                                   return {
                                     ...shelf.toObject(),
@@ -2969,7 +2970,7 @@ export async function storeFixturesv2( req, res ) {
 
                       const shelfDetails = await Promise.all(
                           shelves.map( async ( shelf ) => {
-                            const productDetails = await planoMappingService.find( { fixtureId: fixture._id, shelfId: shelf.toObject(), type: 'product' }, { _id: 1 } );
+                            const productDetails = await planoMappingService.find( { fixtureId: fixture._id, shelfId: shelf._id, type: 'product' }, { _id: 1 } );
                             let productIdList = productDetails.map( ( ele ) => ele._id );
                             let complianceQuery = [
                               {
@@ -2997,7 +2998,7 @@ export async function storeFixturesv2( req, res ) {
                             const compliance = complianceStatus?.[0]?.status.length ? ( ( complianceStatus?.[0]?.status?.length != shelf.productPerShelf ) || complianceStatus?.[0]?.status?.includes( 'misplaced' ) ) ? 'improper' : 'proper' : 'improper';
 
 
-                            const vmCount = await planoMappingService.count( { fixtureId: fixture._id, shelfId: shelf.toObject(), type: 'vm' } );
+                            const vmCount = await planoMappingService.count( { fixtureId: fixture._id, shelfId: shelf._id, type: 'vm' } );
 
                             return {
                               ...shelf.toObject(),
@@ -3488,6 +3489,134 @@ export async function fixtureShelfProductv2( req, res ) {
   }
 }
 
+export async function shelfProduct( req, res ) {
+  try {
+    if ( !req.body.revisionId ) {
+      return res.sendError( 'Revision id is required', 400 );
+    }
+    if ( !req.body.fixtureId ) {
+      return res.sendError( 'Fixture id is required', 400 );
+    }
+    const { revisionId, fixtureId } = req.body;
+    let shelfMapping = {};
+
+    let revisionDetails = await planoRevisionService.findOne( { _id: revisionId } );
+    let wallFixtures = revisionDetails.floorData.layoutPolygon.flatMap( ( ele ) => ele.fixtures );
+    let allFixtures = [ ...wallFixtures, ...revisionDetails.floorData.centerFixture ];
+    let fixture = allFixtures.find( ( ele ) => ele._id.toString() == fixtureId.toString() );
+
+    if ( !revisionDetails ) return res.sendError( 'Planogram not found', 204 );
+    if ( !fixture ) return res.sendError( 'Fixture not found', 204 );
+
+    let getImages = await planoTaskComplianceService.findOne( { fixtureId: fixtureId, type: 'fixture' } );
+
+    let fixtureImage = getImages?.answers?.[0]?.image ?? '';
+
+
+    if ( req.body?.compliance ) {
+      const getFixtureDetails = allFixtures.filter( ( ele ) => ele._id.toString() == fixture._id.toString() );
+      const getAllFixtures = getFixtureDetails.flatMap( ( shelf ) => shelf.shelfConfig );
+
+      shelfMapping = getAllFixtures.reduce( ( acc, ele ) => {
+        let productList = ele.productBrandName?.toString()?.toLowerCase();
+        if ( !acc?.[productList] ) {
+          let findZone = acc?.[productList]?.find( ( prod ) => prod.zone == ele.zone && prod.shelfId.toString() == ele._id.toString() );
+          if ( !findZone ) {
+            let fixDetails = getFixtureDetails.find( ( fix ) => fix._id.toString() == ele.fixtureId.toString() );
+            acc[productList] = [
+              {
+                zone: ele.zone,
+                shelfId: ele._id,
+                fixtureId: ele.fixtureId,
+                fixtureName: fixDetails?.fixtureName,
+                brandName: ele.productBrandName,
+              },
+            ];
+          }
+        }
+        return acc;
+      }, {} );
+    }
+
+
+    const currentDate = new Date( dayjs().format( 'YYYY-MM-DD' ) );
+
+    const getProducts = async ( mappings ) => {
+      const productIds = mappings.map( ( mapping ) => mapping.productId );
+      const products = await planoProductService.find( { _id: { $in: productIds }, type: 'product' } );
+      const productMap = new Map( products.map( ( product ) => [ product._id.toString(), product.toObject() ] ) );
+
+      return await Promise.all(
+          mappings.map( async ( mapping ) => {
+            const productData = productMap.get( mapping?.productId?.toString() ) || {};
+            delete productData._id;
+            let mappingCompliance = await planoComplianceService.findLean( {
+              planoMappingId: mapping._id,
+              date: currentDate,
+            } );
+            if ( mappingCompliance?.compliance == 'misplaced' ) {
+              Object.keys( shelfMapping ).forEach( ( ele ) => {
+                let eleArr = ele.split( ',' );
+                if ( eleArr.includes( productData.brandName.toLowerCase() ) ) {
+                  mappingCompliance = { ...mappingCompliance, fixtureDetails: shelfMapping[ele]?.[0] || {} };
+                }
+              } );
+            }
+            const status = mappingCompliance ? mappingCompliance.compliance : '';
+            return { ...mapping.toObject(), ...productData, status, ...( mappingCompliance?.fixtureDetails &&{ fixtureDetails: mappingCompliance?.fixtureDetails } ) };
+          } ),
+      );
+    };
+
+    const vmDetails = await Promise.all( fixture?.vmConfig?.map( async ( vm ) => {
+      const vmInfo = await planoVmService.findOne( { _id: vm.vmId } );
+      return {
+        ...vm,
+        ...vmInfo?.toObject(),
+      };
+    } ) );
+
+    // if ( fixture.toObject().productResolutionLevel === 'L1' ) {
+    //   const productMappings = await planoMappingService.find( { fixtureId: new mongoose.Types.ObjectId( fixtureId ), type: 'product' } );
+    //   const productDetails = await getProducts( productMappings );
+    //   return res.sendSuccess( { ...fixture.toObject(), products: productDetails, vmConfig: vmDetails, productCount: productMappings.length } );
+    // }
+
+    if ( [ 'L1', 'L2', 'L3', 'L4' ].includes( fixture.productResolutionLevel ) ) {
+      const fixtureShelves = fixture.shelfConfig;
+      const productCount = await planoMappingService.count( { fixtureId: new mongoose.Types.ObjectId( fixtureId ), type: 'product' } );
+      let shelfProducts = await Promise.all(
+          fixtureShelves.map( async ( shelf ) => {
+            const productMappings = await planoMappingService.find( { shelfId: shelf._id, type: 'product' } );
+            const productDetails = await getProducts( productMappings );
+            if ( req.body?.compliance ) {
+              let count = shelf.shelfType == 'tray' ? ( shelf.productPerShelf * shelf.trayRows ) : shelf.productPerShelf;
+              if ( count > productMappings.length ) {
+                let extraProduct = count- productMappings.length;
+                for ( let i=0; i<extraProduct; i++ ) {
+                  productDetails.unshift( {
+                    status: 'missing',
+                  } );
+                }
+              }
+            }
+            return { ...shelf, products: productDetails };
+          } ),
+      );
+
+      let storageProducts = await planoMappingService.find( { fixtureId: new mongoose.Types.ObjectId( fixtureId ), type: 'storageBox' } );
+      storageProducts = await getProducts( storageProducts );
+      return res.sendSuccess( { ...fixture, shelves: shelfProducts, vmConfig: vmDetails, productCount: productCount, storageProducts: storageProducts, fixtureImage: fixtureImage } );
+    }
+
+    return res.sendError( 'Incorrect resolution level', 400 );
+  } catch ( e ) {
+    console.log( e );
+    logger.error( { functionName: 'fixtureShelfProductv1', error: e, message: req.body } );
+    return res.sendError( e, 500 );
+  }
+}
+
 export async function fixtureShelfProductv3( req, res ) {
   try {
     const { planoId, fixtureId } = req.body;
@@ -5020,7 +5149,7 @@ export async function planoList( req, res ) {
     let page = inputData?.offset - 1 || 0;
     let skip = limit * page;
 
-    let storeDetails = await storeService.find( { clientId: inputData.clientId, status: 'active', ...( inputData?.stores?.length && { storeId: { $in: inputData.stores } } ),
+    let storeDetails = await storeService.find( { clientId: inputData.clientId, status: 'active', ...( inputData?.stores?.length && { storeId: { $in: inputData.stores }, ...( req.body.filter.country.length && { 'storeProfile.country': { $in: req.body.filter.country } } ), ...( req.body.filter.city.length && { 'storeProfile.city': { $in: req.body.city.country } } ) } ),
       ...( req.body?.assignedStores?.length && { storeId: { $in: req.body?.assignedStores } } ) }, { storeId: 1 } );
     storeDetails = storeDetails.map( ( ele ) => ele.storeId );
 
@@ -5049,14 +5178,10 @@ export async function planoList( req, res ) {
                 id: '$_id',
                 floorName: 1,
                 floorNumber: 1,
+                planoId: 1,
+                verificationStatus: 1,
               },
             },
-            // {
-            //   $group: {
-            //     _id: '',
-            //     layoutDetails: { $push: { k: '$_id', v: '$status', planoId: '$$plano' } },
-            //   },
-            // },
           ],
           as: 'layout',
         },
@@ -5064,18 +5189,25 @@ export async function planoList( req, res ) {
       {
         $set: {
           layoutCount: { $size: '$layout' },
+          layoutStatus: {
+            $map: {
+              input: '$layout',
+              as: 'lay',
+              in: '$$lay.verificationStatus',
+            },
+          },
         },
       },
-      { $unwind: { path: '$layout', preserveNullAndEmptyArrays: true } },
+      // { $unwind: { path: '$layout', preserveNullAndEmptyArrays: true } },
       {
         $lookup: {
           from: 'storefixtures',
-          let: { floor: '$layout.id' },
+          let: { plano: '$_id' },
           pipeline: [
             {
               $match: {
                 $expr: {
-                  $eq: [ '$floorId', '$$floor' ],
+                  $eq: [ '$planoId', '$$plano' ],
                 },
               },
             },
@@ -5095,14 +5227,13 @@ export async function planoList( req, res ) {
       {
         $lookup: {
           from: 'processedtasks',
-          let: { floor: '$layout.id' },
+          let: { plano: '$_id' },
           pipeline: [
             {
               $match: {
                 $expr: {
                   $and: [
-                    // { $eq: [ '$planoId', '$$plano' ] },
-                    { $eq: [ '$floorId', '$$floor' ] },
+                    { $eq: [ '$planoId', '$$plano' ] },
                     { $eq: [ '$isPlano', true ] },
                     {
                       $lte: [ '$date_iso', new Date( dayjs().format( 'YYYY-MM-DD' ) ) ],
@@ -5153,14 +5284,14 @@ export async function planoList( req, res ) {
         $lookup: {
           from: 'planotaskcompliances',
           let: {
-            floor: '$layout.id',
+            plano: '$_id',
           },
           pipeline: [
             {
               $match: {
                 $expr: {
                   $and: [
-                    { $eq: [ '$floorId', '$$floor' ] },
+                    { $eq: [ '$planoId', '$$plano' ] },
                     { $in: [ '$type', [ 'layout', 'fixture', 'vm' ] ] },
                   ],
                 },
@@ -5335,6 +5466,63 @@ export async function planoList( req, res ) {
                 },
               },
             },
+            {
+              $group: {
+                _id: '',
+                layoutCount: {
+                  $sum: '$layoutCount',
+                },
+                fixtureCount: {
+                  $sum: '$fixtureCount',
+                },
+                vmCount: {
+                  $sum: '$vmCount',
+                },
+                layoutPending: {
+                  $sum: '$layoutPending',
+                },
+                fixturePending: {
+                  $sum: '$fixturePending' },
+                fixtureApproved: {
+                  $push: '$fixtureApproved',
+                },
+                vmPending: {
+                  $sum: '$vmPending',
+                },
+                layoutDisagree: {
+                  $sum: '$layoutDisagree',
+                },
+                fixtureDisagree: {
+                  $sum: '$fixtureDisagree',
+                },
+                vmDisagree: {
+                  $sum: '$vmDisagree',
+                },
+              },
+            },
+            {
+              $project: {
+                _id: 0,
+                layoutCount: 1,
+                fixtureCount: 1,
+                vmCount: 1,
+                layoutPending: 1,
+                fixturePending: 1,
+                fixtureApproved: {
+                  $reduce: {
+                    input: '$fixtureApproved',
+                    initialValue: [],
+                    in: {
+                      $concatArrays: [ '$$value', '$$this' ],
+                    },
+                  },
+                },
+                vmPending: 1,
+                layoutDisagree: 1,
+                fixtureDisagree: 1,
+                vmDisagree: 1,
+              },
+            },
             {
               $project: {
                 _id: 0,
@@ -5519,6 +5707,7 @@ export async function planoList( req, res ) {
           lastUpdate: '$updatedAt',
           planoTask: { $ifNull: [ '$planoTask', [] ] },
           layoutCount: 1,
+          layoutStatus: 1,
           taskDetails: {
             $let: {
               vars: {
@@ -5556,7 +5745,7 @@ export async function planoList( req, res ) {
 
       if ( inputData.filter.taskPending === 'layout' ) {
         andQuery.push(
-            { 'taskDetails.layoutStatus': 'pending' },
+            { 'taskDetails.layoutStatus': 'complete' },
         );
       }
 
@@ -5578,94 +5767,274 @@ export async function planoList( req, res ) {
         },
       } );
     }
-
-    if ( inputData?.filter?.flag?.length ) {
-      let andQuery = [];
-      andQuery.push(
-          {
-            'planoTask.taskStatus': {
-              $elemMatch: {
-                type: { $in: inputData.filter.flag },
-                status: { $ne: 'submit' },
-                breach: true,
-              },
-            },
-          },
-          // { 'taskDetails.layoutStatus': 'pending' },
-      );
-      query.push( {
-        $match: {
-          $and: andQuery,
-        },
-      } );
-    }
-
     let orQuery = [];
 
-    if ( inputData.filter.status.length ) {
-      if ( inputData.filter.status.includes( 'taskAssigned' ) ) {
+
+    if ( inputData.filter.layout.length ) {
+      if ( inputData.filter.layout.includes( 'taskAssigned' ) ) {
         // orQuery.push( { 'planoTask.taskStatus.status': { $in: [ 'open', 'inprogress' ] } } );
         orQuery.push( {
-          'planoTask.taskStatus': {
-            $elemMatch: {
-              status: { $ne: 'submit' },
-              breach: false,
+          $and: [
+            {
+              $expr: {
+                $eq: [
+                  {
+                    $size: {
+                      $filter: {
+                        input: { $ifNull: [ { $arrayElemAt: [ '$planoTask.taskStatus', 0 ] }, [] ] },
+                        as: 'task',
+                        cond: {
+                          $and: [
+                            { $eq: [ '$$task.type', 'layout' ] },
+                            { $ne: [ '$$task.status', 'submit' ] },
+                            { $eq: [ '$$task.breach', false ] },
+                          ],
+                        },
+                      },
+                    },
+                  },
+                  '$layoutCount',
+                ],
+              },
             },
-          },
+          ],
         } );
       }
-      if ( inputData.filter.status.includes( 'reviewPending' ) ) {
+      if ( inputData.filter.layout.includes( 'flag' ) ) {
+        // orQuery.push( { 'planoTask.taskStatus.status': { $in: [ 'open', 'inprogress' ] } } );
         orQuery.push( {
           $and: [
-            { 'planoTask.taskStatus': {
-              $elemMatch: {
-                type: 'layout',
-                status: 'submit',
+            {
+              $expr: {
+                $eq: [
+                  {
+                    $size: {
+                      $filter: {
+                        input: { $ifNull: [ { $arrayElemAt: [ '$planoTask.taskStatus', 0 ] }, [] ] },
+                        as: 'task',
+                        cond: {
+                          $and: [
+                            { $eq: [ '$$task.type', 'layout' ] },
+                            { $ne: [ '$$task.status', 'submit' ] },
+                            { $eq: [ '$$task.breach', true ] },
+                          ],
+                        },
+                      },
+                    },
+                  },
+                  '$layoutCount',
+                ],
               },
-            } }, { 'taskDetails.layoutStatus': 'pending' },
+            },
           ],
         } );
+      }
+      if ( inputData.filter.layout.includes( 'reviewPending' ) ) {
         orQuery.push( {
           $and: [
             { 'planoTask.taskStatus': {
               $elemMatch: {
-                type: 'fixture',
+                type: 'layout',
                 status: 'submit',
               },
-            } }, { 'taskDetails.fixtureStatus': 'pending' },
+            } }, { 'taskDetails.layoutStatus': 'pending' },
           ],
         } );
+      }
+      if ( inputData.filter.layout.includes( 'completed' ) ) {
         orQuery.push( {
           $and: [
             { 'planoTask.taskStatus': {
               $elemMatch: {
-                type: 'vm',
+                type: 'layout',
                 status: 'submit',
               },
-            } }, { 'taskDetails.vmStatus': 'pending' },
+            } }, { 'taskDetails.layoutStatus': 'complete' },
           ],
         } );
       }
-      if ( inputData.filter.status.includes( 'completed' ) ) {
-        let taskType= [ 'fixture' ];
-        let andCondition = [];
-        taskType.forEach( ( type ) => {
-          andCondition.push(
-              { 'planoTask.taskStatus': {
-                $elemMatch: {
-                  type,
-                  status: 'submit',
-                },
-              } },
-              {
-                [`taskDetails.${type}Status`]: 'complete',
+      if ( inputData.filter.layout.includes( 'yetToAssign' ) ) {
+        orQuery.push( { 'planoTask.taskStatus': {
+          $not: {
+            $elemMatch: {
+              type: 'layout',
+            },
+          },
+        } } );
+      }
+    }
+
+    if ( inputData.filter.fixture.length ) {
+      if ( inputData.filter.fixture.includes( 'taskAssigned' ) ) {
+        // orQuery.push( { 'planoTask.taskStatus.status': { $in: [ 'open', 'inprogress' ] } } );
+        orQuery.push( {
+          $and: [
+            {
+              $expr: {
+                $eq: [
+                  {
+                    $size: {
+                      $filter: {
+                        input: { $ifNull: [ { $arrayElemAt: [ '$planoTask.taskStatus', 0 ] }, [] ] },
+                        as: 'task',
+                        cond: {
+                          $and: [
+                            { $eq: [ '$$task.type', 'fixture' ] },
+                            { $ne: [ '$$task.status', 'submit' ] },
+                            { $eq: [ '$$task.breach', false ] },
+                          ],
+                        },
+                      },
+                    },
+                  },
+                  '$layoutCount',
+                ],
               },
-          );
+            },
+          ],
         } );
-        orQuery.push( { $and: andCondition } );
       }
-      if ( inputData.filter.status.includes( 'yetToAssign' ) ) {
-        orQuery.push( { $expr: { $eq: [ { $size: '$planoTask' }, 0 ] } } );
+      if ( inputData.filter.fixture.includes( 'flag' ) ) {
+        // orQuery.push( { 'planoTask.taskStatus.status': { $in: [ 'open', 'inprogress' ] } } );
+        orQuery.push( {
+          $and: [
+            {
+              $expr: {
+                $eq: [
+                  {
+                    $size: {
+                      $filter: {
+                        input: { $ifNull: [ { $arrayElemAt: [ '$planoTask.taskStatus', 0 ] }, [] ] },
+                        as: 'task',
+                        cond: {
+                          $and: [
+                            { $eq: [ '$$task.type', 'fixture' ] },
+                            { $ne: [ '$$task.status', 'submit' ] },
+                            { $eq: [ '$$task.breach', true ] },
+                          ],
+                        },
+                      },
+                    },
+                  },
+                  '$layoutCount',
+                ],
+              },
+            },
+          ],
+        } );
+      }
+      if ( inputData.filter.fixture.includes( 'reviewPending' ) ) {
+        orQuery.push( {
+          $and: [
+            { 'planoTask.taskStatus': {
+              $elemMatch: {
+                type: 'fixture',
+                status: 'submit',
+              },
+            } }, { 'taskDetails.fixtureStatus': 'pending' },
+          ],
+        } );
+      }
+      if ( inputData.filter.fixture.includes( 'completed' ) ) {
+        orQuery.push( {
+          $and: [
+            {
+              $expr: {
+                $eq: [
+                  {
+                    $size: {
+                      $filter: {
+                        input: { $ifNull: [ { $arrayElemAt: [ '$planoTask.taskStatus', 0 ] }, [] ] },
+                        as: 'task',
+                        cond: {
+                          $and: [
+                            { $eq: [ '$$task.type', 'fixture' ] },
+                            { $eq: [ '$$task.status', 'submit' ] },
+                          ],
+                        },
+                      },
+                    },
+                  },
+                  '$layoutCount',
+                ],
+              },
+            },
+            { 'taskDetails.fixtureStatus': 'complete' },
+          ],
+        } );
+      }
+      if ( inputData.filter.fixture.includes( 'yetToAssign' ) ) {
+        orQuery.push( { 'planoTask.taskStatus': {
+          $not: {
+            $elemMatch: {
+              type: 'fixture',
+            },
+          },
+        } } );
+      }
+    }
+
+    if ( inputData.filter.status.length ) {
+      if ( inputData.filter.status.includes( 'inprogress' ) ) {
+        orQuery.push(
+            { 'planoTask.taskStatus': {
+              $elemMatch: {
+                type: 'layout',
+                status: { $ne: 'submit' },
+              },
+            } },
+            { 'taskDetails.layoutStatus': { $ne: 'complete' } },
+            { 'planoTask.taskStatus': {
+              $elemMatch: {
+                type: 'fixture',
+                status: { $ne: 'submit' },
+              },
+            } },
+            { 'taskDetails.fixtureStatus': { $ne: 'complete' } },
+            { $expr: { $eq: [ { $size: '$planoTask' }, 0 ] } },
+        );
+      }
+      if ( inputData.filter.status.includes( 'notPublished' ) ) {
+        orQuery.push( {
+          $and: [
+            { 'planoTask.taskStatus': {
+              $elemMatch: {
+                type: 'layout',
+                status: 'submit',
+              },
+            } }, { 'taskDetails.layoutStatus': 'complete' },
+            { 'planoTask.taskStatus': {
+              $elemMatch: {
+                type: 'fixture',
+                status: 'submit',
+              },
+            } }, { 'taskDetails.fixtureStatus': 'complete' },
+            {
+              layoutStatus: { $in: [ false ] },
+            },
+          ],
+        } );
+      }
+      if ( inputData.filter.status.includes( 'publish' ) ) {
+        orQuery.push( { $and: [
+          { 'planoTask.taskStatus': {
+            $elemMatch: {
+              type: 'layout',
+              status: 'submit',
+            },
+          } }, { 'taskDetails.layoutStatus': 'complete' },
+          { 'planoTask.taskStatus': {
+            $elemMatch: {
+              type: 'fixture',
+              status: 'submit',
+            },
+          } }, { 'taskDetails.fixtureStatus': 'complete' },
+          {
+            layoutStatus: { $nin: [ false ] },
+          },
+        ],
+        },
+        );
       }
     }
 
@@ -5711,7 +6080,9 @@ export async function planoList( req, res ) {
         storeId: { $in: storeDetails } }, { _id: 1 } ),
     ] );
 
-
+    if ( req.body.export ) {
+      await download( planoDetails[0].data );
+    }
     if ( !planoDetails[0].data.length ) {
       return res.sendError( 'No data found', 204 );
     }
@@ -5837,11 +6208,20 @@ export async function planoList( req, res ) {
               ],
             },
           },
+          layoutComplete: {
+            $sum: {
+              $cond: [
+                { $and: [ { $eq: [ '$type', 'layout' ] }, { $eq: [ '$status', 'complete' ] } ] },
+                1,
+                0,
+              ],
+            },
+          },
         },
       },
       {
         $group: {
-          _id: 0,
+          _id: '',
           layoutPending: {
             $sum: { $cond: {
               if: {
@@ -5869,6 +6249,13 @@ export async function planoList( req, res ) {
               else: 0,
             } },
           },
+          layoutComplete: { $sum: { $cond: {
+            if: {
+              $gt: [ '$layoutComplete', 0 ],
+            },
+            then: 1,
+            else: 0,
+          } } },
         },
       },
       {
@@ -5877,6 +6264,7 @@ export async function planoList( req, res ) {
           layoutPending: '$layoutPending',
           fixturePending: '$fixturePending',
           vmPending: '$vmPending',
+          layoutComplete: 1,
         },
       },
     ];
@@ -6379,7 +6767,14 @@ export async function getRolloutDetails( req, res ) {
     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', ...( req.body?.stores?.length && { storeId: { $in: req.body.stores } } ) }, { storeId: 1 } );
+    let storeDetails = await storeService.find( {
+      clientId: req.body.clientId,
+      status: 'active',
+      ...( req.body?.stores?.length && { storeId: { $in: req.body.stores } } ),
+      ...( req.body.filter.country.length && { 'storeProfile.country': { $in: req.body.filter.country } } ),
+      ...( req.body.filter.city.length && { 'storeProfile.city': { $in: req.body.filter.city } } ),
+      ...( req.body?.assignedStores?.length && { storeId: { $in: req.body?.assignedStores } } ) }, { storeId: 1 } );
+
     storeDetails = storeDetails.map( ( ele ) => ele.storeId );
     let query = [
       {
@@ -6389,15 +6784,31 @@ export async function getRolloutDetails( req, res ) {
           planoProgress: 100,
         },
       },
+      {
+        $group: {
+          _id: '$planoId',
+          planoId: { $first: '$planoId' },
+          layoutName: { $first: '$layoutName' },
+          floorId: { $first: '$_id' },
+          floorName: { $first: '$floorName' },
+          planoProgress: { $first: '$planoProgress' },
+          storeId: { $first: '$storeId' },
+          storeName: { $first: '$storeName' },
+          updatedAt: { $first: '$updatedAt' },
+          floorNumber: { $first: '$floorNumber' },
+          layoutCount: { $sum: 1 },
+          layoutStatus: { $push: '$rolloutStatus' },
+        },
+      },
       {
         $lookup: {
           from: 'storefixtures',
-          let: { floor: '$_id' },
+          let: { plano: '$planoId' },
           pipeline: [
             {
               $match: {
                 $expr: {
-                  $eq: [ '$floorId', '$$floor' ],
+                  $eq: [ '$planoId', '$$plano' ],
                 },
               },
             },
@@ -6429,7 +6840,7 @@ export async function getRolloutDetails( req, res ) {
           _id: 0,
           planoId: 1,
           layoutName: 1,
-          floorId: '$_id',
+          floorId: 1,
           floorNumber: 1,
           floorName: 1,
           planoProgress: 1,
@@ -6441,19 +6852,21 @@ export async function getRolloutDetails( req, res ) {
           lastUpdate: '$updatedAt',
           merchEditedCount: '$fixtureDetails.merchEditedCount',
           vmEditedCount: '$fixtureDetails.vmEditedCount',
+          layoutCount: 1,
+          layoutStatus: 1,
         },
       },
       {
         $lookup: {
           from: 'processedtasks',
-          let: { floorId: '$floorId' },
+          let: { planoId: '$planoId' },
           pipeline: [
             {
               $match: {
                 $expr: {
                   $and: [
                     { $lte: [ '$date_iso', new Date( dayjs().format( 'YYYY-MM-DD' ) ) ] },
-                    { $eq: [ '$floorId', '$$floorId' ] },
+                    { $eq: [ '$planoId', '$$planoId' ] },
                     { $eq: [ '$isPlano', true ] },
                     { $in: [ '$planoType', [ 'merchRollout', 'vmRollout' ] ] },
                   ],
@@ -6496,13 +6909,13 @@ export async function getRolloutDetails( req, res ) {
       {
         $lookup: {
           from: 'planotaskcompliances',
-          let: { floorId: '$floorId', taskId: '$taskDetails.taskId' },
+          let: { plano: '$planoId', taskId: '$taskDetails.taskId' },
           pipeline: [
             {
               $match: {
                 $expr: {
                   $and: [
-                    { $eq: [ '$floorId', '$$floorId' ] },
+                    { $eq: [ '$planoId', '$$plano' ] },
                     { $in: [ '$taskId', '$$taskId' ] },
                     { $in: [ '$type', [ 'merchRollout', 'vmRollout' ] ] },
                     // { $eq: [ '$status', 'incomplete' ] },
@@ -6833,10 +7246,9 @@ export async function getRolloutDetails( req, res ) {
       } );
     }
 
-    if ( req.body.filter?.status?.length ) {
-      const orCondition = [];
-
-      if ( req.body.filter.status.includes( 'yetToAssign' ) ) {
+    const orCondition = [];
+    if ( req.body.filter?.merch?.length ) {
+      if ( req.body.filter.merch.includes( 'yetToAssign' ) ) {
         orCondition.push(
             {
               $or: [
@@ -6846,12 +7258,12 @@ export async function getRolloutDetails( req, res ) {
                     { merchEditedCount: { $ne: 0 } },
                   ],
                 },
-                {
-                  $and: [
-                    { taskDetails: { $elemMatch: { type: 'vmRollout', status: 'submit' } } },
-                    { vmEditedCount: { $ne: 0 } },
-                  ],
-                },
+                // {
+                //   $and: [
+                //     { taskDetails: { $elemMatch: { type: 'vmRollout', status: 'submit' } } },
+                //     { vmEditedCount: { $ne: 0 } },
+                //   ],
+                // },
                 {
                   $expr: {
                     $lt: [ { $size: '$taskDetails' }, 2 ],
@@ -6870,6 +7282,87 @@ export async function getRolloutDetails( req, res ) {
                 ] },
               ],
             },
+            // {
+            //   $and: [
+            //     { taskDetails: { $elemMatch: { type: 'vmRollout', status: 'submit' } } },
+            //     { $or: [
+            //       { 'taskFeedback.vmStatus': 'disagree' },
+            //       { $and: [ { vmEditedCount: { $ne: 0 } }, { $expr: {
+            //         $eq: [ { $size: { $objectToArray: '$taskFeedback' } }, 0 ],
+            //       } } ] },
+            //     ] },
+            //   ],
+            // },
+        );
+      }
+
+      if ( req.body.filter.merch.includes( 'taskAssigned' ) ) {
+        orCondition.push( {
+          taskDetails: { $elemMatch: { type: 'merchRollout', status: { $ne: 'submit' }, breach: false } },
+        } );
+      }
+
+      if ( req.body.filter.merch.includes( 'reviewPending' ) ) {
+        orCondition.push(
+            {
+              $and: [
+                { taskDetails: { $elemMatch: { type: 'merchRollout', status: 'submit' } } },
+                { 'taskFeedback.fixtureStatus': 'pending' },
+              ],
+            },
+            // {
+            //   $and: [
+            //     { taskDetails: { $elemMatch: { type: 'vmRollout', status: 'submit' } } },
+            //     { 'taskFeedback.vmStatus': 'pending' },
+            //   ],
+            // },
+        );
+      }
+
+      if ( req.body.filter.merch.includes( 'completed' ) ) {
+        orCondition.push( {
+          $and: [
+            {
+              $or: [
+                { $and: [ { taskDetails: { $elemMatch: { type: 'merchRollout', status: 'submit' } } }, { merchEditedCount: 0 }, { 'taskFeedback.fixtureStatus': 'complete' } ] },
+                // { $and: [ { taskDetails: { $elemMatch: { type: 'vmRollout', status: 'submit' } } }, { vmEditedCount: 0 }, { 'taskFeedback.vmStatus': 'complete' } ] },
+              ],
+            },
+            // {
+            //   $expr: {
+            //     $eq: [ { $size: { $objectToArray: '$taskFeedback' } }, 0 ],
+            //   },
+            // },
+          ],
+        } );
+      }
+
+      if ( req.body.filter.merch.includes( 'flag' ) ) {
+        orCondition.push( {
+          taskDetails: { $elemMatch: { type: 'merchRollout', status: { $ne: 'submit' }, breach: true } },
+        } );
+      }
+
+      extraCondition.push( { $match: { $or: orCondition } } );
+    }
+    if ( req.body.filter?.vm?.length ) {
+      if ( req.body.filter.vm.includes( 'yetToAssign' ) ) {
+        orCondition.push(
+            {
+              $or: [
+                {
+                  $and: [
+                    { taskDetails: { $elemMatch: { type: 'vmRollout', status: 'submit' } } },
+                    { vmEditedCount: { $ne: 0 } },
+                  ],
+                },
+                {
+                  $expr: {
+                    $lt: [ { $size: '$taskDetails' }, 2 ],
+                  },
+                },
+              ],
+            },
             {
               $and: [
                 { taskDetails: { $elemMatch: { type: 'vmRollout', status: 'submit' } } },
@@ -6884,20 +7377,14 @@ export async function getRolloutDetails( req, res ) {
         );
       }
 
-      if ( req.body.filter.status.includes( 'taskAssigned' ) ) {
+      if ( req.body.filter.vm.includes( 'taskAssigned' ) ) {
         orCondition.push( {
-          taskDetails: { $elemMatch: { status: { $ne: 'submit' }, breach: false } },
+          taskDetails: { $elemMatch: { type: 'vmRollout', status: { $ne: 'submit' }, breach: false } },
         } );
       }
 
-      if ( req.body.filter.status.includes( 'reviewPending' ) ) {
+      if ( req.body.filter.vm.includes( 'reviewPending' ) ) {
         orCondition.push(
-            {
-              $and: [
-                { taskDetails: { $elemMatch: { type: 'merchRollout', status: 'submit' } } },
-                { 'taskFeedback.fixtureStatus': 'pending' },
-              ],
-            },
             {
               $and: [
                 { taskDetails: { $elemMatch: { type: 'vmRollout', status: 'submit' } } },
@@ -6907,12 +7394,11 @@ export async function getRolloutDetails( req, res ) {
         );
       }
 
-      if ( req.body.filter.status.includes( 'completed' ) ) {
+      if ( req.body.filter.vm.includes( 'completed' ) ) {
         orCondition.push( {
           $and: [
             {
               $or: [
-                { $and: [ { taskDetails: { $elemMatch: { type: 'merchRollout', status: 'submit' } } }, { merchEditedCount: 0 }, { 'taskFeedback.fixtureStatus': 'complete' } ] },
                 { $and: [ { taskDetails: { $elemMatch: { type: 'vmRollout', status: 'submit' } } }, { vmEditedCount: 0 }, { 'taskFeedback.vmStatus': 'complete' } ] },
               ],
             },
@@ -6925,43 +7411,114 @@ export async function getRolloutDetails( req, res ) {
         } );
       }
 
-      extraCondition.push( { $match: { $or: orCondition } } );
-    }
+      if ( req.body.filter.vm.includes( 'flag' ) ) {
+        orCondition.push( {
+          taskDetails: { $elemMatch: { type: 'vmRollout', status: { $ne: 'submit' }, breach: true } },
+        } );
+      }
 
-    if ( req.body.sortColumnName && req.body.sortBy ) {
-      query.push(
-          { $sort: { [req.body.sortColumnName]: req.body.sortBy } },
-      );
+      extraCondition.push( { $match: { $or: orCondition } } );
     }
 
-
-    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: {
+    if ( req.body.filter.status.length ) {
+      if ( inputData.filter.status.includes( 'inprogress' ) ) {
+        orCondition.push(
+            { 'taskDetails': {
+              $elemMatch: {
+                type: 'merchRollout',
+                status: { $ne: 'submit' },
+              },
+            } },
+            { 'taskDetails.fixtureStatus': { $ne: 'complete' } },
+            { 'taskDetails': {
+              $elemMatch: {
+                type: 'vmRollout',
+                status: { $ne: 'submit' },
+              },
+            } },
+            { 'taskDetails.vmStatus': { $ne: 'complete' } },
+            { $expr: { $eq: [ { $size: '$taskDetails' }, 0 ] } },
+        );
+      }
+      if ( inputData.filter.status.includes( 'notPublished' ) ) {
+        orCondition.push( {
+          $and: [
+            { 'taskDetails': {
+              $elemMatch: {
+                type: 'merchRollout',
+                status: 'submit',
+              },
+            } }, { 'taskDetails.fixtureStatus': 'complete' },
+            { 'planoTask.taskStatus': {
+              $elemMatch: {
+                type: 'vmRollout',
+                status: 'submit',
+              },
+            } }, { 'taskDetails.vmStatus': 'complete' },
+            {
+              layoutStatus: { $in: [ false ] },
+            },
+          ],
+        } );
+      }
+      if ( inputData.filter.status.includes( 'publish' ) ) {
+        orCondition.push( { $and: [
+          { 'taskDetails': {
+            $elemMatch: {
+              type: 'merchRollout',
+              status: 'submit',
+            },
+          } }, { 'taskDetails.fixtureStatus': 'complete' },
+          { 'planoTask.taskStatus': {
+            $elemMatch: {
+              type: 'vmRollout',
+              status: 'submit',
+            },
+          } }, { 'taskDetails.vmStatus': 'complete' },
+          {
+            layoutStatus: { $nin: [ false ] },
+          },
+        ],
+        },
+        );
+      }
+    }
+
+    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' },
+          //   },
+          // },
+          { $count: 'count' },
+        ],
+        rollOutStore: [
+          {
+            $match: {
+              $expr: { $gt: [ { $size: '$taskDetails' }, 0 ] },
+            },
+          },
+          { $count: 'count' },
+        ],
+        merchPending: [
+          {
+            $match: {
               $and: [
                 {
                   taskDetails: {
@@ -7013,36 +7570,36 @@ export async function getRolloutDetails( req, res ) {
     } );
 
 
-    let floorQuery = [
-      {
-        $match: {
-          clientId: req.body.clientId,
-          storeId: { $in: storeDetails },
-        },
-      },
-      {
-        $group: {
-          _id: '$storeId',
-          count: { $sum: 1 },
-        },
-      },
-      {
-        $match: {
-          count: { $gt: 1 },
-        },
-      },
-      {
-        $group: {
-          _id: '',
-          storeList: { $addToSet: '$_id' },
-        },
-      },
-    ];
-
+    // let floorQuery = [
+    //   {
+    //     $match: {
+    //       clientId: req.body.clientId,
+    //       storeId: { $in: storeDetails },
+    //     },
+    //   },
+    //   {
+    //     $group: {
+    //       _id: '$storeId',
+    //       count: { $sum: 1 },
+    //     },
+    //   },
+    //   {
+    //     $match: {
+    //       count: { $gt: 1 },
+    //     },
+    //   },
+    //   {
+    //     $group: {
+    //       _id: '',
+    //       storeList: { $addToSet: '$_id' },
+    //     },
+    //   },
+    // ];
+    // doubleFloorList
 
-    let [ rolloutDetails, doubleFloorList ] = await Promise.all( [
+    let [ rolloutDetails ] = await Promise.all( [
       storeBuilderService.aggregate( query ),
-      storeBuilderService.aggregate( floorQuery ),
+      // storeBuilderService.aggregate( floorQuery ),
     ] );
     let result = {
       cardData: {
@@ -7052,7 +7609,7 @@ export async function getRolloutDetails( req, res ) {
         vmPendingStore: rolloutDetails?.[0]?.vmPending?.[0]?.count || 0,
         flagStore: rolloutDetails?.[0]?.flag?.[0]?.count || 0,
         flagStore: rolloutDetails?.[0]?.flag?.[0]?.count || 0,
-        doubleFloorStore: doubleFloorList[0]?.storeList|| [],
+        // doubleFloorStore: doubleFloorList[0]?.storeList|| [],
       },
       tableData: {
         count: rolloutDetails?.[0]?.count?.[0]?.total || 0,
@@ -7372,6 +7929,7 @@ export async function searchProduct( req, res ) {
 export async function updateProductMapping( req, res ) {
   try {
     let storeDetails = await storeService.find( { clientId: req.body.clientId, ...( req.body.stores && { storeName: { $in: req.body.stores } } ), status: 'active' }, { storeId: 1, storeName: 1 } );
+    console.log( storeDetails, 'storeDetails' );
     if ( !storeDetails.length ) {
       return res.sendError( 'No data found', 204 );
     }
@@ -7386,9 +7944,10 @@ export async function updateProductMapping( req, res ) {
         await Promise.all( data.map( async ( ele ) => {
           let fixtureDetails = await storeFixtureService.find( { readerId: ele.data.MAC } );
           if ( fixtureDetails.length ) {
-            let getShelfDetails = await fixtureShelfService.findOne( { fixtureId: { $in: fixtureDetails?.map( ( fixt ) => fixt._id ) }, antennaNo: ele.data.antenna } );
+            let getShelfDetails = await fixtureShelfService.findOne( { fixtureId: { $in: fixtureDetails?.map( ( fixt ) => fixt._id ) }, antennaNo: { $in: [ ele.data.antenna ] } } );
             if ( !getShelfDetails ) {
-              fixtureDetails = fixtureDetails.find( ( fixt ) => fixt.footer.antennaNo == ele.data.antenna );
+              console.log( fixtureDetails );
+              fixtureDetails = fixtureDetails.find( ( fixt ) => fixt?.footer?.antennaNo?.includes( ele.data.antenna ) );
               if ( fixtureDetails ) {
                 getShelfDetails = { shelfType: 'storage' };
               }
@@ -7410,6 +7969,9 @@ export async function updateProductMapping( req, res ) {
                   fixtureId: fixtureDetails._id,
                   ...( getShelfDetails?.shelfType != 'storage' && { shelfId: getShelfDetails._id } ),
                 };
+                if ( ele.data.antenna == 7 ) {
+                  console.log( data, 'getShelfDetails' );
+                }
                 mappingData.push( data );
 
                 // let mappingDetails = await planoMappingService.create( data );
@@ -7618,7 +8180,7 @@ export async function calculateCompliance( req, res ) {
   }
 }
 
-export async function getPlanogramList( req, res ) {
+export async function getPlanogramListOld( req, res ) {
   try {
     const {
       clientId,
@@ -7660,11 +8222,33 @@ export async function getPlanogramList( req, res ) {
           storeId: { $in: allowedStoreIds },
         },
       },
-
+      {
+        $lookup: {
+          from: 'storelayouts',
+          let: { plano: '$_id' },
+          pipeline: [
+            {
+              $match: {
+                $expr: {
+                  $eq: [ '$planoId', '$$plano' ],
+                },
+              },
+            },
+            {
+              $group: {
+                _id: '$planoId',
+                floorId: { $first: '$_id' },
+                layoutDetails: { $sum: 1 },
+              },
+            },
+          ],
+          as: 'floorDetails',
+        },
+      },
       {
         $lookup: {
           from: 'storefixtures',
-          let: { plano: '$planoId', floor: '$_id' },
+          let: { plano: '$_id', floor: '$_id' },
           pipeline: [
             {
               $match: {
@@ -7686,18 +8270,17 @@ export async function getPlanogramList( req, res ) {
           as: 'fixtureDetails',
         },
       },
-
       {
         $lookup: {
           from: 'planocompliances',
-          let: { plano: '$planoId', floor: '$_id' },
+          let: { plano: '$_id' },
           pipeline: [
             {
               $match: {
                 $expr: {
                   $and: [
                     { $eq: [ '$planoId', '$$plano' ] },
-                    { $eq: [ '$floorId', '$$floor' ] },
+                    // { $eq: [ '$floorId', '$$floor' ] },
                     { $eq: [ '$date', today ] },
                     { $eq: [ '$compliance', 'proper' ] },
                   ],
@@ -7712,11 +8295,10 @@ export async function getPlanogramList( req, res ) {
           as: 'complianceCount',
         },
       },
-
       {
         $project: {
-          _id: 1,
-          planoId: 1,
+          _id: { $ifNull: [ { $arrayElemAt: [ '$floorDetails.floorId', 0 ] }, '' ] },
+          planoId: '$_id',
           createdAt: 1,
           updatedAt: 1,
           floorName: 1,
@@ -7728,6 +8310,7 @@ export async function getPlanogramList( req, res ) {
           storeName: 1,
           fixtureDetails: 1,
           complianceCount: 1,
+          layoutCount: { $ifNull: [ { $arrayElemAt: [ '$floorDetails.layoutDetails', 0 ] }, 1 ] },
           merchCompliance: {
             $floor: [
               {
@@ -7784,7 +8367,8 @@ export async function getPlanogramList( req, res ) {
       },
     } );
 
-    const result = await layoutService.aggregate( pipeline );
+    // const result = await layoutService.aggregate( pipeline );
+    const result = await planoService.aggregate( pipeline );
 
     let data = result?.[0]?.data || [];
     const total = result?.[0]?.count?.[0]?.total || 0;
@@ -7810,7 +8394,220 @@ export async function getPlanogramList( req, res ) {
 
       d.createdAt = dayjs.utc( d.createdAt ).format( 'DD MMM, YYYY' );
       d.updatedAt = dayjs.utc( d.updatedAt ).format( 'DD MMM, YYYY' );
+      d.merchCompliance = d.layoutCount > 1 ? d.merchCompliance/d.layoutCount : d.merchCompliance;
+      return d;
+    } );
+
+    return res.sendSuccess( { data, count: total } );
+  } catch ( err ) {
+    logger.error( { functionName: 'getLayoutList', error: err } );
+    return res.sendError( err, 500 );
+  }
+}
+
+export async function getPlanogramList( req, res ) {
+  try {
+    const {
+      clientId,
+      limit = 10,
+      offset = 1,
+      searchValue = '',
+      sortColumnName = '',
+      sortBy = '',
+      filter = {},
+    } = req.body;
+
+    const page = Math.max( offset - 1, 0 );
+    const skip = page * limit;
+
+    const today = new Date( dayjs().format( 'YYYY-MM-DD' ) );
+
+    const storeQuery = { clientId, status: 'active' };
+
+    if ( filter?.country?.length ) {
+      storeQuery['storeProfile.country'] = { $in: filter.country };
+    }
+
+    if ( filter?.city?.length ) {
+      storeQuery['storeProfile.city'] = { $in: filter.city };
+    }
+
+    const storeDocs = await storeService.find( storeQuery, { storeId: 1, storeProfile: 1 } );
+
+    if ( !storeDocs.length ) {
+      return res.sendSuccess( { data: [], count: 0 } );
+    }
+
+    const allowedStoreIds = storeDocs.map( ( s ) => s.storeId );
 
+    const pipeline = [
+      {
+        $match: {
+          clientId,
+          storeId: { $in: allowedStoreIds },
+        },
+      },
+      { $sort: { _id: -1 } },
+      {
+        $group: {
+          _id: { plano: '$planoId', floorId: '$floorId' },
+          lastUpdate: { $first: '$updatedAt' },
+          storeName: { $first: '$storeName' },
+          layoutName: { $first: '$layoutName' },
+          floorData: { $first: '$floorData' },
+          createdAt: { $first: '$createdAt' },
+          storeId: { $first: '$storeId' },
+        },
+      },
+      {
+        $group: {
+          _id: '$_id.plano',
+          updatedAt: { $first: '$lastUpdate' },
+          storeName: { $first: '$storeName' },
+          layoutName: { $first: '$layoutName' },
+          floorData: { $push: '$floorData' },
+          createdAt: { $first: '$createdAt' },
+          storeId: { $first: '$storeId' },
+        },
+      },
+      {
+        $set: {
+          productCount: {
+            $reduce: {
+              input: '$floorData',
+              initialValue: 0,
+              in: {
+                $add: [ '$$value', '$$this.planoProductCount' ],
+              },
+            },
+          },
+        },
+      },
+      {
+        $lookup: {
+          from: 'planocompliances',
+          let: { plano: '$_id' },
+          pipeline: [
+            {
+              $match: {
+                $expr: {
+                  $and: [
+                    { $eq: [ '$planoId', '$$plano' ] },
+                    // { $eq: [ '$floorId', '$$floor' ] },
+                    { $eq: [ '$date', today ] },
+                    { $eq: [ '$compliance', 'proper' ] },
+                  ],
+                },
+              },
+            },
+            { $group: { _id: '$createdAt', count: { $sum: 1 } } },
+            { $project: { _id: 0, date: '$_id', count: 1 } },
+            { $sort: { date: -1 } },
+            { $limit: 1 },
+          ],
+          as: 'complianceCount',
+        },
+      },
+      {
+        $project: {
+          _id: { $ifNull: [ { $arrayElemAt: [ '$floorData._id', 0 ] }, '' ] },
+          planoId: '$_id',
+          createdAt: 1,
+          updatedAt: 1,
+          // floorName: 1,
+          layoutName: 1,
+          // floorNumber: 1,
+          // planoProgress: 1,
+          // status: 1,
+          storeId: 1,
+          storeName: 1,
+          // fixtureDetails: 1,
+          complianceCount: 1,
+          layoutCount: { $ifNull: [ { $arrayElemAt: [ '$floorDetails.layoutDetails', 0 ] }, 1 ] },
+          merchCompliance: {
+            $floor: [
+              {
+                $multiply: [
+                  {
+                    $divide: [
+                      { $ifNull: [ { $arrayElemAt: [ '$complianceCount.count', 0 ] }, 0 ] },
+                      { $ifNull: [ '$productCount', 1 ] },
+                    ],
+                  },
+                  100,
+                ],
+              },
+            ],
+          },
+        },
+      },
+    ];
+
+    if ( filter?.compliance?.length === 2 ) {
+      const [ minC, maxC ] = filter.compliance.map( Number );
+      pipeline.push( {
+        $match: {
+          merchCompliance: { $gte: minC, $lte: maxC },
+        },
+      } );
+    }
+
+    if ( searchValue?.trim() ) {
+      const values = searchValue.split( ',' ).map( ( s ) => s.trim().toLowerCase() );
+
+      if ( values.length > 1 ) {
+        pipeline.push(
+            { $addFields: { store: { $toLower: '$storeName' } } },
+            { $match: { store: { $in: values } } },
+        );
+      } else {
+        pipeline.push( {
+          $match: { storeName: { $regex: searchValue, $options: 'i' } },
+        } );
+      }
+    }
+
+    if ( sortColumnName && sortBy ) {
+      pipeline.push( { $sort: { [sortColumnName]: Number( sortBy ) } } );
+    } else {
+      pipeline.push( { $sort: { createdAt: -1 } } );
+    }
+
+    pipeline.push( {
+      $facet: {
+        data: [ { $skip: skip }, { $limit: limit } ],
+        count: [ { $count: 'total' } ],
+      },
+    } );
+
+    // const result = await layoutService.aggregate( pipeline );
+    const result = await planoRevisionService.aggregate( pipeline );
+
+    let data = result?.[0]?.data || [];
+    const total = result?.[0]?.count?.[0]?.total || 0;
+
+    if ( !data.length ) {
+      return res.sendError( 'No data found', 204 );
+    }
+
+    const storeMap = {};
+    storeDocs.forEach( ( st ) => {
+      storeMap[st.storeId] = st;
+    } );
+
+    data = data.map( ( d ) => {
+      const st = storeMap[d.storeId];
+      d.storeInfo = st ?
+        {
+          country: st.storeProfile?.country,
+          state: st.storeProfile?.state,
+          city: st.storeProfile?.city,
+        } :
+        null;
+
+      d.createdAt = dayjs.utc( d.createdAt ).format( 'DD MMM, YYYY' );
+      d.updatedAt = dayjs.utc( d.updatedAt ).format( 'DD MMM, YYYY' );
+      d.merchCompliance = d.layoutCount > 1 ? d.merchCompliance/d.layoutCount : d.merchCompliance;
       return d;
     } );