tango-app-api-store-builder 1.0.19 → 1.0.21

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, download } from 'tango-app-api-middleware';
+import { logger, fileUpload, signedUrl, sendMessageToQueue, getOpenSearchData } from 'tango-app-api-middleware';
 import dayjs from 'dayjs';
 import customParseFormat from 'dayjs/plugin/customParseFormat.js';
 import utc from 'dayjs/plugin/utc.js';
@@ -26,7 +26,6 @@ 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 );
@@ -2781,7 +2780,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, layoutName: 1 },
+        { storeId: 1, storeName: 1, planoId: '$_id', productResolutionLevel: 1, scanType: 1, clientId: 1, validateShelfSections: 1 },
     );
 
     if ( !planograms?.length ) return res.sendError( 'No data found', 204 );
@@ -2792,7 +2791,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, verificationStatus: 1, rolloutStatus: 1 },
+              { floorName: 1, layoutPolygon: 1, planoId: 1, isEdited: 1, planoProgress: 1, updatedAt: 1 },
           );
 
           const floorsWithFixtures = await Promise.all(
@@ -2840,7 +2839,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._id, type: 'product' }, { _id: 1 } );
+                                  const productDetails = await planoMappingService.find( { fixtureId: fixture._id, shelfId: shelf.toObject(), type: 'product' }, { _id: 1 } );
                                   let productIdList = productDetails.map( ( ele ) => ele._id );
                                   let complianceQuery = [
                                     {
@@ -2867,7 +2866,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._id, type: 'vm' } );
+                                  const vmCount = await planoMappingService.count( { fixtureId: fixture._id, shelfId: shelf.toObject(), type: 'vm' } );
 
                                   return {
                                     ...shelf.toObject(),
@@ -2970,7 +2969,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._id, type: 'product' }, { _id: 1 } );
+                            const productDetails = await planoMappingService.find( { fixtureId: fixture._id, shelfId: shelf.toObject(), type: 'product' }, { _id: 1 } );
                             let productIdList = productDetails.map( ( ele ) => ele._id );
                             let complianceQuery = [
                               {
@@ -2998,7 +2997,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._id, type: 'vm' } );
+                            const vmCount = await planoMappingService.count( { fixtureId: fixture._id, shelfId: shelf.toObject(), type: 'vm' } );
 
                             return {
                               ...shelf.toObject(),
@@ -3489,134 +3488,6 @@ 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;
@@ -5149,7 +5020,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 }, ...( req.body.filter.country.length && { 'storeProfile.country': { $in: req.body.filter.country } } ), ...( req.body.filter.city.length && { 'storeProfile.city': { $in: req.body.city.country } } ) } ),
+    let storeDetails = await storeService.find( { clientId: inputData.clientId, status: 'active', ...( inputData?.stores?.length && { storeId: { $in: inputData.stores } } ),
       ...( req.body?.assignedStores?.length && { storeId: { $in: req.body?.assignedStores } } ) }, { storeId: 1 } );
     storeDetails = storeDetails.map( ( ele ) => ele.storeId );
 
@@ -5178,10 +5049,14 @@ 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',
         },
@@ -5189,25 +5064,18 @@ 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: { plano: '$_id' },
+          let: { floor: '$layout.id' },
           pipeline: [
             {
               $match: {
                 $expr: {
-                  $eq: [ '$planoId', '$$plano' ],
+                  $eq: [ '$floorId', '$$floor' ],
                 },
               },
             },
@@ -5227,13 +5095,14 @@ export async function planoList( req, res ) {
       {
         $lookup: {
           from: 'processedtasks',
-          let: { plano: '$_id' },
+          let: { floor: '$layout.id' },
           pipeline: [
             {
               $match: {
                 $expr: {
                   $and: [
-                    { $eq: [ '$planoId', '$$plano' ] },
+                    // { $eq: [ '$planoId', '$$plano' ] },
+                    { $eq: [ '$floorId', '$$floor' ] },
                     { $eq: [ '$isPlano', true ] },
                     {
                       $lte: [ '$date_iso', new Date( dayjs().format( 'YYYY-MM-DD' ) ) ],
@@ -5284,14 +5153,14 @@ export async function planoList( req, res ) {
         $lookup: {
           from: 'planotaskcompliances',
           let: {
-            plano: '$_id',
+            floor: '$layout.id',
           },
           pipeline: [
             {
               $match: {
                 $expr: {
                   $and: [
-                    { $eq: [ '$planoId', '$$plano' ] },
+                    { $eq: [ '$floorId', '$$floor' ] },
                     { $in: [ '$type', [ 'layout', 'fixture', 'vm' ] ] },
                   ],
                 },
@@ -5466,63 +5335,6 @@ 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,
@@ -5707,7 +5519,6 @@ export async function planoList( req, res ) {
           lastUpdate: '$updatedAt',
           planoTask: { $ifNull: [ '$planoTask', [] ] },
           layoutCount: 1,
-          layoutStatus: 1,
           taskDetails: {
             $let: {
               vars: {
@@ -5745,7 +5556,7 @@ export async function planoList( req, res ) {
 
       if ( inputData.filter.taskPending === 'layout' ) {
         andQuery.push(
-            { 'taskDetails.layoutStatus': 'complete' },
+            { 'taskDetails.layoutStatus': 'pending' },
         );
       }
 
@@ -5767,274 +5578,94 @@ export async function planoList( req, res ) {
         },
       } );
     }
-    let orQuery = [];
 
+    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.layout.length ) {
-      if ( inputData.filter.layout.includes( 'taskAssigned' ) ) {
+    if ( inputData.filter.status.length ) {
+      if ( inputData.filter.status.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', 'layout' ] },
-                            { $ne: [ '$$task.status', 'submit' ] },
-                            { $eq: [ '$$task.breach', false ] },
-                          ],
-                        },
-                      },
-                    },
-                  },
-                  '$layoutCount',
-                ],
-              },
+          'planoTask.taskStatus': {
+            $elemMatch: {
+              status: { $ne: 'submit' },
+              breach: false,
             },
-          ],
+          },
         } );
       }
-      if ( inputData.filter.layout.includes( 'flag' ) ) {
-        // orQuery.push( { 'planoTask.taskStatus.status': { $in: [ 'open', 'inprogress' ] } } );
+      if ( inputData.filter.status.includes( 'reviewPending' ) ) {
         orQuery.push( {
           $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', true ] },
-                          ],
-                        },
-                      },
-                    },
-                  },
-                  '$layoutCount',
-                ],
+            { 'planoTask.taskStatus': {
+              $elemMatch: {
+                type: 'layout',
+                status: 'submit',
               },
-            },
+            } }, { 'taskDetails.layoutStatus': 'pending' },
           ],
         } );
-      }
-      if ( inputData.filter.layout.includes( 'reviewPending' ) ) {
         orQuery.push( {
           $and: [
             { 'planoTask.taskStatus': {
               $elemMatch: {
-                type: 'layout',
+                type: 'fixture',
                 status: 'submit',
               },
-            } }, { 'taskDetails.layoutStatus': 'pending' },
+            } }, { 'taskDetails.fixtureStatus': 'pending' },
           ],
         } );
-      }
-      if ( inputData.filter.layout.includes( 'completed' ) ) {
         orQuery.push( {
           $and: [
             { 'planoTask.taskStatus': {
               $elemMatch: {
-                type: 'layout',
+                type: 'vm',
                 status: 'submit',
               },
-            } }, { 'taskDetails.layoutStatus': 'complete' },
+            } }, { 'taskDetails.vmStatus': 'pending' },
           ],
         } );
       }
-      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',
-                ],
-              },
-            },
-          ],
-        } );
-      }
-      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',
+      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',
               },
-            } }, { 'taskDetails.fixtureStatus': 'complete' },
-            {
-              layoutStatus: { $in: [ false ] },
-            },
-          ],
+          );
         } );
+        orQuery.push( { $and: andCondition } );
       }
-      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 ] },
-          },
-        ],
-        },
-        );
+      if ( inputData.filter.status.includes( 'yetToAssign' ) ) {
+        orQuery.push( { $expr: { $eq: [ { $size: '$planoTask' }, 0 ] } } );
       }
     }
 
@@ -6080,9 +5711,7 @@ 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 );
     }
@@ -6208,20 +5837,11 @@ export async function planoList( req, res ) {
               ],
             },
           },
-          layoutComplete: {
-            $sum: {
-              $cond: [
-                { $and: [ { $eq: [ '$type', 'layout' ] }, { $eq: [ '$status', 'complete' ] } ] },
-                1,
-                0,
-              ],
-            },
-          },
         },
       },
       {
         $group: {
-          _id: '',
+          _id: 0,
           layoutPending: {
             $sum: { $cond: {
               if: {
@@ -6249,13 +5869,6 @@ export async function planoList( req, res ) {
               else: 0,
             } },
           },
-          layoutComplete: { $sum: { $cond: {
-            if: {
-              $gt: [ '$layoutComplete', 0 ],
-            },
-            then: 1,
-            else: 0,
-          } } },
         },
       },
       {
@@ -6264,7 +5877,6 @@ export async function planoList( req, res ) {
           layoutPending: '$layoutPending',
           fixturePending: '$fixturePending',
           vmPending: '$vmPending',
-          layoutComplete: 1,
         },
       },
     ];
@@ -6767,14 +6379,7 @@ 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 } } ),
-      ...( 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 } );
-
+    let storeDetails = await storeService.find( { clientId: req.body.clientId, status: 'active', ...( req.body?.stores?.length && { storeId: { $in: req.body.stores } } ) }, { storeId: 1 } );
     storeDetails = storeDetails.map( ( ele ) => ele.storeId );
     let query = [
       {
@@ -6784,31 +6389,15 @@ 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: { plano: '$planoId' },
+          let: { floor: '$_id' },
           pipeline: [
             {
               $match: {
                 $expr: {
-                  $eq: [ '$planoId', '$$plano' ],
+                  $eq: [ '$floorId', '$$floor' ],
                 },
               },
             },
@@ -6840,7 +6429,7 @@ export async function getRolloutDetails( req, res ) {
           _id: 0,
           planoId: 1,
           layoutName: 1,
-          floorId: 1,
+          floorId: '$_id',
           floorNumber: 1,
           floorName: 1,
           planoProgress: 1,
@@ -6852,21 +6441,19 @@ export async function getRolloutDetails( req, res ) {
           lastUpdate: '$updatedAt',
           merchEditedCount: '$fixtureDetails.merchEditedCount',
           vmEditedCount: '$fixtureDetails.vmEditedCount',
-          layoutCount: 1,
-          layoutStatus: 1,
         },
       },
       {
         $lookup: {
           from: 'processedtasks',
-          let: { planoId: '$planoId' },
+          let: { floorId: '$floorId' },
           pipeline: [
             {
               $match: {
                 $expr: {
                   $and: [
                     { $lte: [ '$date_iso', new Date( dayjs().format( 'YYYY-MM-DD' ) ) ] },
-                    { $eq: [ '$planoId', '$$planoId' ] },
+                    { $eq: [ '$floorId', '$$floorId' ] },
                     { $eq: [ '$isPlano', true ] },
                     { $in: [ '$planoType', [ 'merchRollout', 'vmRollout' ] ] },
                   ],
@@ -6909,13 +6496,13 @@ export async function getRolloutDetails( req, res ) {
       {
         $lookup: {
           from: 'planotaskcompliances',
-          let: { plano: '$planoId', taskId: '$taskDetails.taskId' },
+          let: { floorId: '$floorId', taskId: '$taskDetails.taskId' },
           pipeline: [
             {
               $match: {
                 $expr: {
                   $and: [
-                    { $eq: [ '$planoId', '$$plano' ] },
+                    { $eq: [ '$floorId', '$$floorId' ] },
                     { $in: [ '$taskId', '$$taskId' ] },
                     { $in: [ '$type', [ 'merchRollout', 'vmRollout' ] ] },
                     // { $eq: [ '$status', 'incomplete' ] },
@@ -7246,9 +6833,10 @@ export async function getRolloutDetails( req, res ) {
       } );
     }
 
-    const orCondition = [];
-    if ( req.body.filter?.merch?.length ) {
-      if ( req.body.filter.merch.includes( 'yetToAssign' ) ) {
+    if ( req.body.filter?.status?.length ) {
+      const orCondition = [];
+
+      if ( req.body.filter.status.includes( 'yetToAssign' ) ) {
         orCondition.push(
             {
               $or: [
@@ -7258,12 +6846,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 ],
@@ -7282,87 +6870,6 @@ 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' } } },
@@ -7377,14 +6884,20 @@ export async function getRolloutDetails( req, res ) {
         );
       }
 
-      if ( req.body.filter.vm.includes( 'taskAssigned' ) ) {
+      if ( req.body.filter.status.includes( 'taskAssigned' ) ) {
         orCondition.push( {
-          taskDetails: { $elemMatch: { type: 'vmRollout', status: { $ne: 'submit' }, breach: false } },
+          taskDetails: { $elemMatch: { status: { $ne: 'submit' }, breach: false } },
         } );
       }
 
-      if ( req.body.filter.vm.includes( 'reviewPending' ) ) {
+      if ( req.body.filter.status.includes( 'reviewPending' ) ) {
         orCondition.push(
+            {
+              $and: [
+                { taskDetails: { $elemMatch: { type: 'merchRollout', status: 'submit' } } },
+                { 'taskFeedback.fixtureStatus': 'pending' },
+              ],
+            },
             {
               $and: [
                 { taskDetails: { $elemMatch: { type: 'vmRollout', status: 'submit' } } },
@@ -7394,11 +6907,12 @@ export async function getRolloutDetails( req, res ) {
         );
       }
 
-      if ( req.body.filter.vm.includes( 'completed' ) ) {
+      if ( req.body.filter.status.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' } ] },
               ],
             },
@@ -7411,79 +6925,9 @@ export async function getRolloutDetails( req, res ) {
         } );
       }
 
-      if ( req.body.filter.vm.includes( 'flag' ) ) {
-        orCondition.push( {
-          taskDetails: { $elemMatch: { type: 'vmRollout', status: { $ne: 'submit' }, breach: true } },
-        } );
-      }
-
       extraCondition.push( { $match: { $or: orCondition } } );
     }
 
-    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 } },
@@ -7494,19 +6938,18 @@ export async function getRolloutDetails( req, res ) {
     query.push( {
       $facet: {
         totalStore: [
-          // {
-          //   $group: {
-          //     _id: '',
-          //     storeList: { $addToSet: '$storeId' },
-          //   },
-          // },
-          // {
-          //   $project: {
-          //     _id: 0,
-          //     count: { $size: '$storeList' },
-          //   },
-          // },
-          { $count: 'count' },
+          {
+            $group: {
+              _id: '',
+              storeList: { $addToSet: '$storeId' },
+            },
+          },
+          {
+            $project: {
+              _id: 0,
+              count: { $size: '$storeList' },
+            },
+          },
         ],
         rollOutStore: [
           {
@@ -7570,36 +7013,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' },
-    //     },
-    //   },
-    // ];
-    // doubleFloorList
+    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 [ rolloutDetails ] = await Promise.all( [
+
+    let [ rolloutDetails, doubleFloorList ] = await Promise.all( [
       storeBuilderService.aggregate( query ),
-      // storeBuilderService.aggregate( floorQuery ),
+      storeBuilderService.aggregate( floorQuery ),
     ] );
     let result = {
       cardData: {
@@ -7609,7 +7052,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,
@@ -7929,7 +7372,6 @@ 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 );
     }
@@ -7944,10 +7386,9 @@ 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: { $in: [ ele.data.antenna ] } } );
+            let getShelfDetails = await fixtureShelfService.findOne( { fixtureId: { $in: fixtureDetails?.map( ( fixt ) => fixt._id ) }, antennaNo: ele.data.antenna } );
             if ( !getShelfDetails ) {
-              console.log( fixtureDetails );
-              fixtureDetails = fixtureDetails.find( ( fixt ) => fixt?.footer?.antennaNo?.includes( ele.data.antenna ) );
+              fixtureDetails = fixtureDetails.find( ( fixt ) => fixt.footer.antennaNo == ele.data.antenna );
               if ( fixtureDetails ) {
                 getShelfDetails = { shelfType: 'storage' };
               }
@@ -7969,9 +7410,6 @@ 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 );
@@ -8180,7 +7618,7 @@ export async function calculateCompliance( req, res ) {
   }
 }
 
-export async function getPlanogramListOld( req, res ) {
+export async function getPlanogramList( req, res ) {
   try {
     const {
       clientId,
@@ -8222,33 +7660,11 @@ export async function getPlanogramListOld( 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: '$_id', floor: '$_id' },
+          let: { plano: '$planoId', floor: '$_id' },
           pipeline: [
             {
               $match: {
@@ -8270,17 +7686,18 @@ export async function getPlanogramListOld( req, res ) {
           as: 'fixtureDetails',
         },
       },
+
       {
         $lookup: {
           from: 'planocompliances',
-          let: { plano: '$_id' },
+          let: { plano: '$planoId', floor: '$_id' },
           pipeline: [
             {
               $match: {
                 $expr: {
                   $and: [
                     { $eq: [ '$planoId', '$$plano' ] },
-                    // { $eq: [ '$floorId', '$$floor' ] },
+                    { $eq: [ '$floorId', '$$floor' ] },
                     { $eq: [ '$date', today ] },
                     { $eq: [ '$compliance', 'proper' ] },
                   ],
@@ -8295,10 +7712,11 @@ export async function getPlanogramListOld( req, res ) {
           as: 'complianceCount',
         },
       },
+
       {
         $project: {
-          _id: { $ifNull: [ { $arrayElemAt: [ '$floorDetails.floorId', 0 ] }, '' ] },
-          planoId: '$_id',
+          _id: 1,
+          planoId: 1,
           createdAt: 1,
           updatedAt: 1,
           floorName: 1,
@@ -8310,7 +7728,6 @@ export async function getPlanogramListOld( req, res ) {
           storeName: 1,
           fixtureDetails: 1,
           complianceCount: 1,
-          layoutCount: { $ifNull: [ { $arrayElemAt: [ '$floorDetails.layoutDetails', 0 ] }, 1 ] },
           merchCompliance: {
             $floor: [
               {
@@ -8367,8 +7784,7 @@ export async function getPlanogramListOld( req, res ) {
       },
     } );
 
-    // const result = await layoutService.aggregate( pipeline );
-    const result = await planoService.aggregate( pipeline );
+    const result = await layoutService.aggregate( pipeline );
 
     let data = result?.[0]?.data || [];
     const total = result?.[0]?.count?.[0]?.total || 0;
@@ -8394,220 +7810,7 @@ export async function getPlanogramListOld( 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;
     } );