tango-app-api-store-builder 1.0.30 → 1.0.32

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-store-builder",
-    "version": "1.0.30",
+    "version": "1.0.32",
     "description": "storeBuilder",
     "main": "index.js",
     "type": "module",
@@ -32,7 +32,7 @@
         "path": "^0.12.7",
         "selenium-webdriver": "^4.31.0",
         "sharp": "^0.34.1",
-        "tango-api-schema": "^2.5.17",
+        "tango-api-schema": "^2.5.23",
         "tango-app-api-middleware": "3.1.48",
         "url": "^0.11.4",
         "winston": "^3.17.0",

package/src/controllers/managePlano.controller.js

@@ -1,6 +1,6 @@
 import * as floorService from '../service/storeBuilder.service.js';
-import { logger, insertOpenSearchData, getOpenSearchData, updateOpenSearchData, getOpenSearchById } from 'tango-app-api-middleware';
-// import * as storeService from '../service/store.service.js';
+import { logger, insertOpenSearchData, getOpenSearchData, updateOpenSearchData, getOpenSearchById, fileUpload } from 'tango-app-api-middleware';
+import * as storeService from '../service/store.service.js';
 import * as planoService from '../service/planogram.service.js';
 import * as storeFixtureService from '../service/storeFixture.service.js';
 import * as fixtureShelfService from '../service/fixtureShelf.service.js';
@@ -1372,7 +1372,7 @@ export async function updateStoreFixture( req, res ) {
           };
           vmDetails = await planoVmService.create( planovmData );
         }
-        vmConfig.push( { ...vm, vmId: vmDetails._id, vmName: vmDetails.vmName, vmImage: vmDetails.vmImageUrl } );
+        vmConfig.push({ ...vm, vmId: vmDetails._id, vmName: vmDetails.vmName, vmImage: vmDetails.vmImageUrl });
       }
       data.vmConfig = vmConfig;
       let groupName = {
@@ -2363,3 +2363,261 @@ export async function getPlanoStoreVideoPageParams( req, res ) {
     res.sendError( 'Failed to fetch plano store video page params', 500 );
   }
 }
+
+export async function createPlanoFromCAD(req, res) {
+  try {
+    const user = req.user;
+    const file = req.files.file;
+    const { storeId, floorNumber } = req.body;
+
+    if (!req?.files?.file) return res.sendError('File is required', 400);
+
+    if (!storeId || !floorNumber) return res.sendError('storeId and floorNumber are required', 400);
+
+    if (!file.name.endsWith('.dxf')) return res.sendError('Only DXF files are allowed', 400);
+
+
+    // if (file.size > 20 * 1024 * 1024) {
+    //   return res.sendError('File size exceeds 20MB limit', 400);
+    // }
+
+    // File Upload
+    const fileUploadPayload = {
+      Bucket: JSON.parse(process.env.BUCKET).storeBuilder,
+      Key: `planoCad/`,
+      fileName: Date.now() + '.' + file.name?.split('.')?.slice(-1)?.[0],
+      ContentType: file.mimetype,
+      body: file.data,
+    };
+
+    const fileRes = await fileUpload(fileUploadPayload);
+
+    if (!fileRes?.Key) return res.sendError('Failed to upload file to storage', 502);
+
+    // CAD Extraction
+    const dataExtractPayload = {
+      s3Bucket: fileUploadPayload.Bucket,
+      filePath: fileRes.Key,
+    };
+
+    const cadRes = await fetch(
+      JSON.parse(process.env.LAMBDAURL).extractCADDetails,
+      {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(dataExtractPayload),
+      }
+    );
+
+    if (!cadRes.ok) {
+      const errorText = await cadRes.text();
+      logger.error({ cadLambdaError: errorText });
+      return res.sendError('CAD extraction service failed', 502);
+    }
+
+    const cadData = await cadRes.json();
+
+    if (
+      cadData?.status !== 'success' ||
+      !cadData?.data?.layoutPolygon
+    ) {
+      return res.sendError('Invalid CAD layout data', 502);
+    }
+
+    const userMeta = {
+      createdBy: user._id,
+      createdByEmail: user.email,
+      createdByName: user.userName,
+    }
+
+    // PLANOGRAM
+    let planoData = await planoService.findOne({ storeId }, { _id: 1, clientId: 1, storeName: 1, });
+
+    if (!planoData) {
+      const storeData = await storeService.findOne({ storeId }, { clientId: 1, storeName: 1 });
+      if (!storeData) return res.sendError('Unable to find the store to create planogram', 400);
+
+      const newPlano = {
+        clientId: storeData.clientId,
+        storeName: storeData.storeName,
+        storeId,
+        layoutName: `${storeData.storeName} - Layout`,
+        attachments: [],
+        status: 'completed',
+        productResolutionLevel: 'L2',
+        scanType: 'qr',
+        planoStrategy: "nonIvm",
+        ...userMeta
+      };
+
+      planoData = await planoService.create(newPlano);
+      if (!planoData) return res.sendError('Failed to create new planogram', 400);
+    }
+
+    const floorPayload = {
+      layoutPolygon: processWallData(cadData.data.layoutPolygon),
+      planoProgress: 25,
+      floorName: `Floor ${floorNumber}`,
+      isEdited: false,
+      cadLayout: true
+    };
+
+    let floorData = await floorService.findOne({ planoId: planoData._id, floorNumber }, { _id: 1, clientId: 1, storeName: 1, storeId: 1, planoId: 1 });
+    if (floorData) {
+      await floorService.updateOne({ _id: floorData._id }, { ...floorPayload, updatedBy: user._id });
+    } else {
+      const newFloor = {
+        clientId: planoData.clientId,
+        planoId: planoData._id,
+        layoutName: `${planoData.storeName} - Layout`,
+        status: 'completed',
+        storeName: planoData.storeName,
+        floorNumber,
+        storeId,
+        ...floorPayload,
+        ...userMeta,
+      };
+
+      floorData = await floorService.create(newFloor);
+      if (!floorData) return res.sendError('Failed to create new floor layout', 400);
+    }
+
+    const meta = {
+      clientId: floorData.clientId,
+      storeName: floorData.storeName,
+      storeId: floorData.storeId,
+      planoId: floorData.planoId,
+      floorId: floorData._id,
+    }
+
+    logger.info({
+      functionName: 'CAD DATA: ',
+      body: cadData.data,
+    });
+
+    // Create Fixtures
+    const processedFixtures = createStoreFixtures(cadData.data, meta);
+
+    try {
+      await storeFixtureService.deleteMany({ floorId: meta.floorId });
+      await fixtureShelfService.deleteMany({ floorId: meta.floorId });
+      for (let i = 0; i < processedFixtures.length; i++) {
+        const fix = processedFixtures[i];
+        await storeFixtureService.create(fix);
+      }
+    } catch (e) {
+      logger.error({
+        functionName: 'createPlanoFromCAD [Create Fixtures]',
+        error: e,
+      });
+    }
+
+    return res.sendSuccess(meta);
+
+  } catch (error) {
+    logger.error({
+      functionName: 'createPlanoFromCAD',
+      error,
+    });
+
+    return res.sendError('Failed to create planogram.', 500);
+  }
+}
+
+function processWallData(cadRes) {
+  return cadRes.map((w) => {
+    return {
+      "elementType": w?.elementType ?? 'wall',
+      "distance": w?.distance ?? 16,
+      "elementNumber": w?.elementNumber ?? 0,
+      "unit": w?.unit ?? "ft",
+      "direction": w?.direction ?? "right",
+      "angle": w?.angle ?? 0,
+      "relativePosition": w?.relativePosition,
+    }
+  });
+}
+
+function createStoreFixtures(data, meta) {
+
+  let fixtures = [];
+  const walls = data?.layoutPolygon ?? [];
+  for (let i = 1; i <= walls.length; i++) {
+    const w = walls[i - 1];
+    const wFixtures = w?.fixtures ?? [];
+
+    for (let j = 1; j <= wFixtures.length; j++) {
+      const f = wFixtures[j - 1];
+
+      const fixtureInfo = {
+        f: f,
+        meta: meta,
+        wallNumber: w.elementNumber,
+        fixtureNumber: j,
+      }
+
+      fixtures.push(processFixtureData(fixtureInfo));
+    }
+  }
+
+  const centerFixtures = data?.centerFixture ?? [];
+  for (let i = 1; i <= centerFixtures.length; i++) {
+    const f = centerFixtures[i - 1];
+
+    const fixtureInfo = {
+      f: f,
+      meta: meta,
+      wallNumber: undefined,
+      fixtureNumber: i,
+    }
+
+    fixtures.push(processFixtureData(fixtureInfo));
+  }
+
+  return fixtures;
+}
+
+function processFixtureData(data) {
+  const f = data.f;
+
+  function normalizeCadText(value) {
+    if (typeof value !== 'string') return value;
+    return value.replace(/^\\[^;]+;/, '').trim();
+  }
+
+  return {
+    ...data.meta,
+    fixtureName: normalizeCadText(f?.header?.label ?? ''),
+    relativePosition: f?.relativePosition,
+    fixtureType: f?.associatedElementType,
+    header: {
+      ...f?.header,
+      label: normalizeCadText(f?.header?.label ?? '')
+    },
+    footer: f?.footer,
+    fixtureWidth: f?.fixtureWidth,
+    fixtureLength: f?.fixtureLength,
+    fixtureNumber: f?.fixtureNumber,
+    associatedElementNumber: data?.wallNumber,
+    associatedElementFixtureNumber: data.fixtureNumber,
+    associatedElementType: f?.associatedElementType === 'wall' ? 'wall' : undefined,
+    productBrandName: Array.isArray(f?.productBrandName) ? f?.productBrandName?.map(normalizeCadText) : normalizeCadText(f?.productBrandName),
+
+    fixtureHeight: {
+      value: 0,
+      unit: 'mm',
+    },
+    fixtureStaticLength: {
+      value: 1524,
+      unit: 'mm',
+    },
+    fixtureStaticWidth: {
+      value: 1220,
+      unit: 'mm',
+    },
+    productResolutionLevel: 'L2',
+    isBodyEnabled: true,
+    isMerchEdited: false,
+    isVmEdited: false,
+  };
+}

package/src/controllers/script.controller.js

@@ -9573,8 +9573,8 @@ export async function productMappings( req, res ) {
 
     const { fixtureId, Top, Mid, Bottom } = payload;
 
-    const storeName = 'LKST2681';
-    const storeId = '11-2362';
+    const storeName = 'LKST11';
+    const storeId = '11-259';
     const clientId = '11';
 
     if ( !fixtureId ) {

package/src/controllers/storeBuilder.controller.js

@@ -2792,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, verificationStatus: 1, merchRolloutStatus: 1, vmRolloutStatus: 1 },
+              { floorName: 1, layoutPolygon: 1, planoId: 1, isEdited: 1, planoProgress: 1, updatedAt: 1, verificationStatus: 1, merchRolloutStatus: 1, vmRolloutStatus: 1,cadLayout:1 },
           );
 
           const floorsWithFixtures = await Promise.all(
@@ -5154,8 +5154,8 @@ export async function planoList( req, res ) {
       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.filter.city } } ),
+      ...( 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, storeProfile: 1 } );
 
     let storeDetails = storeList.map( ( ele ) => ele.storeId );
@@ -6095,16 +6095,9 @@ export async function planoList( req, res ) {
     if ( req.body.export ) {
       let exportData = [];
       planoDetails[0].data.forEach( ( ele ) => {
-        let findStore = storeList.find( ( store ) => ele.storeId == store.storeId );
-        if ( findStore ) {
-          ele['country'] = findStore.storeProfile.country;
-          ele['city'] = findStore.storeProfile.city;
-        }
         exportData.push( {
           'Store Name': ele?.storeName ?? '--',
           'Layout Name': ele?.layoutName ?? '--',
-          'Country': ele?.country ?? '--',
-          'City': ele?.City ?? '--',
           'Plano Completion %': ele?.taskDetails.layoutStatus == 'complete' && ele?.taskDetails.fixtureStatus == 'complete' ? 100 : ele?.taskDetails.layoutStatus == 'complete' ? 50 : 25,
           'Layout': ele?.layoutCount ?? 0,
           'Layout Status': ele?.taskDetails.layoutStatus == 'complete' ? 'Completed' : 'Yet to assign',
@@ -6813,8 +6806,8 @@ export async function getRolloutDetails( req, res ) {
       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.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, storeProfile: 1 } );
 
     let storeDetails = storeList.map( ( ele ) => ele.storeId );
@@ -7673,8 +7666,6 @@ export async function getRolloutDetails( req, res ) {
         exportData.push( {
           'Store Name': ele?.storeName ?? '--',
           'Plano Name': ele?.layoutName ?? '--',
-          'Country': ele?.country ?? '--',
-          'city': ele?.city ?? '--',
           'Merch Fixtures': ele?.fixtureCount ?? 0,
           'Merch Status': ele?.taskDetails.fixtureStatus == 'complete' ? 'Completed' : ele?.taskDetails.fixtureStatus == 'pending' ? 'Review Pending' : 'Yet to Assign',
           'Visual Merch': ele?.vmCount ?? 0,
@@ -8464,7 +8455,7 @@ export async function getPlanogramListOld( req, res ) {
 
     return res.sendSuccess( { data, count: total } );
   } catch ( err ) {
-    logger.error( { functionName: 'getPlanogramListOld', error: err } );
+    logger.error( { functionName: 'getLayoutList', error: err } );
     return res.sendError( err, 500 );
   }
 }
@@ -8591,16 +8582,15 @@ export async function getPlanogramList( req, res ) {
           merchCompliance: {
             $floor: [
               {
-                $cond: {
-                  if: { $gt: [ { $ifNull: [ '$productCount', 0 ] }, 0 ] },
-                  then: {
+                $multiply: [
+                  {
                     $divide: [
                       { $ifNull: [ { $arrayElemAt: [ '$complianceCount.count', 0 ] }, 0 ] },
-                      '$productCount',
+                      { $ifNull: [ '$productCount', 1 ] },
                     ],
                   },
-                  else: 0,
-                },
+                  100,
+                ],
               },
             ],
           },
@@ -8693,372 +8683,81 @@ export async function getPlanogramList( req, res ) {
 
     return res.sendSuccess( { data, count: total } );
   } catch ( err ) {
-    logger.error( { functionName: 'getPlanogramList', error: err } );
+    logger.error( { functionName: 'getLayoutList', error: err } );
     return res.sendError( err, 500 );
   }
 }
 
-
-export async function revisionData( req, res ) {
-  try {
-    let storeList = req.body.store;
-    await Promise.all( storeList.map( async ( ele ) => {
-      console.log( ele );
-      req.body = { id: [ ele ] };
-      await convertFixtureStructure( req, res );
-    } ) );
-    return res.sendSuccess( 'Updated Successfully' );
-  } catch ( e ) {
-    logger.error( { functionName: 'revisionData', error: e } );
-    return res.sendError( e, 500 );
-  }
-}
-
-async function convertFixtureStructure( req ) {
+export async function getStoreFloorsList(req, res) {
   try {
-    const planoIds = req.body.id
-        .filter( ( id ) => mongoose.Types.ObjectId.isValid( id ) )
-        .map( ( id ) => new mongoose.Types.ObjectId( id ) );
-
-    const planograms = await planoService.find(
-        {
-          $or: [
-            { _id: { $in: planoIds } },
-            { storeId: { $in: req.body.id } },
-          ],
-        },
-        { storeId: 1, storeName: 1, planoId: '$_id', productResolutionLevel: 1, scanType: 1, clientId: 1, validateShelfSections: 1, layoutName: 1 },
-    );
-
-    if ( !planograms?.length ) return false;
-
-    const currentDate = new Date( dayjs().format( 'YYYY-MM-DD' ) );
-
-    await Promise.all(
-        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, merchRolloutStatus: 1, vmRolloutStatus: 1 },
-          );
-
-          await Promise.all(
-              floors.map( async ( floor, index ) => {
-                let fixtureCount = 0;
-                let totalVmCount = 0;
-                let productCapacity = 0;
-                const masterTemplateIds = new Set();
-                const layoutPolygonWithFixtures = await Promise.all(
-                    floor.layoutPolygon.map( async ( element ) => {
-                      const fixtures = await storeFixtureService.findAndSort( {
-                        floorId: floor._id,
-                        associatedElementType: element.elementType,
-                        associatedElementNumber: element.elementNumber,
-                        fixtureType: { $ne: 'other' },
-                      }, { shelfcount: 0 }, { associatedElementFixtureNumber: 1 } );
-
-                      const fixturesWithStatus = await Promise.all(
-                          fixtures.map( async ( fixture ) => {
-                            if ( fixture?.masterTemplateId && mongoose.Types.ObjectId.isValid( fixture?.masterTemplateId ) ) {
-                              masterTemplateIds.add( fixture?.masterTemplateId );
-                            }
-                            if ( fixture?.imageUrl ) {
-                              let params = {
-                                Bucket: JSON.parse( process.env.BUCKET ).storeBuilder,
-                                file_path: fixture.imageUrl,
-                              };
-                              fixture.imageUrl = await signedUrl( params );
-                            } else {
-                              fixture.imageUrl = '';
-                            }
-                            productCapacity += fixture.toObject().fixtureCapacity;
-                            fixtureCount += 1;
-                            const productCount = await planoMappingService.count( { fixtureId: fixture._id, type: 'product' } );
-
-                            const vmCount = await planoMappingService.count( { fixtureId: fixture._id, type: 'vm' } );
-
-                            const complianceCount = await planoComplianceService.count( {
-                              fixtureId: fixture._id,
-                              compliance: 'proper',
-                              date: currentDate,
-                            } );
-
-                            const shelves = await fixtureShelfService.findAndSort( { fixtureId: fixture._id }, { }, { shelfNumber: 1 } );
-
-                            const shelfDetails = await Promise.all(
-                                shelves.map( async ( shelf ) => {
-                                  const productDetails = await planoMappingService.find( { fixtureId: fixture._id, shelfId: shelf._id, type: 'product' }, { _id: 1 } );
-                                  let productIdList = productDetails.map( ( ele ) => ele._id );
-                                  let complianceQuery = [
-                                    {
-                                      $match: {
-                                        fixtureId: fixture._id,
-                                        shelfId: shelf._id,
-                                        date: currentDate,
-                                        planoMappingId: { $in: productIdList },
-                                      },
-                                    },
-                                    {
-                                      $group: {
-                                        _id: '$createdAt',
-                                        status: { $push: '$compliance' },
-                                      },
-                                    },
-                                    {
-                                      $sort: { _id: -1 },
-                                    },
-                                    {
-                                      $limit: 1,
-                                    },
-                                  ];
-                                  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' } );
-
-                                  return {
-                                    ...shelf.toObject(),
-                                    productCount: productDetails.length,
-                                    vmCount: vmCount,
-                                    compliance,
-                                  };
-                                } ),
-                            );
-
-                            let fixtureStatus;
-
-                            const cvProcessStatus = await planoQrConversionRequestService.count( { fixtureId: fixture._id, date: currentDate, status: 'initiated' } );
-
-                            if ( cvProcessStatus ) {
-                              fixtureStatus = 'inprogress';
-                            } else {
-                              const missingCount = await planoComplianceService.count( {
-                                fixtureId: fixture._id,
-                                compliance: 'missing',
-                                date: currentDate,
-                              } );
-                              fixtureStatus = complianceCount === 0 && !missingCount ? '' : complianceCount === productCount ? 'complete' : 'incomplete';
-                            }
-
-
-                            const vmDetails = await Promise.all( fixture.toObject()?.vmConfig?.map( async ( vm ) => {
-                              totalVmCount += 1;
-                              const vmInfo = await planoVmService.findOne( { _id: vm.vmId } );
-                              return {
-                                ...vm,
-                                ...vmInfo?.toObject(),
-                              };
-                            } ) );
-
-                            return {
-                              ...fixture.toObject(),
-                              status: fixtureStatus,
-                              shelfCount: shelves.length,
-                              productCount: productCount,
-                              vmCount: vmCount,
-                              shelfConfig: shelfDetails,
-                              vmConfig: vmDetails,
-                            };
-                          } ),
-                      );
-
-                      const otherElements = await storeFixtureService.find( {
-                        floorId: floor._id,
-                        associatedElementType: element.elementType,
-                        associatedElementNumber: element.elementNumber,
-                        fixtureType: 'other',
-                      } );
-
-                      return {
-                        ...element,
-                        fixtures: fixturesWithStatus,
-                        otherElements: otherElements,
-                      };
-                    } ),
-                );
-
-                const centerFixtures = await storeFixtureService.findAndSort( {
-                  floorId: floor._id,
-                  $and: [
-                    { associatedElementType: { $exists: false } },
-                    { associatedElementNumber: { $exists: false } },
-                    { fixtureType: { $ne: 'other' } },
-                  ],
-                }, { shelfcount: 0 }, { associatedElementFixtureNumber: 1 } );
-
-
-                const centerFixturesWithStatus = await Promise.all(
-                    centerFixtures.map( async ( fixture ) => {
-                      if ( fixture?.masterTemplateId && mongoose.Types.ObjectId.isValid( fixture?.masterTemplateId ) ) {
-                        masterTemplateIds.add( fixture?.masterTemplateId );
-                      }
-                      if ( fixture?.imageUrl ) {
-                        let params = {
-                          Bucket: JSON.parse( process.env.BUCKET ).storeBuilder,
-                          file_path: fixture.imageUrl,
-                        };
-                        fixture.imageUrl = await signedUrl( params );
-                      } else {
-                        fixture.imageUrl = '';
-                      }
-                      productCapacity += fixture.toObject().fixtureCapacity;
-                      fixtureCount += 1;
-                      const productCount = await planoMappingService.count( { fixtureId: fixture._id, type: 'product' } );
-
-                      const vmCount = await planoMappingService.count( { fixtureId: fixture._id, type: 'vm' } );
-
-                      const complianceCount = await planoComplianceService.count( {
-                        fixtureId: fixture._id,
-                        compliance: 'proper',
-                        date: currentDate,
-                      } );
-
-                      const shelves = await fixtureShelfService.findAndSort( { fixtureId: fixture._id }, { }, { shelfNumber: 1 } );
-
-                      const shelfDetails = await Promise.all(
-                          shelves.map( async ( shelf ) => {
-                            const productDetails = await planoMappingService.find( { fixtureId: fixture._id, shelfId: shelf._id, type: 'product' }, { _id: 1 } );
-                            let productIdList = productDetails.map( ( ele ) => ele._id );
-                            let complianceQuery = [
-                              {
-                                $match: {
-                                  fixtureId: fixture._id,
-                                  shelfId: shelf._id,
-                                  date: currentDate,
-                                  planoMappingId: { $in: productIdList },
-                                },
-                              },
-                              {
-                                $group: {
-                                  _id: '$createdAt',
-                                  status: { $push: '$compliance' },
-                                },
-                              },
-                              {
-                                $sort: { _id: -1 },
-                              },
-                              {
-                                $limit: 1,
-                              },
-                            ];
-                            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' } );
-
-                            return {
-                              ...shelf.toObject(),
-                              productCount: productDetails.length,
-                              vmCount: vmCount,
-                              compliance,
-                            };
-                          } ),
-                      );
-
-                      let fixtureStatus;
-
-                      const cvProcessStatus = await planoQrConversionRequestService.count( { fixtureId: fixture._id, date: currentDate, status: 'initiated' } );
-
-                      if ( cvProcessStatus ) {
-                        fixtureStatus = 'inprogress';
-                      } else {
-                        const missingCount = await planoComplianceService.count( {
-                          fixtureId: fixture._id,
-                          compliance: 'missing',
-                          date: currentDate,
-                        } );
-                        fixtureStatus = complianceCount === 0 && !missingCount ? '' : complianceCount === productCount ? 'complete' : 'incomplete';
-                      }
-
-
-                      const vmDetails = await Promise.all( fixture.toObject().vmConfig.map( async ( vm ) => {
-                        totalVmCount += 1;
-                        const vmInfo = await planoVmService.findOne( { _id: vm.vmId } );
 
-                        return {
-                          ...vm,
-                          ...vmInfo?.toObject(),
-                        };
-                      } ) );
-
-                      return {
-                        ...fixture.toObject(),
-                        status: fixtureStatus,
-                        shelfCount: shelves.length,
-                        productCount: productCount,
-                        vmCount: vmCount,
-                        shelfConfig: shelfDetails,
-                        vmConfig: vmDetails,
-                      };
-                    } ),
-                );
+    const { storeId } = req.query;
 
+    if (!storeId) {
+      return res.sendError('storeId is required');
+    }
 
-                const otherElements = await storeFixtureService.find( {
-                  floorId: floor._id,
-                  associatedElementType: { $exists: false },
-                  associatedElementNumber: { $exists: false },
-                  fixtureType: 'other',
-                } );
+    const query = [
+      {
+        $match: {
+          storeId: storeId
+        }
+      },
+      {
+        $lookup: {
+          from: "storelayouts",
+          let: { planoId: "$_id" },
+          pipeline: [
+            {
+              $match: {
+                $expr: { $eq: ["$planoId", "$$planoId"] }
+              }
+            },
+            {
+              $project: {
+                _id: 1,
+                floorNumber: 1,
+                floorName: 1
+              }
+            }
+          ],
+          as: "floors"
+        }
+      },
+      {
+        $project: {
+          _id: 0,
+          floors: 1
+        }
+      }
+    ]
 
 
-                let masterTempArr = [ ...masterTemplateIds ];
+    const floorsRes = await planoService.aggregate(query);
 
+    return res.sendSuccess(floorsRes?.[0]?.floors ?? []);
 
-                if ( masterTempArr?.length && req.body?.treeView ) {
-                  masterTempArr = await fixtureConfigService.find( { _id: { $in: [ ...masterTemplateIds ] } } );
-                }
+  } catch (e) {
+    logger.error({ functionName: 'getStoreFloorsList', error: e });
+    return res.sendError(e, 500);
+  }
+}
 
-                let floorData = {
-                  ...floor.toObject(),
-                  updatedAt: dayjs( floor?.updatedAt ).format( 'Do MMM YYYY' ),
-                  fixtureCount: fixtureCount,
-                  vmCount: totalVmCount,
-                  layoutPolygon: layoutPolygonWithFixtures,
-                  centerFixture: centerFixturesWithStatus,
-                  otherElements: otherElements,
-                  lastUpdate: dayjs( floor?.updatedAt ).format( 'Do MMMM YYYY hh:mm A' ),
-                  ...( floors.length > 1 ) ? { floorNum: `Floor ${index + 1}/${floors.length}` } : { floorNum: 'Floor 1' },
-                };
+export async function getAllStores(req, res) {
+  try {
 
-                let planoProductCount = 0;
-                layoutPolygonWithFixtures.forEach( ( poly ) => {
-                  poly.fixtures.forEach( ( fixt ) => {
-                    planoProductCount += fixt.fixtureCapacity;
-                  } );
-                } );
+    const { clientId } = req.query;
 
-                centerFixturesWithStatus.forEach( ( fixt ) => {
-                  planoProductCount += fixt.fixtureCapacity;
-                } );
+    if (!clientId) {
+      return res.sendError('clientId is required', 400);
+    }
 
-                floorData = { ...floorData, planoProductCount };
-
-                const data = {
-                  storeName: planogram.storeName,
-                  storeId: planogram.storeId,
-                  clientId: planogram.clientId,
-                  planoId: planogram._id,
-                  productResolutionLevel: planogram.productResolutionLevel,
-                  scanType: planogram.scanType,
-                  createdByName: 'Bejan',
-                  createdByEmail: 'Bejan@tangotech.co.in',
-                  createdBy: new mongoose.Types.ObjectId( '66a78cd82734f4f857cd6db6' ),
-                  layoutName: planogram.layoutName,
-                  floorId: floorData._id,
-                  floorData: floorData,
-                };
+    const storeRes = await storeService.find({ clientId: clientId, status: 'active' }, { storeId: 1, storeName: 1, _id: 0 })
 
-                console.log( data, 'data' );
+    return res.sendSuccess(storeRes);
 
-                await planoRevisionService.create( data );
-              } ),
-          );
-        } ),
-    );
-  } catch ( e ) {
-    console.log( e );
-    logger.error( { functionName: 'storeFixturesv2', error: e, message: req.body } );
-    return e;
+  } catch (e) {
+    logger.error({ functionName: 'getAllStores', error: e });
+    return res.sendError(e, 500);
   }
 }

package/src/routes/managePlano.routes.js

@@ -6,25 +6,26 @@ import { isAllowedSessionHandler } from 'tango-app-api-middleware';
 export const managePlanoRouter = express.Router();
 
 managePlanoRouter
-    .post( '/updateStorePlano', isAllowedSessionHandler, managePlanoController.updateStorePlano )
-    .post( '/getplanoFeedback', isAllowedSessionHandler, managePlanoController.getplanoFeedback )
-    .post( '/getplanoFeedbackv1', isAllowedSessionHandler, managePlanoController.getplanoFeedbackv1 )
-    .post( '/getStoreFixturesfeedback', isAllowedSessionHandler, managePlanoController.getStoreFixturesfeedback )
-    .get( '/fixtureList', isAllowedSessionHandler, managePlanoController.fixtureList )
-    .get( '/templateList', isAllowedSessionHandler, managePlanoController.templateList )
-    .get( '/fixtureBrandsList', isAllowedSessionHandler, managePlanoController.fixtureBrandsList )
-    .get( '/fixtureVMList', isAllowedSessionHandler, managePlanoController.fixtureVMList )
-    .get( '/fixtureVMListv1', isAllowedSessionHandler, managePlanoController.fixtureVMListv1 )
-    .post( '/updateFixtureStatus', isAllowedSessionHandler, managePlanoController.updateFixtureStatus )
-    .post( '/updateApprovalStatus', isAllowedSessionHandler, managePlanoController.updateApprovalStatus )
-    .post( '/updateStoreFixture', isAllowedSessionHandler, managePlanoController.updateStoreFixture )
-    .post( '/updateredostatus', isAllowedSessionHandler, managePlanoController.updateredostatus )
-    .post( '/updateGlobalComment', isAllowedSessionHandler, managePlanoController.updateGlobalComment )
-    .post( '/getGlobalComment', isAllowedSessionHandler, managePlanoController.getGlobalComment )
-    .post( '/createRevision', isAllowedSessionHandler, managePlanoController.createPlanoRevision )
-    .post( '/getRevisions', isAllowedSessionHandler, managePlanoController.getAllPlanoRevisions )
-    .post( '/getRevisionData', isAllowedSessionHandler, managePlanoController.getPlanoRevisionById )
-    .post( '/getRolloutFeedback', isAllowedSessionHandler, managePlanoController.getRolloutFeedback )
-    .post( '/getRolloutFeedbackv2', isAllowedSessionHandler, managePlanoController.getRolloutFeedbackv2 )
-    .post( '/updateRolloutStatus', isAllowedSessionHandler, managePlanoController.updateRolloutStatus )
-    .post( '/getPlanoStoreVideoParams', isAllowedSessionHandler, managePlanoController.getPlanoStoreVideoPageParams );
+    .post('/updateStorePlano', isAllowedSessionHandler, managePlanoController.updateStorePlano)
+    .post('/getplanoFeedback', isAllowedSessionHandler, managePlanoController.getplanoFeedback)
+    .post('/getplanoFeedbackv1', isAllowedSessionHandler, managePlanoController.getplanoFeedbackv1)
+    .post('/getStoreFixturesfeedback', isAllowedSessionHandler, managePlanoController.getStoreFixturesfeedback)
+    .get('/fixtureList', isAllowedSessionHandler, managePlanoController.fixtureList)
+    .get('/templateList', isAllowedSessionHandler, managePlanoController.templateList)
+    .get('/fixtureBrandsList', isAllowedSessionHandler, managePlanoController.fixtureBrandsList)
+    .get('/fixtureVMList', isAllowedSessionHandler, managePlanoController.fixtureVMList)
+    .get('/fixtureVMListv1', isAllowedSessionHandler, managePlanoController.fixtureVMListv1)
+    .post('/updateFixtureStatus', isAllowedSessionHandler, managePlanoController.updateFixtureStatus)
+    .post('/updateApprovalStatus', isAllowedSessionHandler, managePlanoController.updateApprovalStatus)
+    .post('/updateStoreFixture', isAllowedSessionHandler, managePlanoController.updateStoreFixture)
+    .post('/updateredostatus', isAllowedSessionHandler, managePlanoController.updateredostatus)
+    .post('/updateGlobalComment', isAllowedSessionHandler, managePlanoController.updateGlobalComment)
+    .post('/getGlobalComment', isAllowedSessionHandler, managePlanoController.getGlobalComment)
+    .post('/createRevision', isAllowedSessionHandler, managePlanoController.createPlanoRevision)
+    .post('/getRevisions', isAllowedSessionHandler, managePlanoController.getAllPlanoRevisions)
+    .post('/getRevisionData', isAllowedSessionHandler, managePlanoController.getPlanoRevisionById)
+    .post('/getRolloutFeedback', isAllowedSessionHandler, managePlanoController.getRolloutFeedback)
+    .post('/getRolloutFeedbackv2', isAllowedSessionHandler, managePlanoController.getRolloutFeedbackv2)
+    .post('/updateRolloutStatus', isAllowedSessionHandler, managePlanoController.updateRolloutStatus)
+    .post('/getPlanoStoreVideoParams', isAllowedSessionHandler, managePlanoController.getPlanoStoreVideoPageParams)
+    .post('/createPlanoFromCAD', isAllowedSessionHandler, managePlanoController.createPlanoFromCAD);

package/src/routes/storeBuilder.routes.js

@@ -69,5 +69,6 @@ storeBuilderRouter
     .post( '/updateProductMapping', storeBuilderController.updateProductMapping )
     .post( '/calculateCompliance', isAllowedSessionHandler, storeBuilderController.calculateCompliance )
     .post( '/getPlanogramList', isAllowedSessionHandler, storeBuilderController.getPlanogramList )
-    .post( '/revisionUpdate', storeBuilderController.revisionData )
+    .get('/getAllStores', isAllowedSessionHandler, storeBuilderController.getAllStores)
+    .get('/getStoreFloorsList', isAllowedSessionHandler, storeBuilderController.getStoreFloorsList)
 ;