tango-app-api-store-builder 1.0.0-beta-86 → 1.0.0-beta-87

package/src/controllers/script.controller.js

@@ -9,6 +9,7 @@ import * as fixtureShelfService from '../service/fixtureShelf.service.js';
 import * as planoProductService from '../service/planoProduct.service.js';
 import * as planoMappingService from '../service/planoMapping.service.js';
 import * as planoTaskService from '../service/planoTask.service.js';
+import * as processedTaskService from '../service/processedTaskservice.js';
 // import * as planoComplianceService from '../service/planoCompliance.service.js';
 // import * as planoTaskComplianceService from '../service/planoTask.service.js';
 // import * as planoQrConversionRequestService from '../service/planoQrConversionRequest.service.js';
@@ -18,7 +19,6 @@ import JSZip from 'jszip';
 import { signedUrl } from 'tango-app-api-middleware';
 import fs from 'fs';
 import https from 'https';
-import dayjs from 'dayjs';
 import os from 'os';
 import { fileURLToPath } from 'url';
 import path from 'path';
@@ -4216,35 +4216,36 @@ export async function downloadPlanoImage( req, res ) {
           const targetPath = path.join( targetFolder, file );
           if ( storeList.includes( fileName ) ) {
             if ( fs.existsSync( sourcePath ) ) {
-              let chckFixtureCount = await storeFixtureService.findAndSort( { storeName: fileName }, { associatedElementFixtureNumber: 1 }, { associatedElementFixtureNumber: -1 } );
-              console.log( chckFixtureCount[0].associatedElementFixtureNumber );
-              if ( chckFixtureCount[0].associatedElementFixtureNumber < 10 ) {
-                sharp( sourcePath )
-                    .extract( { left: 1200, top: 30, width: 3800, height: 3200 } )
-                    .toFile( targetPath )
-                    .then( () => {
-                      fs.unlinkSync( sourcePath );
-                      console.log( 'Image cropped successfully!' );
-                    } )
-                    .catch( ( err ) => {
-                      console.error( 'Error cropping image:', err );
-                    } );
-              } else {
-                fs.copyFile( sourcePath, targetPath, ( err ) => {
-                  if ( err ) {
-                    fs.unlinkSync( sourcePath );
-                    console.error( 'Error copying file:', err );
-                  } else {
-                    console.log( `File moved from Downloads to ${targetFolder}` );
-                  }
-                } );
-              }
+              // let chckFixtureCount = await storeFixtureService.findAndSort( { storeName: fileName }, { associatedElementFixtureNumber: 1 }, { associatedElementFixtureNumber: -1 } );
+              // console.log( chckFixtureCount[0].associatedElementFixtureNumber );
+              // if ( chckFixtureCount[0].associatedElementFixtureNumber < 10 ) {
+              //   sharp( sourcePath )
+              //       .extract( { left: 1200, top: 30, width: 3800, height: 3200 } )
+              //       .toFile( targetPath )
+              //       .then( () => {
+              //         fs.unlinkSync( sourcePath );
+              //         console.log( 'Image cropped successfully!' );
+              //       } )
+              //       .catch( ( err ) => {
+              //         console.error( 'Error cropping image:', err );
+              //       } );
+              // } else {
+              fs.copyFile( sourcePath, targetPath, ( err ) => {
+                if ( err ) {
+                  console.error( 'Error copying file:', err );
+                } else {
+                  fs.unlinkSync( sourcePath );
+                  console.log( `File moved from Downloads to ${targetFolder}` );
+                }
+              } );
+              // }
             } else {
               console.warn( 'File not found in Downloads:', fileName );
             }
           }
         }
       } );
+      return res.sendSuccess( 'Image Generated SuccessFully' );
     }
 
     if ( req.body?.merge ) {
@@ -4253,12 +4254,13 @@ export async function downloadPlanoImage( req, res ) {
         fs.mkdirSync( targetFolder, { recursive: true } );
         console.log( 'Created folder:', targetFolder );
       }
+      let spacing = 500;
       for ( let store of storeList ) {
         if ( store != undefined ) {
           const image1 = path.join( __dirname, '..', '..', `oldImages/${store}.png` );
           const image2 = path.join( __dirname, '..', '..', `newImages/${store}.png` );
 
-          const output = path.join( __dirname, '..', '..', `mergedImages/${store}merged.png` );
+          const output = path.join( targetFolder, `/${store}.png` );
 
 
           const [ img1, img2 ] = await Promise.all( [
@@ -4268,7 +4270,7 @@ export async function downloadPlanoImage( req, res ) {
 
           const [ meta1, meta2 ] = await Promise.all( [ img1.metadata(), img2.metadata() ] );
 
-          const canvasWidth = meta1.width + meta2.width;
+          const canvasWidth = meta1.width + meta2.width + spacing;
           const canvasHeight = Math.max( meta1.height, meta2.height );
 
           const [ img1Buffer, img2Buffer ] = await Promise.all( [
@@ -4280,23 +4282,2447 @@ export async function downloadPlanoImage( req, res ) {
             create: {
               width: canvasWidth,
               height: canvasHeight,
-              channels: 3,
+              channels: 4,
               background: { r: 255, g: 255, b: 255 },
             },
           } )
               .composite( [
                 { input: img1Buffer, top: 0, left: 0 },
-                { input: img2Buffer, top: 0, left: meta1.width },
+                { input: img2Buffer, top: 0, left: meta1.width + spacing },
               ] )
               .toFile( output );
 
           console.log( 'Images merged successfully!' );
         }
       }
+      let zip = new JSZip;
+      const promises = storeList.map( async ( store ) => {
+        try {
+          const file = fs.readFileSync( `${targetFolder}/${store}.png` );
+          zip.file( `${store}.png`, file );
+        } catch ( err ) {
+          console.error( `Error reading ${store}.png:`, err );
+        }
+      } );
+
+      await Promise.all( promises );
+
+      const zipBuffer = await zip.generateAsync( { type: 'nodebuffer' } );
+
+      res.set( {
+        'Content-Type': 'application/zip',
+        'Content-Disposition': 'attachment; filename=download.zip',
+      } );
+
+      let rmFolderList = [ 'oldImages', 'newImages', 'mergedImages' ];
+      for ( let folder of rmFolderList ) {
+        const filePath = path.join( __dirname, '..', '..', folder );
+        fs.rm( filePath, { recursive: true, force: true } );
+      }
+
+      return res.send( zipBuffer );
     }
-    return res.sendSuccess( 'Image Generated SuccessFully' );
   } catch ( e ) {
     console.log( e );
     return res.sendError( e, 500 );
   }
 }
+
+
+export async function updateCrestPlanogram( req, res ) {
+  try {
+    if ( req?.headers?.authorization?.split( ' ' )[1] !== 'hwjXfCD6TgMvc82cuSGZ9bNv9MuXsaiQ6uvx' ) {
+      return res.sendError( 'Unauthorized', 401 );
+    }
+
+    const startTime = Date.now();
+
+    const layoutApiUrl = 'https://api.getcrest.ai/api/ms_shelfsensei/layout/';
+    let staticToken = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ0b2tlbl90eXBlIjoiYWNjZXNzIiwiZXhwIjoxNzQ1NTE3MjQxLCJpYXQiOjE3NDU1MTM2NDEsImp0aSI6Ijg3MWVlNTA3ODY2OTQ5OTVhMTQ0YTk4NzQyNzY0MzEzIiwidXNlcl9pZCI6MTA4NSwiaWQiOjEwODUsImlzX21lZXNlZWtfYWNjb3VudCI6ZmFsc2UsImN1c3RvbWVyX2dyb3VwIjozOTgsImxpY2VuY2Vfc2NvcGVzIjpbeyJyZXNvdXJjZV9zZXQiOiJwcF9zZXQiLCJzY29wZV9yb2xlIjoiY29udHJpYnV0b3IifSx7InJlc291cmNlX3NldCI6ImRwX3NldCIsInNjb3BlX3JvbGUiOiJjb250cmlidXRvciJ9LHsicmVzb3VyY2Vfc2V0IjoiZGZfc2V0Iiwic2NvcGVfcm9sZSI6ImNvbnRyaWJ1dG9yIn0seyJyZXNvdXJjZV9zZXQiOiJkZWZhdWx0X3NldCIsInNjb3BlX3JvbGUiOiJjb250cmlidXRvciJ9XX0.eGzTMGwwstr13M0Hu1Ls5-gkE_oSPMJJBL2wgygT6Ac';
+
+    async function fetchStoreData( store, bearerToken, res ) {
+      const payload = JSON.stringify( { store_id: store.toObject().storeName } );
+
+      try {
+        const response = await fetch( layoutApiUrl, {
+          method: 'POST',
+          headers: {
+            'Authorization': `Bearer ${bearerToken}`,
+            'Content-Type': 'application/json',
+            'Content-Length': Buffer.byteLength( payload ),
+          },
+          body: payload,
+        } );
+
+        const data = await response.text();
+        let jsonData = null;
+
+        try {
+          jsonData = JSON.parse( data );
+        } catch ( parseError ) {
+          logger.error( { functionName: `Warning: Received invalid JSON for store ${store.toObject().storeName}`, error: parseError } );
+          console.warn( `Warning: Received invalid JSON for store ${store.toObject().storeName}` );
+          return { storeName: store.toObject().storeName, data: null };
+        }
+
+        if ( jsonData.result === 'Token is invalid or expired' ) {
+          console.log( 'Token expired, retrying...' );
+          try {
+            const newToken = await fetchNewToken();
+            staticToken = newToken;
+            return await fetchStoreData( store, newToken, res );
+          } catch ( retryError ) {
+            logger.error( { functionName: 'Failed to refresh token', error: retryError } );
+            console.log( retryError );
+            return res.sendError( 'Failed to refresh token', 401 );
+          }
+        }
+
+        return { storeName: store.toObject().storeName, data: jsonData };
+      } catch ( error ) {
+        logger.error( { functionName: `Error fetching data for ${store.toObject().storeName}:`, error } );
+        console.error( `Error fetching data for ${store.toObject().storeName}:`, error.message );
+        return { storeName: store.toObject().storeName, data: null };
+      }
+    }
+
+
+    const fetchNewToken = async () => {
+      const fetchWithCookies = fetchCookie( fetch );
+
+      const email = 'tango.lenskart@getcrest.ai';
+      const password = 'Tangolenskart@123';
+
+      const credentials = JSON.stringify( { email, password } );
+
+      const invalidateUrl = 'https://app.getcrest.ai/api/ms_iam/user/session/override/';
+      const tokenUrl = 'https://app.getcrest.ai/api/ms_iam/token/';
+
+      try {
+        const invalidateRes = await fetchWithCookies( invalidateUrl, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+          },
+          body: credentials,
+        } );
+
+        const invalidateData = await invalidateRes.json();
+        console.log( 'Invalidate response:', invalidateData );
+
+        console.log( 'Fetching new token...' );
+        const tokenRes = await fetchWithCookies( tokenUrl, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            'Accept': 'application/json, text/javascript, */*; q=0.01',
+          },
+          body: credentials,
+        } );
+
+        const tokenData = await tokenRes.json();
+        console.log( 'Token response:', tokenData );
+
+        return tokenData.access;
+      } catch ( error ) {
+        console.error( 'Error fetching new token:', error );
+        throw error;
+      }
+    };
+
+    let storeList = await storeService.find( { ...( req?.body?.storeName ) ? { storeName: req?.body?.storeName } : {}, clientId: '11' } );
+
+    const constantFixtureLength = 1220;
+    const constantDetailedFixtureLength = 1220;
+
+    const constantFixtureWidth = 610;
+    const constantDetailedFixtureWidth = 1524;
+
+    const mmToFeet = 305;
+
+    function roundToTwo( num ) {
+      return Math.round( num * 100 ) / 100;
+    }
+
+    for ( let i = 0; i < storeList.length; i++ ) {
+      const storeData = await fetchStoreData( storeList[i], staticToken, res );
+
+      if ( storeData?.data?.message !== 'SUCCESS' ) continue;
+
+      const storeDetails = storeList[i];
+
+      const existingPlanogram = await planoService.findOne( { storeName: storeData.storeName } );
+
+      if ( existingPlanogram ) {
+        const checkTaskSubmitted = await planoTaskService.findOne( { planoId: existingPlanogram.toObject()._id } );
+
+        const checkTaskCreated = await processedTaskService.findOne( { storeName: storeData.storeName, date_iso: { $gte: new Date( ), $lte: new Date( ) }, isPlano: true } );
+
+        if ( checkTaskSubmitted || checkTaskCreated ) {
+          continue;
+        }
+      }
+
+
+      if ( existingPlanogram?.toObject()?._id && mongoose.Types.ObjectId.isValid( existingPlanogram?.toObject()?._id ) ) {
+        await Promise.all( [ planoService.deleteOne( { _id: existingPlanogram?.toObject()?._id } ), storeBuilderService.deleteOne( { planoId: existingPlanogram?.toObject()?._id } ),
+          storeFixtureService.deleteMany( { planoId: existingPlanogram?.toObject()?._id } ), fixtureShelfService.deleteMany( { planoId: existingPlanogram?.toObject()?._id } ),
+          planoMappingService.deleteMany( { planoId: existingPlanogram?.toObject()?._id } ),
+        ] );
+      }
+
+
+      const planoInsertData = {
+        storeName: storeData.storeName,
+        storeId: storeDetails?.toObject()?.storeId ? storeDetails.toObject().storeId : 'nil',
+        layoutName: `${storeData.storeName} - Layout`,
+        clientId: '11',
+        attachments: [],
+        createdBy: new mongoose.Types.ObjectId( '66a78cd82734f4f857cd6db6' ),
+        createdByName: 'Bejan',
+        createdByEmail: 'bejan@tangotech.co.in',
+        status: 'completed',
+        floorNumber: 1,
+        productResolutionLevel: 'L2',
+        scanType: 'qr',
+      };
+
+      const insertedPlano = await planoService.upsertOne( { storeName: storeData.storeName }, planoInsertData );
+      const planoDoc = insertedPlano.toObject();
+
+      const leftWall = storeData.data.result.filter( ( entry ) => entry['main'] === 'LEFT WALL' );
+      const leftFixtures = leftWall.flatMap( ( wall ) => wall.fixtures );
+      const rightWall = storeData.data.result.filter( ( entry ) => entry['main'] === 'RIGHT WALL' );
+      const rightFixtures = rightWall.flatMap( ( wall ) => wall.fixtures );
+      const backWall = storeData.data.result.filter( ( entry ) => entry['main'] === 'RIGHT VERTICAL WALL' );
+      const backFixtures = backWall.flatMap( ( wall ) => wall.fixtures );
+      const floorFixtures = storeData.data.result.filter(
+          ( entry ) => entry['main'] === 'Euro Center' || entry['main'] === 'Euro Center Dr',
+      );
+
+      const leftXDistanceFeet = leftFixtures.length ? roundToTwo( ( leftFixtures.length * ( constantFixtureLength / mmToFeet ) ) ) : 0;
+      const leftXDetailedDistanceFeet = leftFixtures.length ? roundToTwo( ( leftFixtures.length * ( constantDetailedFixtureLength / mmToFeet ) ) ) : 0;
+
+      const leftYDistanceFeet = leftFixtures.length ? roundToTwo( ( ( constantFixtureWidth / mmToFeet ) ) ) : 0;
+      const leftYDetailedDistanceFeet = leftFixtures.length ? roundToTwo( ( ( constantDetailedFixtureWidth / mmToFeet ) ) ) : 0;
+
+      const rightXDistanceFeet = rightFixtures.length ? roundToTwo( ( rightFixtures.length * ( constantFixtureLength / mmToFeet ) ) ) : 0;
+      const rightXDetailedDistanceFeet = rightFixtures.length ? roundToTwo( ( rightFixtures.length * ( constantDetailedFixtureLength / mmToFeet ) ) ) : 0;
+
+      const rightYDistanceFeet = rightFixtures.length ? roundToTwo( ( constantFixtureWidth / mmToFeet ) ) : 0;
+      const rightYDetailedDistanceFeet = rightFixtures.length ? roundToTwo( ( constantDetailedFixtureWidth / mmToFeet ) ): 0;
+
+      const maxFixturesPerRow = floorFixtures.length/2;
+      const totalRows = 2;
+
+      const floorXDistanceFeet = floorFixtures.length ? roundToTwo( ( ( floorFixtures.length/2 ) * ( constantFixtureLength / mmToFeet ) ) ) : 0;
+      const floorXDetailedDistanceFeet = floorFixtures.length ? roundToTwo( ( ( floorFixtures.length/2 ) * ( constantDetailedFixtureLength / mmToFeet ) ) ): 0;
+
+      const floorYDistanceFeet = floorFixtures.length ? roundToTwo( ( 2 * ( constantFixtureWidth/ mmToFeet ) ) ): 0;
+      const floorYDetailedDistanceFeet = floorFixtures.length ? roundToTwo( 2 * ( constantDetailedFixtureWidth/mmToFeet ) ): 0;
+
+      const backXDistanceFeet = backFixtures.length ? roundToTwo( ( constantFixtureWidth / mmToFeet ) ) : 0;
+      const backXDetailedDistanceFeet = backFixtures.length ? roundToTwo( ( constantDetailedFixtureLength / mmToFeet ) ) : 0;
+
+      const backYDistanceFeet = backFixtures.length ? roundToTwo( ( ( backFixtures.length * ( constantFixtureLength / mmToFeet ) ) + ( ( ( leftFixtures.length ? 1 : 0 ) + ( rightFixtures.length ? 1 : 0 ) * constantFixtureWidth )/mmToFeet ) ) ) : 0;
+      const backYDetailedDistanceFeet = backFixtures.length ? roundToTwo( ( ( backFixtures.length * ( constantDetailedFixtureWidth / mmToFeet ) ) + ( ( ( leftFixtures.length ? 1 : 0 ) + ( rightFixtures.length ? 1 : 0 ) * constantDetailedFixtureWidth )/mmToFeet ) ) ): 0;
+
+      const maxXDistance = Math.max( leftXDistanceFeet, rightXDistanceFeet, floorXDistanceFeet );
+      const maxXDetailedDistance = Math.max( leftXDetailedDistanceFeet, rightXDetailedDistanceFeet, floorXDetailedDistanceFeet );
+
+      const maxYDistance = Math.max( floorYDistanceFeet, backYDistanceFeet );
+      const maxYDetailedDistance = Math.max( floorYDetailedDistanceFeet, backYDetailedDistanceFeet );
+
+      const finalXDistance = roundToTwo( ( maxXDistance < ( backXDistanceFeet + floorXDistanceFeet )? ( ( backXDistanceFeet + floorXDistanceFeet ) + ( ( 2 * constantFixtureLength )/mmToFeet ) ) : ( floorFixtures.length && backFixtures.length ) ? ( maxXDistance + ( ( 2 * constantFixtureLength )/mmToFeet ) ) : maxXDistance ) );
+      const finalXDetailedDistance = roundToTwo( ( maxXDetailedDistance < ( backXDetailedDistanceFeet + floorXDetailedDistanceFeet )? ( ( backXDetailedDistanceFeet + floorXDetailedDistanceFeet ) + ( ( 2 * constantDetailedFixtureLength )/mmToFeet ) ) : ( floorFixtures.length && backFixtures.length ) ? ( maxXDetailedDistance + ( ( 2 * constantDetailedFixtureLength )/mmToFeet ) ) : maxXDetailedDistance ) );
+
+      const finalYDistance = roundToTwo( ( maxYDistance < ( leftYDistanceFeet + rightYDistanceFeet + floorYDistanceFeet ) ? ( ( leftYDistanceFeet + rightYDistanceFeet + floorYDistanceFeet ) + ( ( 2 * constantFixtureWidth )/mmToFeet ) ) : ( maxYDistance + ( ( constantFixtureWidth )/mmToFeet ) ) ) );
+      const finalYDetailedDistance = roundToTwo( ( maxYDetailedDistance < ( leftYDetailedDistanceFeet + rightYDetailedDistanceFeet + floorYDetailedDistanceFeet ) ? ( ( leftYDetailedDistanceFeet + rightYDetailedDistanceFeet + floorYDetailedDistanceFeet ) + ( ( 2 * constantDetailedFixtureWidth )/mmToFeet ) ) : ( maxYDetailedDistance + ( ( constantDetailedFixtureWidth )/mmToFeet ) ) ) );
+
+
+      const floorInsertData = {
+        storeName: planoDoc.storeName,
+        storeId: planoDoc.storeId,
+        layoutName: `${planoDoc.storeName} - Layout`,
+        clientId: '11',
+        floorNumber: 1,
+        floorName: 'floor 1',
+        layoutPolygon: [
+          {
+            elementType: 'wall',
+            distance: finalXDistance,
+            unit: 'ft',
+            direction: 'right',
+            angle: 90,
+            elementNumber: 1,
+            detailedDistance: finalXDetailedDistance,
+          },
+          {
+            elementType: 'wall',
+            distance: finalYDistance,
+            unit: 'ft',
+            direction: 'down',
+            angle: 90,
+            elementNumber: 2,
+            detailedDistance: finalYDetailedDistance,
+          },
+          {
+            elementType: 'wall',
+            distance: finalXDistance,
+            unit: 'ft',
+            direction: 'left',
+            angle: 90,
+            elementNumber: 3,
+            detailedDistance: finalXDetailedDistance,
+          },
+          {
+            elementType: 'wall',
+            distance: roundToTwo( ( ( finalYDistance * 40 ) / 100 ) ),
+            unit: 'ft',
+            direction: 'up',
+            angle: 90,
+            elementNumber: 4,
+            detailedDistance: roundToTwo( ( ( finalYDetailedDistance * 35 ) / 100 ) ),
+          },
+          {
+            elementType: 'entrance',
+            distance: roundToTwo( ( ( finalYDistance * 20 ) / 100 ) ),
+            unit: 'ft',
+            direction: 'up',
+            angle: 90,
+            elementNumber: 1,
+            detailedDistance: roundToTwo( ( ( finalYDetailedDistance * 30 ) / 100 ) ),
+          },
+          {
+            elementType: 'wall',
+            distance: roundToTwo( ( ( finalYDistance * 40 ) / 100 ) ),
+            unit: 'ft',
+            direction: 'up',
+            angle: 90,
+            elementNumber: 5,
+            detailedDistance: roundToTwo( ( ( finalYDetailedDistance * 35 ) / 100 ) ),
+          },
+        ],
+        createdBy: new mongoose.Types.ObjectId( '66a78cd82734f4f857cd6db6' ),
+        createdByName: 'Bejan',
+        createdByEmail: 'bejan@tangotech.co.in',
+        status: 'completed',
+        planoId: planoDoc._id,
+      };
+
+      const layoutDoc = await storeBuilderService.upsertOne( { planoId: planoDoc._id }, floorInsertData );
+
+      let fixtureCounter = 1;
+
+      const leftFixturePromises = leftFixtures.map( async ( fixture, index ) => {
+        const fixtureConfig = await fixtureConfigService.findOne( { fixtureCategory: fixture.fixtureType } );
+        if ( !fixtureConfig ) return;
+        const fixtureConfigDoc = fixtureConfig.toObject();
+
+        const fixtureData = {
+          'clientId': layoutDoc.clientId,
+          'storeName': layoutDoc.storeName,
+          'storeId': layoutDoc.storeId,
+          'planoId': layoutDoc.planoId,
+          'floorId': layoutDoc._id,
+          'fixtureName': `Fixture ${index+1} - ${fixture.fixtureType}`,
+          'fixtureCategory': fixtureConfigDoc.fixtureConfigType,
+          'fixtureBrandCategory': fixture.fixtureSubname.length ? ( fixture.fixtureSubname.length > 1 ? fixture.fixtureSubname.join( ' + ' ) : fixture.fixtureSubname[0] ) : undefined,
+          'fixtureBrandSubCategory': fixture.fixtureSubname.length ? ( fixture.fixtureSubname.length > 1 ? fixture.fixtureSubname.join( ' + ' ) : fixture.fixtureSubname[0] ) : undefined,
+          'fixtureCode': fixtureConfigDoc?.fixtureCode,
+          'fixtureCapacity': fixtureConfigDoc?.fixtureCapacity,
+          'fixtureType': 'wall',
+          'fixtureHeight': {
+            'value': 0,
+            'unit': 'mm',
+          },
+          'fixtureLength': {
+            'value': constantFixtureLength,
+            'unit': 'mm',
+          },
+          'fixtureWidth': {
+            'value': constantFixtureWidth,
+            'unit': 'mm',
+          },
+          'associatedElementType': 'wall',
+          'associatedElementNumber': 1,
+          'relativePosition': {
+            'x': roundToTwo( ( index * ( constantFixtureLength / mmToFeet ) ) ),
+            'y': 0,
+            'unit': 'ft',
+          },
+          'fixtureNumber': fixtureCounter,
+          'detailedFixtureLength': {
+            'value': constantDetailedFixtureLength,
+            'unit': 'mm',
+          },
+          'detailedFixtureWidth': {
+            'value': constantDetailedFixtureWidth,
+            'unit': 'mm',
+          },
+          'relativeDetailedPosition': {
+            'x': roundToTwo( ( index * ( constantDetailedFixtureLength / mmToFeet ) ) ),
+            'y': 0,
+            'unit': 'ft',
+          },
+          'productResolutionLevel': 'L2',
+          'associatedElementFixtureNumber': index+1,
+          'header': fixture.header,
+          'footer': fixture.footer,
+          'fixtureConfigId': fixtureConfigDoc._id,
+        };
+
+        const createdFixture = await storeFixtureService.upsertOne(
+            {
+              floorId: layoutDoc._id,
+              fixtureNumber: fixtureCounter++,
+            },
+            fixtureData,
+        );
+
+        if ( !fixtureConfigDoc.shelfConfig.length || fixture.header === 'CL' || fixture.fixtureSubname?.includes( 'CL' ) ) return;
+
+        await Promise.all(
+            fixtureConfigDoc.shelfConfig.map( async ( configShelf, j ) => {
+              const shelfZone = fixture.productZones.find( ( zone ) => zone.zoneName === configShelf.shelfZone );
+              const shelfSection = shelfZone.products.find( ( product ) => !product.isMerchandisingElement );
+
+              const shelfData = {
+                'clientId': '11',
+                'storeName': layoutDoc.storeName,
+                'storeId': layoutDoc.storeId,
+                'planoId': layoutDoc.planoId,
+                'floorId': layoutDoc._id,
+                'fixtureId': createdFixture._id,
+                'shelfNumber': j + 1,
+                'shelfOrder': 'LTR',
+                'shelfCapacity': configShelf.shelfCapacity,
+                'sectionName': shelfSection?.productName ? shelfSection.productName : 'Unknown',
+                'sectionZone': configShelf.shelfZone,
+                'shelfSplitup': configShelf?.shelfSplitup ? configShelf.shelfSplitup : 0,
+              };
+
+              await fixtureShelfService.upsertOne(
+                  {
+                    fixtureId: createdFixture._id,
+                    shelfNumber: j + 1,
+                  },
+                  shelfData,
+              );
+            } ),
+        );
+
+        await Promise.all(
+            fixture.productZones?.map( async ( zone ) => {
+              const vms = zone.products.filter( ( vm ) => vm.isMerchandisingElement );
+              const vmConfig = fixtureConfigDoc.vmConfig.filter( ( vm ) => vm.position === zone.zoneName );
+              const pids = zone.products.filter( ( vm ) => !vm.isMerchandisingElement );
+
+              await Promise.all(
+                  vms.map( async ( vm ) => {
+                    let configData = vmConfig[0];
+
+                    if ( vm.productName === 'Creatr' && zone.zoneName === 'Mid' ) {
+                      configData = vmConfig.find( ( config ) => config.vmWidthmm === 905 );
+                    }
+
+                    if ( vm.productName === 'Creatr' && zone.zoneName === 'Mid' && pids.length ) {
+                      configData = vmConfig.find( ( config ) => config.vmWidthmm === 230 );
+                    }
+
+                    if ( !configData ) return;
+
+                    const insertData = {
+                      'clientId': '11',
+                      'productId': 'VMCR',
+                      'type': 'vm',
+                      'productName': vm.productName,
+                      'productHeight': {
+                        'value': configData.vmHeightmm,
+                        'unit': 'mm',
+                      },
+                      'productWidth': {
+                        'value': configData.vmWidthmm,
+                        'unit': 'mm',
+                      },
+                      'startYPosition': configData.startShelf,
+                      'endYPosition': configData.endShelf,
+                      'xZone': configData.zone,
+                      'fixtureConfigId': fixtureConfig._id,
+                    };
+
+                    const vmTemplate = await planoProductService.upsertOne(
+                        {
+                          'productName': vm.productName,
+                          'fixtureConfigId': fixtureConfig._id,
+                          'productHeight.value': configData.vmHeightmm,
+                          'productWidth.value': configData.vmWidthmm,
+                          'startYPosition': configData.startShelf,
+                          'endYPosition': configData.endShelf,
+                          'xZone': configData.zone,
+                        },
+                        insertData,
+                    );
+
+                    const vmData = {
+                      'clientId': layoutDoc.clientId,
+                      'storeName': layoutDoc.storeName,
+                      'storeId': layoutDoc.storeId,
+                      'planoId': layoutDoc.planoId,
+                      'floorId': layoutDoc._id,
+                      'type': 'vm',
+                      'fixtureId': createdFixture._id,
+                      'productId': vmTemplate._id,
+                    };
+
+                    await planoMappingService.upsertOne(
+                        {
+                          fixtureId: createdFixture._id,
+                          productId: vmTemplate._id,
+                        },
+                        vmData,
+                    );
+                  } ),
+              );
+            } ) || [],
+        );
+      } );
+
+      const backFixturePromises = backFixtures.map( async ( fixture, index ) => {
+        const fixtureConfig = await fixtureConfigService.findOne( { fixtureCategory: fixture.fixtureType } );
+        if ( !fixtureConfig ) return;
+        const fixtureConfigDoc = fixtureConfig.toObject();
+
+        const fixtureData = {
+          'clientId': layoutDoc.clientId,
+          'storeName': layoutDoc.storeName,
+          'storeId': layoutDoc.storeId,
+          'planoId': layoutDoc.planoId,
+          'floorId': layoutDoc._id,
+          'fixtureName': `Fixture ${index+1} - ${fixture.fixtureType}`,
+          'fixtureCategory': fixtureConfigDoc.fixtureConfigType,
+          'fixtureBrandCategory': fixture.fixtureSubname.length ? ( fixture.fixtureSubname.length > 1 ? fixture.fixtureSubname.join( ' + ' ) : fixture.fixtureSubname[0] ) : undefined,
+          'fixtureBrandSubCategory': fixture.fixtureSubname.length ? ( fixture.fixtureSubname.length > 1 ? fixture.fixtureSubname.join( ' + ' ) : fixture.fixtureSubname[0] ) : undefined,
+          'fixtureCode': fixtureConfigDoc?.fixtureCode,
+          'fixtureCapacity': fixtureConfigDoc?.fixtureCapacity,
+          'fixtureType': 'wall',
+          'fixtureHeight': {
+            'value': 0,
+            'unit': 'mm',
+          },
+          'fixtureLength': {
+            'value': constantFixtureWidth,
+            'unit': 'mm',
+          },
+          'fixtureWidth': {
+            'value': constantFixtureLength,
+            'unit': 'mm',
+          },
+          'associatedElementType': 'wall',
+          'associatedElementNumber': 2,
+          'relativePosition': {
+            'x': roundToTwo( ( finalXDistance - ( constantFixtureWidth/mmToFeet ) ) ),
+            'y': roundToTwo( ( ( index * ( ( constantFixtureLength/mmToFeet ) ) ) + ( ( leftFixtures.length ? 1 : 0 ) * constantFixtureWidth/mmToFeet ) ) ),
+            'unit': 'ft',
+          },
+          'fixtureNumber': fixtureCounter,
+          'detailedFixtureLength': {
+            'value': constantDetailedFixtureLength,
+            'unit': 'mm',
+          },
+          'detailedFixtureWidth': {
+            'value': constantDetailedFixtureWidth,
+            'unit': 'mm',
+          },
+          'relativeDetailedPosition': {
+            'x': roundToTwo( ( finalXDetailedDistance - ( constantDetailedFixtureLength/mmToFeet ) ) ),
+            'y': roundToTwo( ( ( index * ( ( constantDetailedFixtureWidth/mmToFeet ) ) ) + ( ( leftFixtures.length ? 1 : 0 ) * constantDetailedFixtureWidth/mmToFeet ) ) ),
+            'unit': 'ft',
+          },
+          'productResolutionLevel': 'L2',
+          'associatedElementFixtureNumber': index+1,
+          'header': fixture.header,
+          'footer': fixture.footer,
+          'fixtureConfigId': fixtureConfigDoc._id,
+        };
+
+        const createdFixture = await storeFixtureService.upsertOne(
+            {
+              floorId: layoutDoc._id,
+              fixtureNumber: fixtureCounter++,
+            },
+            fixtureData,
+        );
+
+        if ( !fixtureConfigDoc.shelfConfig.length || fixture.header === 'CL' || fixture.fixtureSubname?.includes( 'CL' ) ) return;
+
+        await Promise.all(
+            fixtureConfigDoc.shelfConfig.map( async ( configShelf, j ) => {
+              const shelfZone = fixture.productZones.find( ( zone ) => zone.zoneName === configShelf.shelfZone );
+              const shelfSection = shelfZone.products.find( ( product ) => !product.isMerchandisingElement );
+
+              const shelfData = {
+                'clientId': '11',
+                'storeName': layoutDoc.storeName,
+                'storeId': layoutDoc.storeId,
+                'planoId': layoutDoc.planoId,
+                'floorId': layoutDoc._id,
+                'fixtureId': createdFixture._id,
+                'shelfNumber': j + 1,
+                'shelfOrder': 'LTR',
+                'shelfCapacity': configShelf.shelfCapacity,
+                'sectionName': shelfSection?.productName ? shelfSection.productName : 'Unknown',
+                'sectionZone': configShelf.shelfZone,
+                'shelfSplitup': configShelf?.shelfSplitup ? configShelf.shelfSplitup : 0,
+              }; ;
+
+              await fixtureShelfService.upsertOne(
+                  {
+                    fixtureId: createdFixture._id,
+                    shelfNumber: j + 1,
+                  },
+                  shelfData,
+              );
+            } ),
+        );
+
+        await Promise.all(
+            fixture.productZones?.map( async ( zone ) => {
+              const vms = zone.products.filter( ( vm ) => vm.isMerchandisingElement );
+              const vmConfig = fixtureConfigDoc.vmConfig.filter( ( vm ) => vm.position === zone.zoneName );
+              const pids = zone.products.filter( ( vm ) => !vm.isMerchandisingElement );
+
+              await Promise.all(
+                  vms.map( async ( vm ) => {
+                    let configData = vmConfig[0];
+
+                    if ( vm.productName === 'Creatr' && zone.zoneName === 'Mid' ) {
+                      configData = vmConfig.find( ( config ) => config.vmWidthmm === 905 );
+                    }
+
+                    if ( vm.productName === 'Creatr' && zone.zoneName === 'Mid' && pids.length ) {
+                      configData = vmConfig.find( ( config ) => config.vmWidthmm === 230 );
+                    }
+
+                    if ( !configData ) return;
+
+                    const insertData = {
+                      'clientId': '11',
+                      'productId': 'VMCR',
+                      'type': 'vm',
+                      'productName': vm.productName,
+                      'productHeight': {
+                        'value': configData.vmHeightmm,
+                        'unit': 'mm',
+                      },
+                      'productWidth': {
+                        'value': configData.vmWidthmm,
+                        'unit': 'mm',
+                      },
+                      'startYPosition': configData.startShelf,
+                      'endYPosition': configData.endShelf,
+                      'xZone': configData.zone,
+                      'fixtureConfigId': fixtureConfig._id,
+                    };
+
+                    const vmTemplate = await planoProductService.upsertOne(
+                        {
+                          'productName': vm.productName,
+                          'fixtureConfigId': fixtureConfig._id,
+                          'productHeight.value': configData.vmHeightmm,
+                          'productWidth.value': configData.vmWidthmm,
+                          'startYPosition': configData.startShelf,
+                          'endYPosition': configData.endShelf,
+                          'xZone': configData.zone,
+                        },
+                        insertData,
+                    );
+
+                    const vmData = {
+                      'clientId': layoutDoc.clientId,
+                      'storeName': layoutDoc.storeName,
+                      'storeId': layoutDoc.storeId,
+                      'planoId': layoutDoc.planoId,
+                      'floorId': layoutDoc._id,
+                      'type': 'vm',
+                      'fixtureId': createdFixture._id,
+                      'productId': vmTemplate._id,
+                    };
+
+                    await planoMappingService.upsertOne(
+                        {
+                          fixtureId: createdFixture._id,
+                          productId: vmTemplate._id,
+                        },
+                        vmData,
+                    );
+                  } ),
+              );
+            } ) || [],
+        );
+      } );
+
+      const rightFixturePromises = rightFixtures.map( async ( fixture, index ) => {
+        const fixtureConfig = await fixtureConfigService.findOne( { fixtureCategory: fixture.fixtureType } );
+        if ( !fixtureConfig ) return;
+        const fixtureConfigDoc = fixtureConfig.toObject();
+
+        const fixtureData = {
+          'clientId': layoutDoc.clientId,
+          'storeName': layoutDoc.storeName,
+          'storeId': layoutDoc.storeId,
+          'planoId': layoutDoc.planoId,
+          'floorId': layoutDoc._id,
+          'fixtureName': `Fixture ${index+1} - ${fixture.fixtureType}`,
+          'fixtureCategory': fixtureConfigDoc.fixtureConfigType,
+          'fixtureBrandCategory': fixture.fixtureSubname.length ? ( fixture.fixtureSubname.length > 1 ? fixture.fixtureSubname.join( ' + ' ) : fixture.fixtureSubname[0] ) : undefined,
+          'fixtureBrandSubCategory': fixture.fixtureSubname.length ? ( fixture.fixtureSubname.length > 1 ? fixture.fixtureSubname.join( ' + ' ) : fixture.fixtureSubname[0] ) : undefined,
+          'fixtureCode': fixtureConfigDoc?.fixtureCode,
+          'fixtureCapacity': fixtureConfigDoc?.fixtureCapacity,
+          'fixtureType': 'wall',
+          'fixtureHeight': {
+            'value': 0,
+            'unit': 'mm',
+          },
+          'fixtureLength': {
+            'value': constantFixtureLength,
+            'unit': 'mm',
+          },
+          'fixtureWidth': {
+            'value': constantFixtureWidth,
+            'unit': 'mm',
+          },
+          'associatedElementType': 'wall',
+          'associatedElementNumber': 3,
+          'relativePosition': {
+            'x': roundToTwo( ( index * ( constantFixtureLength / mmToFeet ) ) ),
+            'y': roundToTwo( ( finalYDistance - ( constantFixtureWidth / mmToFeet ) ) ),
+            'unit': 'ft',
+          },
+          'fixtureNumber': fixtureCounter,
+          'detailedFixtureLength': {
+            'value': constantDetailedFixtureLength,
+            'unit': 'mm',
+          },
+          'detailedFixtureWidth': {
+            'value': constantDetailedFixtureWidth,
+            'unit': 'mm',
+          },
+          'relativeDetailedPosition': {
+            'x': roundToTwo( ( index * ( constantDetailedFixtureLength / mmToFeet ) ) ),
+            'y': roundToTwo( ( finalYDetailedDistance - ( constantDetailedFixtureWidth / mmToFeet ) ) ),
+            'unit': 'ft',
+          },
+          'productResolutionLevel': 'L2',
+          'associatedElementFixtureNumber': index+1,
+          'header': fixture.header,
+          'footer': fixture.footer,
+          'fixtureConfigId': fixtureConfigDoc._id,
+        };
+
+        const createdFixture = await storeFixtureService.upsertOne(
+            {
+              floorId: layoutDoc._id,
+              fixtureNumber: fixtureCounter++,
+            },
+            fixtureData,
+        );
+
+        if ( !fixtureConfigDoc.shelfConfig.length || fixture.header === 'CL' || fixture.fixtureSubname?.includes( 'CL' ) ) return;
+
+        await Promise.all(
+            fixtureConfigDoc.shelfConfig.map( async ( configShelf, j ) => {
+              const shelfZone = fixture.productZones.find( ( zone ) => zone.zoneName === configShelf.shelfZone );
+              const shelfSection = shelfZone.products.find( ( product ) => !product.isMerchandisingElement );
+
+              const shelfData = {
+                'clientId': '11',
+                'storeName': layoutDoc.storeName,
+                'storeId': layoutDoc.storeId,
+                'planoId': layoutDoc.planoId,
+                'floorId': layoutDoc._id,
+                'fixtureId': createdFixture._id,
+                'shelfNumber': j + 1,
+                'shelfOrder': 'LTR',
+                'shelfCapacity': configShelf.shelfCapacity,
+                'sectionName': shelfSection?.productName ? shelfSection.productName : 'Unknown',
+                'sectionZone': configShelf.shelfZone,
+                'shelfSplitup': configShelf?.shelfSplitup ? configShelf.shelfSplitup : 0,
+              };
+
+              await fixtureShelfService.upsertOne(
+                  {
+                    fixtureId: createdFixture._id,
+                    shelfNumber: j + 1,
+                  },
+                  shelfData,
+              );
+            } ),
+        );
+
+        await Promise.all(
+            fixture.productZones?.map( async ( zone ) => {
+              const vms = zone.products.filter( ( vm ) => vm.isMerchandisingElement );
+              const vmConfig = fixtureConfigDoc.vmConfig.filter( ( vm ) => vm.position === zone.zoneName );
+              const pids = zone.products.filter( ( vm ) => !vm.isMerchandisingElement );
+
+              await Promise.all(
+                  vms.map( async ( vm ) => {
+                    let configData = vmConfig[0];
+
+                    if ( vm.productName === 'Creatr' && zone.zoneName === 'Mid' ) {
+                      configData = vmConfig.find( ( config ) => config.vmWidthmm === 905 );
+                    }
+
+                    if ( vm.productName === 'Creatr' && zone.zoneName === 'Mid' && pids.length ) {
+                      configData = vmConfig.find( ( config ) => config.vmWidthmm === 230 );
+                    }
+
+                    if ( !configData ) return;
+
+                    const insertData = {
+                      'clientId': '11',
+                      'productId': 'VMCR',
+                      'type': 'vm',
+                      'productName': vm.productName,
+                      'productHeight': {
+                        'value': configData.vmHeightmm,
+                        'unit': 'mm',
+                      },
+                      'productWidth': {
+                        'value': configData.vmWidthmm,
+                        'unit': 'mm',
+                      },
+                      'startYPosition': configData.startShelf,
+                      'endYPosition': configData.endShelf,
+                      'xZone': configData.zone,
+                      'fixtureConfigId': fixtureConfig._id,
+                    };
+
+                    const vmTemplate = await planoProductService.upsertOne(
+                        {
+                          'productName': vm.productName,
+                          'fixtureConfigId': fixtureConfig._id,
+                          'productHeight.value': configData.vmHeightmm,
+                          'productWidth.value': configData.vmWidthmm,
+                          'startYPosition': configData.startShelf,
+                          'endYPosition': configData.endShelf,
+                          'xZone': configData.zone,
+                        },
+                        insertData,
+                    );
+
+                    const vmData = {
+                      'clientId': layoutDoc.clientId,
+                      'storeName': layoutDoc.storeName,
+                      'storeId': layoutDoc.storeId,
+                      'planoId': layoutDoc.planoId,
+                      'floorId': layoutDoc._id,
+                      'type': 'vm',
+                      'fixtureId': createdFixture._id,
+                      'productId': vmTemplate._id,
+                    };
+
+                    await planoMappingService.upsertOne(
+                        {
+                          fixtureId: createdFixture._id,
+                          productId: vmTemplate._id,
+                        },
+                        vmData,
+                    );
+                  } ),
+              );
+            } ) || [],
+        );
+      } );
+
+      const floorFixturePromises = floorFixtures.map( async ( fixture, index ) => {
+        const centerRow = Math.floor( totalRows / 2 );
+
+        const startingX = roundToTwo( ( finalXDistance / 2 - ( maxFixturesPerRow / 2 ) * ( constantFixtureLength / mmToFeet ) ) );
+        const detailedStartingX = roundToTwo( ( finalXDetailedDistance / 2 - ( maxFixturesPerRow / 2 ) * ( constantDetailedFixtureLength / mmToFeet ) ) );
+
+        const startingY = finalYDistance / 2 - centerRow * ( constantFixtureWidth / mmToFeet );
+        const detailedStartingY = finalYDetailedDistance / 2 - centerRow * ( constantDetailedFixtureWidth / mmToFeet );
+
+        const colIndex = Math.floor( index / 2 );
+        const rowIndex = index % 2 === 0 ? 1 : 0;
+
+        const xPos = roundToTwo( startingX + colIndex * ( constantFixtureLength / mmToFeet ) );
+        const yPos = roundToTwo( startingY + rowIndex * ( constantFixtureWidth / mmToFeet ) );
+
+        const detailedXPos = roundToTwo( ( detailedStartingX + colIndex * ( constantDetailedFixtureLength / mmToFeet ) ) );
+        const detailedYPos = roundToTwo( ( detailedStartingY + rowIndex * ( constantDetailedFixtureWidth / mmToFeet ) ) );
+
+        const fixtureConfig = await fixtureConfigService.findOne( { fixtureCategory: fixture.main } );
+        if ( !fixtureConfig ) return;
+
+        const fixtureConfigDoc = fixtureConfig.toObject();
+
+        const fixtureData = {
+          'clientId': layoutDoc.clientId,
+          'storeName': layoutDoc.storeName,
+          'storeId': layoutDoc.storeId,
+          'planoId': layoutDoc.planoId,
+          'floorId': layoutDoc._id,
+          'fixtureName': `Fixture ${index+1} - ${fixture.main}`,
+          'fixtureCategory': fixtureConfigDoc.fixtureConfigType,
+          'fixtureBrandCategory': fixture.centerSubMain ? fixture.centerSubMain : undefined,
+          'fixtureBrandSubCategory': fixture.centerSubMain ? fixture.centerSubMain : undefined,
+          'fixtureCode': fixtureConfigDoc?.fixtureCode,
+          'fixtureCapacity': fixtureConfigDoc?.fixtureCapacity,
+          'fixtureType': 'floor',
+          'fixtureHeight': {
+            'value': 0,
+            'unit': 'mm',
+          },
+          'fixtureLength': {
+            'value': constantFixtureLength,
+            'unit': 'mm',
+          },
+          'fixtureWidth': {
+            'value': constantFixtureWidth,
+            'unit': 'mm',
+          },
+          'relativePosition': {
+            'x': xPos,
+            'y': yPos,
+            'unit': 'ft',
+          },
+          'fixtureNumber': fixtureCounter,
+          'detailedFixtureLength': {
+            'value': constantDetailedFixtureLength,
+            'unit': 'mm',
+          },
+          'detailedFixtureWidth': {
+            'value': constantDetailedFixtureWidth,
+            'unit': 'mm',
+          },
+          'relativeDetailedPosition': {
+            'x': detailedXPos,
+            'y': detailedYPos,
+            'unit': 'ft',
+          },
+          'productResolutionLevel': 'L2',
+          'associatedElementFixtureNumber': index+1,
+          'fixtureConfigId': fixtureConfigDoc._id,
+        };
+
+
+        const createdFixture = await storeFixtureService.upsertOne(
+            {
+              floorId: layoutDoc._id,
+              fixtureNumber: fixtureCounter++,
+            },
+            fixtureData,
+        );
+
+        if ( !fixtureConfigDoc.shelfConfig.length || fixture.header === 'CL' || fixture.fixtureSubname?.includes( 'CL' ) ) return;
+
+        await Promise.all(
+            fixtureConfigDoc.shelfConfig.map( async ( configShelf, j ) => {
+              const shelfSection = fixture.centerSuperSubMain.find(
+                  ( product ) => product.isVisualMerchandiser === false || product.isVisualMerchandiser === true,
+              );
+
+              const shelfData = {
+                'clientId': '11',
+                'storeName': layoutDoc.storeName,
+                'storeId': layoutDoc.storeId,
+                'planoId': layoutDoc.planoId,
+                'floorId': layoutDoc._id,
+                'fixtureId': createdFixture._id,
+                'shelfNumber': j + 1,
+                'shelfOrder': 'LTR',
+                'shelfCapacity': configShelf.shelfCapacity,
+                'sectionName': fixture.centerSuperSubMain.find( ( product ) => product.isVisualMerchandiser === true ) ? shelfSection?.name + ' PIDs' : shelfSection?.name,
+                'shelfSplitup': configShelf?.shelfSplitup ? configShelf.shelfSplitup : 0,
+              };
+
+              await fixtureShelfService.upsertOne(
+                  {
+                    fixtureId: createdFixture._id,
+                    shelfNumber: j + 1,
+                  },
+                  shelfData,
+              );
+            } ),
+        );
+
+        const vm = fixture.centerSuperSubMain.find( ( vm ) => vm.isVisualMerchandiser );
+        const vmConfig = fixtureConfigDoc.vmConfig;
+
+        if ( vm ) {
+          const [ configData1, configData2 ] = [ vmConfig[0], vmConfig[1] ];
+
+          const insertData1 = {
+            'clientId': '11',
+            'productId': 'VMCR',
+            'type': 'vm',
+            'productName': vm.name,
+            'productHeight': {
+              'value': configData1.vmHeightmm,
+              'unit': 'mm',
+            },
+            'productWidth': {
+              'value': configData1.vmWidthmm,
+              'unit': 'mm',
+            },
+            'startYPosition': configData1.startShelf,
+            'endYPosition': configData1.endShelf,
+            'xZone': configData1.zone,
+            'fixtureConfigId': fixtureConfig._id,
+          };
+          const insertData2 = {
+            'clientId': '11',
+            'productId': 'VMCR',
+            'type': 'vm',
+            'productName': ' ',
+            'productHeight': {
+              'value': configData2.vmHeightmm,
+              'unit': 'mm',
+            },
+            'productWidth': {
+              'value': configData2.vmWidthmm,
+              'unit': 'mm',
+            },
+            'startYPosition': configData2.startShelf,
+            'endYPosition': configData2.endShelf,
+            'xZone': configData2.zone,
+            'fixtureConfigId': fixtureConfig._id,
+          };
+
+          const [ vmTemplate1, vmTemplate2 ] = await Promise.all( [
+            planoProductService.upsertOne(
+                {
+                  'productName': vm.name,
+                  'fixtureConfigId': fixtureConfig._id,
+                  'productHeight.value': configData1.vmHeightmm,
+                  'productWidth.value': configData1.vmWidthmm,
+                  'startYPosition': configData1.startShelf,
+                  'endYPosition': configData1.endShelf,
+                  'xZone': configData1.zone,
+                },
+                insertData1,
+            ),
+            planoProductService.upsertOne(
+                {
+                  'productName': ' ',
+                  'fixtureConfigId': fixtureConfig._id,
+                  'productHeight.value': configData2.vmHeightmm,
+                  'productWidth.value': configData2.vmWidthmm,
+                  'startYPosition': configData2.startShelf,
+                  'endYPosition': configData2.endShelf,
+                  'xZone': configData2.zone,
+                },
+                insertData2,
+            ),
+          ] );
+
+          const vmData1 = {
+            'clientId': layoutDoc.clientId,
+            'storeName': layoutDoc.storeName,
+            'storeId': layoutDoc.storeId,
+            'planoId': layoutDoc.planoId,
+            'floorId': layoutDoc._id,
+            'type': 'vm',
+            'fixtureId': createdFixture._id,
+            'productId': vmTemplate1._id,
+          };
+          const vmData2 = {
+            'clientId': layoutDoc.clientId,
+            'storeName': layoutDoc.storeName,
+            'storeId': layoutDoc.storeId,
+            'planoId': layoutDoc.planoId,
+            'floorId': layoutDoc._id,
+            'type': 'vm',
+            'fixtureId': createdFixture._id,
+            'productId': vmTemplate2._id,
+          };
+
+          await Promise.all( [
+            planoMappingService.upsertOne(
+                {
+                  fixtureId: createdFixture._id,
+                  productId: vmTemplate1._id,
+                },
+                vmData1,
+            ),
+            planoMappingService.upsertOne(
+                {
+                  fixtureId: createdFixture._id,
+                  productId: vmTemplate2._id,
+                },
+                vmData2,
+            ),
+          ] );
+        }
+      } );
+
+      await Promise.all( [ ...leftFixturePromises, ...backFixturePromises, ...rightFixturePromises, ...floorFixturePromises ] );
+
+      const now = Date.now();
+      const elapsedMinutes = ( now - startTime ) / 1000 / 60;
+      console.log( `Store name: ${storeData.storeName}, Iteration ${i + 1}: total elapsed time = ${elapsedMinutes.toFixed( 2 )} minutes` );
+    }
+
+    res.sendSuccess( 'Updated Successfully' );
+  } catch ( e ) {
+    logger.error( { functionName: 'updateCrestPlanogram', error: e } );
+    return res.sendError( e.message || 'Internal Server Error', 500 );
+  }
+}
+
+export async function getVideoLinks( req, res ) {
+  if ( req?.headers?.authorization?.split( ' ' )[1] !== 'hwjXfCD6TgMvc82cuSGZ9bNv9MuXsaiQ6uvx' ) {
+    return res.sendError( 'Unauthorized', 401 );
+  }
+  try {
+    const query = [
+      {
+        $match: {
+          date_string: { $gte: req.body.fromDate, $lte: req.body.toDate },
+          type: 'layout',
+          status: req.body.status,
+        },
+      },
+      {
+        $lookup: {
+          from: 'planograms',
+          let: { plano_id: '$planoId' },
+          pipeline: [
+            {
+              $match: {
+                $expr: {
+                  $and: [
+                    { $eq: [ '$_id', '$$plano_id' ] },
+                  ],
+                },
+              },
+            },
+            {
+              $project: {
+                storeName: 1,
+                _id: 0,
+              },
+            },
+          ],
+          as: 'planogram',
+        },
+      },
+      { $unwind: { path: '$planogram', preserveNullAndEmptyArrays: true } },
+      {
+        $project: {
+          storeName: '$planogram.storeName',
+          answers: 1,
+          type: 1,
+          status: 1,
+          planoId: 1,
+          floorId: 1,
+        },
+      },
+    ];
+    const responseData = await planoTaskService.aggregate( query );
+
+    const videoData = [];
+
+    const seenStores = new Set();
+
+    for ( const data of responseData ) {
+      const store = await planoService.findOne( { _id: data.planoId } );
+      if ( seenStores.has( store?.toObject()?.storeName ) ) {
+        continue;
+      }
+      const [ q1, q2, q3 ] = data.answers;
+
+      const params = {
+        Bucket: 'tango-planogram',
+        file_path: q3?.video || null,
+      };
+
+      const videoUrl = await signedUrl( params );
+
+      videoData.push( {
+        date: data.date_string,
+        store: store?.toObject()?.storeName,
+        videoUrl,
+      } );
+
+      seenStores.add( store?.toObject()?.storeName );
+    }
+
+    const resData = {
+      count: videoData.length,
+      data: videoData,
+    };
+
+    res.sendSuccess( resData );
+  } catch ( e ) {
+    console.log( e );
+    return res.sendError( e, 500 );
+  }
+}
+
+export async function updateExcelPlanogram( req, res ) {
+  try {
+    if ( req?.headers?.authorization?.split( ' ' )[1] !== 'hwjXfCD6TgMvc82cuSGZ9bNv9MuXsaiQ6uvx' ) {
+      return res.sendError( 'Unauthorized', 401 );
+    }
+
+    const startTime = Date.now();
+
+    const workbook = xlsx.read( req.files.file.data, { type: 'buffer' } );
+    const sheetName = 'Sheet1';
+    const raw = xlsx.utils.sheet_to_json( workbook.Sheets[sheetName] );
+
+    const storeNames = new Set();
+
+    raw.forEach( ( entry ) => storeNames.add( entry?.['Store ID'] ) );
+
+    const storeNameArr = Array.from( storeNames );
+
+    const storeList = await storeService.find( { clientId: '11', storeName: { $in: storeNameArr } }, { storeName: 1, storeId: 1 } );
+
+    function transformFixtureData( inputData ) {
+      const storeMap = new Map();
+
+      inputData.forEach( ( item ) => {
+        const storeName = item['Store ID'];
+        if ( !storeMap.has( storeName ) ) {
+          storeMap.set( storeName, [] );
+        }
+        storeMap.get( storeName ).push( item );
+      } );
+
+      const result = [];
+
+      for ( const [ storeName, storeItems ] of storeMap.entries() ) {
+        const wallGroups = new Map();
+        const fixtureGroupMap = new Map();
+
+        function addZoneProduct( fixture, zoneName, productName, isVM ) {
+          let zone = fixture.productZones.find( ( z ) => z.zoneName === zoneName );
+          if ( !zone ) {
+            zone = { zoneName, products: [] };
+            fixture.productZones.push( zone );
+          }
+
+          if ( !zone.products.some( ( p ) => p.productName === productName && p.isMerchandisingElement === isVM ) ) {
+            zone.products.push( {
+              productName,
+              isMerchandisingElement: isVM,
+            } );
+          }
+        }
+
+        storeItems.forEach( ( item ) => {
+          const wall = item.Wall || 'Unknown';
+          const locator = item['Store Fixture Locator'];
+          const wallUpper = wall.toUpperCase();
+          const isCenterWall = wallUpper.includes( 'CENTRE' );
+          const fixtureKey = wall + '::' + locator;
+
+          if ( !fixtureGroupMap.has( fixtureKey ) ) {
+            if ( isCenterWall ) {
+              console.log();
+              fixtureGroupMap.set( fixtureKey, {
+                type: 'center',
+                id: item['Store Fixture ID'],
+                main: item['Fixture Type'],
+                centerSubMain: item['Brand-Category'],
+                fixtureLocator: locator,
+                centerSuperSubMain: [
+                  {
+                    name: item['Brand-Category'],
+                    isVisualMerchandiser: false,
+                  },
+                ],
+              } );
+            } else {
+              fixtureGroupMap.set( fixtureKey, {
+                type: 'wall',
+                id: item['Store Fixture ID'],
+                footer: 'Storage Box',
+                header: item['Brand-Category'],
+                fixtureName: `${locator} - ${item['Fixture Type']}`,
+                fixtureType: item['Fixture Type'],
+                productZones: [],
+                fixtureSpacing: 0,
+                fixtureSubname: [ item['Brand - Sub Category'] ],
+                wall: wallUpper + ' WALL',
+              } );
+            }
+          }
+
+          const fixture = fixtureGroupMap.get( fixtureKey );
+
+          if ( fixture.type === 'wall' ) {
+            if ( item.VM ) addZoneProduct( fixture, item.Zone, item.VM, true );
+            if ( item.Allocation ) addZoneProduct( fixture, item.Zone, item.Allocation, false );
+          }
+        } );
+
+        const structuredData = [];
+
+        for ( const fixture of fixtureGroupMap.values() ) {
+          if ( fixture.type === 'center' ) {
+            structuredData.push( {
+              id: fixture.id,
+              main: fixture.main,
+              centerSubMain: fixture.centerSubMain,
+              fixtureLocator: fixture.fixtureLocator,
+              centerSuperSubMain: fixture.centerSuperSubMain,
+            } );
+          } else {
+            const wallName = fixture.wall;
+            if ( !wallGroups.has( wallName ) ) {
+              wallGroups.set( wallName, {
+                main: wallName,
+                fixtures: [],
+              } );
+            }
+            wallGroups.get( wallName ).fixtures.push( fixture );
+          }
+        }
+
+        result.push( {
+          storeName,
+          data: [
+            ...Array.from( wallGroups.values() ),
+            ...structuredData,
+          ],
+        } );
+      }
+
+      return result;
+    }
+
+
+    const finalData = transformFixtureData( raw );
+
+
+    const constantFixtureLength = 1220;
+    const constantDetailedFixtureLength = 1220;
+
+    const constantFixtureWidth = 610;
+    const constantDetailedFixtureWidth = 1524;
+
+    const mmToFeet = 305;
+
+    function roundToTwo( num ) {
+      return Math.round( num * 100 ) / 100;
+    }
+
+    for ( let i = 0; i < storeList.length; i++ ) {
+      const storeData = finalData.find( ( store ) => store.storeName === storeList[i].toObject().storeName );
+
+      const storeDetails = storeList[i];
+
+      const existingPlanogram = await planoService.findOne( { storeName: storeData.storeName } );
+
+      if ( existingPlanogram ) {
+        const checkTaskSubmitted = await planoTaskService.findOne( { planoId: existingPlanogram.toObject()._id } );
+
+        const checkTaskCreated = await processedTaskService.findOne( { storeName: storeData.storeName, date_iso: { $gte: new Date( ), $lte: new Date( ) }, isPlano: true } );
+
+        if ( checkTaskSubmitted || checkTaskCreated ) {
+          continue;
+        }
+      }
+
+
+      if ( existingPlanogram?.toObject()?._id && mongoose.Types.ObjectId.isValid( existingPlanogram?.toObject()?._id ) ) {
+        await Promise.all( [ planoService.deleteOne( { _id: existingPlanogram?.toObject()?._id } ), storeBuilderService.deleteOne( { planoId: existingPlanogram?.toObject()?._id } ),
+          storeFixtureService.deleteMany( { planoId: existingPlanogram?.toObject()?._id } ), fixtureShelfService.deleteMany( { planoId: existingPlanogram?.toObject()?._id } ),
+          planoMappingService.deleteMany( { planoId: existingPlanogram?.toObject()?._id } ),
+        ] );
+      }
+
+
+      const planoInsertData = {
+        storeName: storeData.storeName,
+        storeId: storeDetails?.toObject()?.storeId ? storeDetails.toObject().storeId : 'nil',
+        layoutName: `${storeData.storeName} - Layout`,
+        clientId: '11',
+        attachments: [],
+        createdBy: new mongoose.Types.ObjectId( '66a78cd82734f4f857cd6db6' ),
+        createdByName: 'Bejan',
+        createdByEmail: 'bejan@tangotech.co.in',
+        status: 'completed',
+        floorNumber: 1,
+        productResolutionLevel: 'L2',
+        scanType: 'qr',
+      };
+
+      const insertedPlano = await planoService.upsertOne( { storeName: storeData.storeName }, planoInsertData );
+      const planoDoc = insertedPlano.toObject();
+
+      const leftWall = storeData.data.filter( ( entry ) => entry['main'] === 'LEFT WALL' );
+      const leftFixtures = leftWall.flatMap( ( wall ) => wall.fixtures );
+      const rightWall = storeData.data.filter( ( entry ) => entry['main'] === 'RIGHT WALL' );
+      const rightFixtures = rightWall.flatMap( ( wall ) => wall.fixtures );
+      const backWall = storeData.data.filter( ( entry ) => entry['main'] === 'BACK WALL' );
+      const backFixtures = backWall.flatMap( ( wall ) => wall.fixtures );
+      const frontWall = storeData.data.filter( ( entry ) => entry['main'] === 'FRONT WALL' );
+      const frontFixtures = frontWall.flatMap( ( wall ) => wall.fixtures );
+      const floorFixtures = storeData.data.filter( ( entry ) => entry['main'] === 'Euro Center' );
+
+
+      const leftXDistanceFeet = leftFixtures.length ? roundToTwo( ( leftFixtures.length * ( constantFixtureLength / mmToFeet ) ) ) : 0;
+      const leftXDetailedDistanceFeet = leftFixtures.length ? roundToTwo( ( leftFixtures.length * ( constantDetailedFixtureLength / mmToFeet ) ) ) : 0;
+
+      const leftYDistanceFeet = leftFixtures.length ? roundToTwo( ( ( constantFixtureWidth / mmToFeet ) ) ) : 0;
+      const leftYDetailedDistanceFeet = leftFixtures.length ? roundToTwo( ( ( constantDetailedFixtureWidth / mmToFeet ) ) ) : 0;
+
+      const rightXDistanceFeet = rightFixtures.length ? roundToTwo( ( rightFixtures.length * ( constantFixtureLength / mmToFeet ) ) ) : 0;
+      const rightXDetailedDistanceFeet = rightFixtures.length ? roundToTwo( ( rightFixtures.length * ( constantDetailedFixtureLength / mmToFeet ) ) ) : 0;
+
+      const rightYDistanceFeet = rightFixtures.length ? roundToTwo( ( constantFixtureWidth / mmToFeet ) ) : 0;
+      const rightYDetailedDistanceFeet = rightFixtures.length ? roundToTwo( ( constantDetailedFixtureWidth / mmToFeet ) ): 0;
+
+      const maxFixturesPerRow = floorFixtures.length/2;
+      const totalRows = 2;
+
+      const floorXDistanceFeet = floorFixtures.length ? roundToTwo( ( ( floorFixtures.length/2 ) * ( constantFixtureLength / mmToFeet ) ) ) : 0;
+      const floorXDetailedDistanceFeet = floorFixtures.length ? roundToTwo( ( ( floorFixtures.length/2 ) * ( constantDetailedFixtureLength / mmToFeet ) ) ): 0;
+
+      const floorYDistanceFeet = floorFixtures.length ? roundToTwo( ( 2 * ( constantFixtureWidth/ mmToFeet ) ) ): 0;
+      const floorYDetailedDistanceFeet = floorFixtures.length ? roundToTwo( 2 * ( constantDetailedFixtureWidth/mmToFeet ) ): 0;
+
+      const frontXDistanceFeet = frontFixtures.length ? roundToTwo( ( constantFixtureWidth / mmToFeet ) ) : 0;
+      const frontXDetailedDistanceFeet = frontFixtures.length ? roundToTwo( ( constantDetailedFixtureLength / mmToFeet ) ) : 0;
+
+      const frontYDistanceFeet = frontFixtures.length ? roundToTwo( ( ( frontFixtures.length * ( constantFixtureLength / mmToFeet ) ) + ( ( ( leftFixtures.length ? 1 : 0 ) + ( rightFixtures.length ? 1 : 0 ) * constantFixtureWidth )/mmToFeet ) ) ) : 0;
+      const frontYDetailedDistanceFeet = frontFixtures.length ? roundToTwo( ( ( frontFixtures.length * ( constantDetailedFixtureWidth / mmToFeet ) ) + ( ( ( leftFixtures.length ? 1 : 0 ) + ( rightFixtures.length ? 1 : 0 ) * constantDetailedFixtureWidth )/mmToFeet ) ) ): 0;
+
+      const backXDistanceFeet = backFixtures.length ? roundToTwo( ( constantFixtureWidth / mmToFeet ) ) : 0;
+      const backXDetailedDistanceFeet = backFixtures.length ? roundToTwo( ( constantDetailedFixtureLength / mmToFeet ) ) : 0;
+
+      const backYDistanceFeet = backFixtures.length ? roundToTwo( ( ( backFixtures.length * ( constantFixtureLength / mmToFeet ) ) + ( ( ( leftFixtures.length ? 1 : 0 ) + ( rightFixtures.length ? 1 : 0 ) * constantFixtureWidth )/mmToFeet ) ) ) : 0;
+      const backYDetailedDistanceFeet = backFixtures.length ? roundToTwo( ( ( backFixtures.length * ( constantDetailedFixtureWidth / mmToFeet ) ) + ( ( ( leftFixtures.length ? 1 : 0 ) + ( rightFixtures.length ? 1 : 0 ) * constantDetailedFixtureWidth )/mmToFeet ) ) ): 0;
+
+      const maxXDistance = Math.max( leftXDistanceFeet, rightXDistanceFeet, floorXDistanceFeet );
+      const maxXDetailedDistance = Math.max( leftXDetailedDistanceFeet, rightXDetailedDistanceFeet, floorXDetailedDistanceFeet );
+
+      const maxYDistance = Math.max( floorYDistanceFeet, backYDistanceFeet, frontYDistanceFeet );
+      const maxYDetailedDistance = Math.max( floorYDetailedDistanceFeet, backYDetailedDistanceFeet, frontYDetailedDistanceFeet );
+
+      const finalXDistance = roundToTwo( ( maxXDistance < ( backXDistanceFeet + floorXDistanceFeet + frontXDistanceFeet )? ( ( backXDistanceFeet + floorXDistanceFeet + frontXDistanceFeet ) + ( ( 2 * constantFixtureLength )/mmToFeet ) ) : ( floorFixtures.length && backFixtures.length ) ? ( maxXDistance + ( ( 2 * constantFixtureLength )/mmToFeet ) ) : maxXDistance ) );
+      const finalXDetailedDistance = roundToTwo( ( maxXDetailedDistance < ( backXDetailedDistanceFeet + floorXDetailedDistanceFeet + frontXDetailedDistanceFeet )? ( ( backXDetailedDistanceFeet + floorXDetailedDistanceFeet + frontXDetailedDistanceFeet ) + ( ( 2 * constantDetailedFixtureLength )/mmToFeet ) ) : ( floorFixtures.length && backFixtures.length ) ? ( maxXDetailedDistance + ( ( 2 * constantDetailedFixtureLength )/mmToFeet ) ) : maxXDetailedDistance ) );
+
+      const finalYDistance = roundToTwo( ( maxYDistance < ( leftYDistanceFeet + rightYDistanceFeet + floorYDistanceFeet ) ? ( ( leftYDistanceFeet + rightYDistanceFeet + floorYDistanceFeet ) + ( ( 2 * constantFixtureWidth )/mmToFeet ) ) : ( maxYDistance + ( ( constantFixtureWidth )/mmToFeet ) ) ) );
+      const finalYDetailedDistance = roundToTwo( ( maxYDetailedDistance < ( leftYDetailedDistanceFeet + rightYDetailedDistanceFeet + floorYDetailedDistanceFeet ) ? ( ( leftYDetailedDistanceFeet + rightYDetailedDistanceFeet + floorYDetailedDistanceFeet ) + ( ( 2 * constantDetailedFixtureWidth )/mmToFeet ) ) : ( maxYDetailedDistance + ( ( constantDetailedFixtureWidth )/mmToFeet ) ) ) );
+
+
+      const floorInsertData = {
+        storeName: planoDoc.storeName,
+        storeId: planoDoc.storeId,
+        layoutName: `${planoDoc.storeName} - Layout`,
+        clientId: '11',
+        floorNumber: 1,
+        floorName: 'floor 1',
+        layoutPolygon: [
+          {
+            elementType: 'wall',
+            distance: finalXDistance,
+            unit: 'ft',
+            direction: 'right',
+            angle: 90,
+            elementNumber: 1,
+            detailedDistance: finalXDetailedDistance,
+          },
+          {
+            elementType: 'wall',
+            distance: finalYDistance,
+            unit: 'ft',
+            direction: 'down',
+            angle: 90,
+            elementNumber: 2,
+            detailedDistance: finalYDetailedDistance,
+          },
+          {
+            elementType: 'wall',
+            distance: finalXDistance,
+            unit: 'ft',
+            direction: 'left',
+            angle: 90,
+            elementNumber: 3,
+            detailedDistance: finalXDetailedDistance,
+          },
+          {
+            elementType: 'wall',
+            distance: roundToTwo( ( ( finalYDistance * 40 ) / 100 ) ),
+            unit: 'ft',
+            direction: 'up',
+            angle: 90,
+            elementNumber: 4,
+            detailedDistance: roundToTwo( ( ( finalYDetailedDistance * 35 ) / 100 ) ),
+          },
+          {
+            elementType: 'entrance',
+            distance: roundToTwo( ( ( finalYDistance * 20 ) / 100 ) ),
+            unit: 'ft',
+            direction: 'up',
+            angle: 90,
+            elementNumber: 1,
+            detailedDistance: roundToTwo( ( ( finalYDetailedDistance * 30 ) / 100 ) ),
+          },
+          {
+            elementType: 'wall',
+            distance: roundToTwo( ( ( finalYDistance * 40 ) / 100 ) ),
+            unit: 'ft',
+            direction: 'up',
+            angle: 90,
+            elementNumber: 5,
+            detailedDistance: roundToTwo( ( ( finalYDetailedDistance * 35 ) / 100 ) ),
+          },
+        ],
+        createdBy: new mongoose.Types.ObjectId( '66a78cd82734f4f857cd6db6' ),
+        createdByName: 'Bejan',
+        createdByEmail: 'bejan@tangotech.co.in',
+        status: 'completed',
+        planoId: planoDoc._id,
+      };
+
+      const layoutDoc = await storeBuilderService.upsertOne( { planoId: planoDoc._id }, floorInsertData );
+
+      let fixtureCounter = 1;
+      const frontFixturePromises = frontFixtures.map( async ( fixture, index ) => {
+        const fixtureConfig = await fixtureConfigService.findOne( { fixtureCategory: fixture.fixtureType } );
+        if ( !fixtureConfig ) return;
+        const fixtureConfigDoc = fixtureConfig.toObject();
+
+        const fixtureData = {
+          'clientId': layoutDoc.clientId,
+          'storeName': layoutDoc.storeName,
+          'storeId': layoutDoc.storeId,
+          'planoId': layoutDoc.planoId,
+          'floorId': layoutDoc._id,
+          'fixtureName': `Fixture ${index+1} - ${fixture.fixtureType}`,
+          'fixtureCategory': fixtureConfigDoc.fixtureConfigType,
+          'fixtureBrandCategory': fixture.fixtureSubname.length ? ( fixture.fixtureSubname.length > 1 ? fixture.fixtureSubname.join( ' + ' ) : fixture.fixtureSubname[0] ) : undefined,
+          'fixtureBrandSubCategory': fixture.fixtureSubname.length ? ( fixture.fixtureSubname.length > 1 ? fixture.fixtureSubname.join( ' + ' ) : fixture.fixtureSubname[0] ) : undefined,
+          'fixtureCode': fixtureConfigDoc?.fixtureCode,
+          'fixtureCapacity': fixtureConfigDoc?.fixtureCapacity,
+          'fixtureType': 'wall',
+          'fixtureHeight': {
+            'value': 0,
+            'unit': 'mm',
+          },
+          'fixtureLength': {
+            'value': constantFixtureWidth,
+            'unit': 'mm',
+          },
+          'fixtureWidth': {
+            'value': constantFixtureLength,
+            'unit': 'mm',
+          },
+          'associatedElementType': 'wall',
+          'associatedElementNumber': 2,
+          'relativePosition': {
+            'x': 0,
+            'y': roundToTwo( ( ( index * ( ( constantFixtureLength/mmToFeet ) ) ) + ( ( frontFixtures.length ? 1 : 0 ) * constantFixtureWidth/mmToFeet ) ) ),
+            'unit': 'ft',
+          },
+          'fixtureNumber': fixtureCounter,
+          'detailedFixtureLength': {
+            'value': constantDetailedFixtureLength,
+            'unit': 'mm',
+          },
+          'detailedFixtureWidth': {
+            'value': constantDetailedFixtureWidth,
+            'unit': 'mm',
+          },
+          'relativeDetailedPosition': {
+            'x': 0,
+            'y': roundToTwo( ( ( index * ( ( constantDetailedFixtureWidth/mmToFeet ) ) ) + ( ( frontFixtures.length ? 1 : 0 ) * constantDetailedFixtureWidth/mmToFeet ) ) ),
+            'unit': 'ft',
+          },
+          'productResolutionLevel': 'L2',
+          'associatedElementFixtureNumber': index+1,
+          'header': fixture.header,
+          'footer': fixture.footer,
+          'fixtureConfigId': fixtureConfigDoc._id,
+        };
+
+        const createdFixture = await storeFixtureService.upsertOne(
+            {
+              floorId: layoutDoc._id,
+              fixtureNumber: fixtureCounter++,
+            },
+            fixtureData,
+        );
+
+        if ( !fixtureConfigDoc.shelfConfig.length || fixture.header === 'CL' || fixture.fixtureSubname?.includes( 'CL' ) ) return;
+
+        await Promise.all(
+            fixtureConfigDoc.shelfConfig.map( async ( configShelf, j ) => {
+              const shelfZone = fixture.productZones.find( ( zone ) => zone.zoneName === configShelf.shelfZone );
+              const shelfSection = shelfZone.products.find( ( product ) => !product.isMerchandisingElement );
+
+              const shelfData = {
+                'clientId': '11',
+                'storeName': layoutDoc.storeName,
+                'storeId': layoutDoc.storeId,
+                'planoId': layoutDoc.planoId,
+                'floorId': layoutDoc._id,
+                'fixtureId': createdFixture._id,
+                'shelfNumber': j + 1,
+                'shelfOrder': 'LTR',
+                'shelfCapacity': configShelf.shelfCapacity,
+                'sectionName': shelfSection?.productName ? shelfSection.productName : 'Unknown',
+                'sectionZone': configShelf.shelfZone,
+                'shelfSplitup': configShelf?.shelfSplitup ? configShelf.shelfSplitup : 0,
+              }; ;
+
+              await fixtureShelfService.upsertOne(
+                  {
+                    fixtureId: createdFixture._id,
+                    shelfNumber: j + 1,
+                  },
+                  shelfData,
+              );
+            } ),
+        );
+
+        await Promise.all(
+            fixture.productZones?.map( async ( zone ) => {
+              const vms = zone.products.filter( ( vm ) => vm.isMerchandisingElement );
+              const vmConfig = fixtureConfigDoc.vmConfig.filter( ( vm ) => vm.position === zone.zoneName );
+              const pids = zone.products.filter( ( vm ) => !vm.isMerchandisingElement );
+
+              await Promise.all(
+                  vms.map( async ( vm ) => {
+                    let configData = vmConfig[0];
+
+                    if ( vm.productName === 'Creatr' && zone.zoneName === 'Mid' ) {
+                      configData = vmConfig.find( ( config ) => config.vmWidthmm === 905 );
+                    }
+
+                    if ( vm.productName === 'Creatr' && zone.zoneName === 'Mid' && pids.length ) {
+                      configData = vmConfig.find( ( config ) => config.vmWidthmm === 230 );
+                    }
+
+                    if ( !configData ) return;
+
+                    const insertData = {
+                      'clientId': '11',
+                      'productId': 'VMCR',
+                      'type': 'vm',
+                      'productName': vm.productName,
+                      'productHeight': {
+                        'value': configData.vmHeightmm,
+                        'unit': 'mm',
+                      },
+                      'productWidth': {
+                        'value': configData.vmWidthmm,
+                        'unit': 'mm',
+                      },
+                      'startYPosition': configData.startShelf,
+                      'endYPosition': configData.endShelf,
+                      'xZone': configData.zone,
+                      'fixtureConfigId': fixtureConfig._id,
+                    };
+
+                    const vmTemplate = await planoProductService.upsertOne(
+                        {
+                          'productName': vm.productName,
+                          'fixtureConfigId': fixtureConfig._id,
+                          'productHeight.value': configData.vmHeightmm,
+                          'productWidth.value': configData.vmWidthmm,
+                          'startYPosition': configData.startShelf,
+                          'endYPosition': configData.endShelf,
+                          'xZone': configData.zone,
+                        },
+                        insertData,
+                    );
+
+                    const vmData = {
+                      'clientId': layoutDoc.clientId,
+                      'storeName': layoutDoc.storeName,
+                      'storeId': layoutDoc.storeId,
+                      'planoId': layoutDoc.planoId,
+                      'floorId': layoutDoc._id,
+                      'type': 'vm',
+                      'fixtureId': createdFixture._id,
+                      'productId': vmTemplate._id,
+                    };
+
+                    await planoMappingService.upsertOne(
+                        {
+                          fixtureId: createdFixture._id,
+                          productId: vmTemplate._id,
+                        },
+                        vmData,
+                    );
+                  } ),
+              );
+            } ) || [],
+        );
+      } );
+
+      const leftFixturePromises = leftFixtures.map( async ( fixture, index ) => {
+        const fixtureConfig = await fixtureConfigService.findOne( { fixtureCategory: fixture.fixtureType } );
+        if ( !fixtureConfig ) return;
+        const fixtureConfigDoc = fixtureConfig.toObject();
+
+        const fixtureData = {
+          'clientId': layoutDoc.clientId,
+          'storeName': layoutDoc.storeName,
+          'storeId': layoutDoc.storeId,
+          'planoId': layoutDoc.planoId,
+          'floorId': layoutDoc._id,
+          'fixtureName': `Fixture ${index+1} - ${fixture.fixtureType}`,
+          'fixtureCategory': fixtureConfigDoc.fixtureConfigType,
+          'fixtureBrandCategory': fixture.fixtureSubname.length ? ( fixture.fixtureSubname.length > 1 ? fixture.fixtureSubname.join( ' + ' ) : fixture.fixtureSubname[0] ) : undefined,
+          'fixtureBrandSubCategory': fixture.fixtureSubname.length ? ( fixture.fixtureSubname.length > 1 ? fixture.fixtureSubname.join( ' + ' ) : fixture.fixtureSubname[0] ) : undefined,
+          'fixtureCode': fixtureConfigDoc?.fixtureCode,
+          'fixtureCapacity': fixtureConfigDoc?.fixtureCapacity,
+          'fixtureType': 'wall',
+          'fixtureHeight': {
+            'value': 0,
+            'unit': 'mm',
+          },
+          'fixtureLength': {
+            'value': constantFixtureLength,
+            'unit': 'mm',
+          },
+          'fixtureWidth': {
+            'value': constantFixtureWidth,
+            'unit': 'mm',
+          },
+          'associatedElementType': 'wall',
+          'associatedElementNumber': 1,
+          'relativePosition': {
+            'x': roundToTwo( ( index * ( constantFixtureLength / mmToFeet ) ) ),
+            'y': 0,
+            'unit': 'ft',
+          },
+          'fixtureNumber': fixtureCounter,
+          'detailedFixtureLength': {
+            'value': constantDetailedFixtureLength,
+            'unit': 'mm',
+          },
+          'detailedFixtureWidth': {
+            'value': constantDetailedFixtureWidth,
+            'unit': 'mm',
+          },
+          'relativeDetailedPosition': {
+            'x': roundToTwo( ( index * ( constantDetailedFixtureLength / mmToFeet ) ) ),
+            'y': 0,
+            'unit': 'ft',
+          },
+          'productResolutionLevel': 'L2',
+          'associatedElementFixtureNumber': index+1,
+          'header': fixture.header,
+          'footer': fixture.footer,
+          'fixtureConfigId': fixtureConfigDoc._id,
+        };
+
+        const createdFixture = await storeFixtureService.upsertOne(
+            {
+              floorId: layoutDoc._id,
+              fixtureNumber: fixtureCounter++,
+            },
+            fixtureData,
+        );
+
+        if ( !fixtureConfigDoc.shelfConfig.length || fixture.header === 'CL' || fixture.fixtureSubname?.includes( 'CL' ) ) return;
+
+        await Promise.all(
+            fixtureConfigDoc.shelfConfig.map( async ( configShelf, j ) => {
+              const shelfZone = fixture.productZones.find( ( zone ) => zone.zoneName === configShelf.shelfZone );
+              const shelfSection = shelfZone.products.find( ( product ) => !product.isMerchandisingElement );
+
+              const shelfData = {
+                'clientId': '11',
+                'storeName': layoutDoc.storeName,
+                'storeId': layoutDoc.storeId,
+                'planoId': layoutDoc.planoId,
+                'floorId': layoutDoc._id,
+                'fixtureId': createdFixture._id,
+                'shelfNumber': j + 1,
+                'shelfOrder': 'LTR',
+                'shelfCapacity': configShelf.shelfCapacity,
+                'sectionName': shelfSection?.productName ? shelfSection.productName : 'Unknown',
+                'sectionZone': configShelf.shelfZone,
+                'shelfSplitup': configShelf?.shelfSplitup ? configShelf.shelfSplitup : 0,
+              };
+
+              await fixtureShelfService.upsertOne(
+                  {
+                    fixtureId: createdFixture._id,
+                    shelfNumber: j + 1,
+                  },
+                  shelfData,
+              );
+            } ),
+        );
+
+        await Promise.all(
+            fixture.productZones?.map( async ( zone ) => {
+              const vms = zone.products.filter( ( vm ) => vm.isMerchandisingElement );
+              const vmConfig = fixtureConfigDoc.vmConfig.filter( ( vm ) => vm.position === zone.zoneName );
+              const pids = zone.products.filter( ( vm ) => !vm.isMerchandisingElement );
+
+              await Promise.all(
+                  vms.map( async ( vm ) => {
+                    let configData = vmConfig[0];
+
+                    if ( vm.productName === 'Creatr' && zone.zoneName === 'Mid' ) {
+                      configData = vmConfig.find( ( config ) => config.vmWidthmm === 905 );
+                    }
+
+                    if ( vm.productName === 'Creatr' && zone.zoneName === 'Mid' && pids.length ) {
+                      configData = vmConfig.find( ( config ) => config.vmWidthmm === 230 );
+                    }
+
+                    if ( !configData ) return;
+
+                    const insertData = {
+                      'clientId': '11',
+                      'productId': 'VMCR',
+                      'type': 'vm',
+                      'productName': vm.productName,
+                      'productHeight': {
+                        'value': configData.vmHeightmm,
+                        'unit': 'mm',
+                      },
+                      'productWidth': {
+                        'value': configData.vmWidthmm,
+                        'unit': 'mm',
+                      },
+                      'startYPosition': configData.startShelf,
+                      'endYPosition': configData.endShelf,
+                      'xZone': configData.zone,
+                      'fixtureConfigId': fixtureConfig._id,
+                    };
+
+                    const vmTemplate = await planoProductService.upsertOne(
+                        {
+                          'productName': vm.productName,
+                          'fixtureConfigId': fixtureConfig._id,
+                          'productHeight.value': configData.vmHeightmm,
+                          'productWidth.value': configData.vmWidthmm,
+                          'startYPosition': configData.startShelf,
+                          'endYPosition': configData.endShelf,
+                          'xZone': configData.zone,
+                        },
+                        insertData,
+                    );
+
+                    const vmData = {
+                      'clientId': layoutDoc.clientId,
+                      'storeName': layoutDoc.storeName,
+                      'storeId': layoutDoc.storeId,
+                      'planoId': layoutDoc.planoId,
+                      'floorId': layoutDoc._id,
+                      'type': 'vm',
+                      'fixtureId': createdFixture._id,
+                      'productId': vmTemplate._id,
+                    };
+
+                    await planoMappingService.upsertOne(
+                        {
+                          fixtureId: createdFixture._id,
+                          productId: vmTemplate._id,
+                        },
+                        vmData,
+                    );
+                  } ),
+              );
+            } ) || [],
+        );
+      } );
+
+      const backFixturePromises = backFixtures.map( async ( fixture, index ) => {
+        const fixtureConfig = await fixtureConfigService.findOne( { fixtureCategory: fixture.fixtureType } );
+        if ( !fixtureConfig ) return;
+        const fixtureConfigDoc = fixtureConfig.toObject();
+
+        const fixtureData = {
+          'clientId': layoutDoc.clientId,
+          'storeName': layoutDoc.storeName,
+          'storeId': layoutDoc.storeId,
+          'planoId': layoutDoc.planoId,
+          'floorId': layoutDoc._id,
+          'fixtureName': `Fixture ${index+1} - ${fixture.fixtureType}`,
+          'fixtureCategory': fixtureConfigDoc.fixtureConfigType,
+          'fixtureBrandCategory': fixture.fixtureSubname.length ? ( fixture.fixtureSubname.length > 1 ? fixture.fixtureSubname.join( ' + ' ) : fixture.fixtureSubname[0] ) : undefined,
+          'fixtureBrandSubCategory': fixture.fixtureSubname.length ? ( fixture.fixtureSubname.length > 1 ? fixture.fixtureSubname.join( ' + ' ) : fixture.fixtureSubname[0] ) : undefined,
+          'fixtureCode': fixtureConfigDoc?.fixtureCode,
+          'fixtureCapacity': fixtureConfigDoc?.fixtureCapacity,
+          'fixtureType': 'wall',
+          'fixtureHeight': {
+            'value': 0,
+            'unit': 'mm',
+          },
+          'fixtureLength': {
+            'value': constantFixtureWidth,
+            'unit': 'mm',
+          },
+          'fixtureWidth': {
+            'value': constantFixtureLength,
+            'unit': 'mm',
+          },
+          'associatedElementType': 'wall',
+          'associatedElementNumber': 2,
+          'relativePosition': {
+            'x': roundToTwo( ( finalXDistance - ( constantFixtureWidth/mmToFeet ) ) ),
+            'y': roundToTwo( ( ( index * ( ( constantFixtureLength/mmToFeet ) ) ) + ( ( leftFixtures.length ? 1 : 0 ) * constantFixtureWidth/mmToFeet ) ) ),
+            'unit': 'ft',
+          },
+          'fixtureNumber': fixtureCounter,
+          'detailedFixtureLength': {
+            'value': constantDetailedFixtureLength,
+            'unit': 'mm',
+          },
+          'detailedFixtureWidth': {
+            'value': constantDetailedFixtureWidth,
+            'unit': 'mm',
+          },
+          'relativeDetailedPosition': {
+            'x': roundToTwo( ( finalXDetailedDistance - ( constantDetailedFixtureLength/mmToFeet ) ) ),
+            'y': roundToTwo( ( ( index * ( ( constantDetailedFixtureWidth/mmToFeet ) ) ) + ( ( leftFixtures.length ? 1 : 0 ) * constantDetailedFixtureWidth/mmToFeet ) ) ),
+            'unit': 'ft',
+          },
+          'productResolutionLevel': 'L2',
+          'associatedElementFixtureNumber': index+1,
+          'header': fixture.header,
+          'footer': fixture.footer,
+          'fixtureConfigId': fixtureConfigDoc._id,
+        };
+
+        const createdFixture = await storeFixtureService.upsertOne(
+            {
+              floorId: layoutDoc._id,
+              fixtureNumber: fixtureCounter++,
+            },
+            fixtureData,
+        );
+
+        if ( !fixtureConfigDoc.shelfConfig.length || fixture.header === 'CL' || fixture.fixtureSubname?.includes( 'CL' ) ) return;
+
+        await Promise.all(
+            fixtureConfigDoc.shelfConfig.map( async ( configShelf, j ) => {
+              const shelfZone = fixture.productZones.find( ( zone ) => zone.zoneName === configShelf.shelfZone );
+              const shelfSection = shelfZone.products.find( ( product ) => !product.isMerchandisingElement );
+
+              const shelfData = {
+                'clientId': '11',
+                'storeName': layoutDoc.storeName,
+                'storeId': layoutDoc.storeId,
+                'planoId': layoutDoc.planoId,
+                'floorId': layoutDoc._id,
+                'fixtureId': createdFixture._id,
+                'shelfNumber': j + 1,
+                'shelfOrder': 'LTR',
+                'shelfCapacity': configShelf.shelfCapacity,
+                'sectionName': shelfSection?.productName ? shelfSection.productName : 'Unknown',
+                'sectionZone': configShelf.shelfZone,
+                'shelfSplitup': configShelf?.shelfSplitup ? configShelf.shelfSplitup : 0,
+              }; ;
+
+              await fixtureShelfService.upsertOne(
+                  {
+                    fixtureId: createdFixture._id,
+                    shelfNumber: j + 1,
+                  },
+                  shelfData,
+              );
+            } ),
+        );
+
+        await Promise.all(
+            fixture.productZones?.map( async ( zone ) => {
+              const vms = zone.products.filter( ( vm ) => vm.isMerchandisingElement );
+              const vmConfig = fixtureConfigDoc.vmConfig.filter( ( vm ) => vm.position === zone.zoneName );
+              const pids = zone.products.filter( ( vm ) => !vm.isMerchandisingElement );
+
+              await Promise.all(
+                  vms.map( async ( vm ) => {
+                    let configData = vmConfig[0];
+
+                    if ( vm.productName === 'Creatr' && zone.zoneName === 'Mid' ) {
+                      configData = vmConfig.find( ( config ) => config.vmWidthmm === 905 );
+                    }
+
+                    if ( vm.productName === 'Creatr' && zone.zoneName === 'Mid' && pids.length ) {
+                      configData = vmConfig.find( ( config ) => config.vmWidthmm === 230 );
+                    }
+
+                    if ( !configData ) return;
+
+                    const insertData = {
+                      'clientId': '11',
+                      'productId': 'VMCR',
+                      'type': 'vm',
+                      'productName': vm.productName,
+                      'productHeight': {
+                        'value': configData.vmHeightmm,
+                        'unit': 'mm',
+                      },
+                      'productWidth': {
+                        'value': configData.vmWidthmm,
+                        'unit': 'mm',
+                      },
+                      'startYPosition': configData.startShelf,
+                      'endYPosition': configData.endShelf,
+                      'xZone': configData.zone,
+                      'fixtureConfigId': fixtureConfig._id,
+                    };
+
+                    const vmTemplate = await planoProductService.upsertOne(
+                        {
+                          'productName': vm.productName,
+                          'fixtureConfigId': fixtureConfig._id,
+                          'productHeight.value': configData.vmHeightmm,
+                          'productWidth.value': configData.vmWidthmm,
+                          'startYPosition': configData.startShelf,
+                          'endYPosition': configData.endShelf,
+                          'xZone': configData.zone,
+                        },
+                        insertData,
+                    );
+
+                    const vmData = {
+                      'clientId': layoutDoc.clientId,
+                      'storeName': layoutDoc.storeName,
+                      'storeId': layoutDoc.storeId,
+                      'planoId': layoutDoc.planoId,
+                      'floorId': layoutDoc._id,
+                      'type': 'vm',
+                      'fixtureId': createdFixture._id,
+                      'productId': vmTemplate._id,
+                    };
+
+                    await planoMappingService.upsertOne(
+                        {
+                          fixtureId: createdFixture._id,
+                          productId: vmTemplate._id,
+                        },
+                        vmData,
+                    );
+                  } ),
+              );
+            } ) || [],
+        );
+      } );
+
+      const rightFixturePromises = rightFixtures.map( async ( fixture, index ) => {
+        const fixtureConfig = await fixtureConfigService.findOne( { fixtureCategory: fixture.fixtureType } );
+        if ( !fixtureConfig ) return;
+        const fixtureConfigDoc = fixtureConfig.toObject();
+
+        const fixtureData = {
+          'clientId': layoutDoc.clientId,
+          'storeName': layoutDoc.storeName,
+          'storeId': layoutDoc.storeId,
+          'planoId': layoutDoc.planoId,
+          'floorId': layoutDoc._id,
+          'fixtureName': `Fixture ${index+1} - ${fixture.fixtureType}`,
+          'fixtureCategory': fixtureConfigDoc.fixtureConfigType,
+          'fixtureBrandCategory': fixture.fixtureSubname.length ? ( fixture.fixtureSubname.length > 1 ? fixture.fixtureSubname.join( ' + ' ) : fixture.fixtureSubname[0] ) : undefined,
+          'fixtureBrandSubCategory': fixture.fixtureSubname.length ? ( fixture.fixtureSubname.length > 1 ? fixture.fixtureSubname.join( ' + ' ) : fixture.fixtureSubname[0] ) : undefined,
+          'fixtureCode': fixtureConfigDoc?.fixtureCode,
+          'fixtureCapacity': fixtureConfigDoc?.fixtureCapacity,
+          'fixtureType': 'wall',
+          'fixtureHeight': {
+            'value': 0,
+            'unit': 'mm',
+          },
+          'fixtureLength': {
+            'value': constantFixtureLength,
+            'unit': 'mm',
+          },
+          'fixtureWidth': {
+            'value': constantFixtureWidth,
+            'unit': 'mm',
+          },
+          'associatedElementType': 'wall',
+          'associatedElementNumber': 3,
+          'relativePosition': {
+            'x': roundToTwo( ( index * ( constantFixtureLength / mmToFeet ) ) ),
+            'y': roundToTwo( ( finalYDistance - ( constantFixtureWidth / mmToFeet ) ) ),
+            'unit': 'ft',
+          },
+          'fixtureNumber': fixtureCounter,
+          'detailedFixtureLength': {
+            'value': constantDetailedFixtureLength,
+            'unit': 'mm',
+          },
+          'detailedFixtureWidth': {
+            'value': constantDetailedFixtureWidth,
+            'unit': 'mm',
+          },
+          'relativeDetailedPosition': {
+            'x': roundToTwo( ( index * ( constantDetailedFixtureLength / mmToFeet ) ) ),
+            'y': roundToTwo( ( finalYDetailedDistance - ( constantDetailedFixtureWidth / mmToFeet ) ) ),
+            'unit': 'ft',
+          },
+          'productResolutionLevel': 'L2',
+          'associatedElementFixtureNumber': index+1,
+          'header': fixture.header,
+          'footer': fixture.footer,
+          'fixtureConfigId': fixtureConfigDoc._id,
+        };
+
+        const createdFixture = await storeFixtureService.upsertOne(
+            {
+              floorId: layoutDoc._id,
+              fixtureNumber: fixtureCounter++,
+            },
+            fixtureData,
+        );
+
+        if ( !fixtureConfigDoc.shelfConfig.length || fixture.header === 'CL' || fixture.fixtureSubname?.includes( 'CL' ) ) return;
+
+        await Promise.all(
+            fixtureConfigDoc.shelfConfig.map( async ( configShelf, j ) => {
+              const shelfZone = fixture.productZones.find( ( zone ) => zone.zoneName === configShelf.shelfZone );
+              const shelfSection = shelfZone.products.find( ( product ) => !product.isMerchandisingElement );
+
+              const shelfData = {
+                'clientId': '11',
+                'storeName': layoutDoc.storeName,
+                'storeId': layoutDoc.storeId,
+                'planoId': layoutDoc.planoId,
+                'floorId': layoutDoc._id,
+                'fixtureId': createdFixture._id,
+                'shelfNumber': j + 1,
+                'shelfOrder': 'LTR',
+                'shelfCapacity': configShelf.shelfCapacity,
+                'sectionName': shelfSection?.productName ? shelfSection.productName : 'Unknown',
+                'sectionZone': configShelf.shelfZone,
+                'shelfSplitup': configShelf?.shelfSplitup ? configShelf.shelfSplitup : 0,
+              };
+
+              await fixtureShelfService.upsertOne(
+                  {
+                    fixtureId: createdFixture._id,
+                    shelfNumber: j + 1,
+                  },
+                  shelfData,
+              );
+            } ),
+        );
+
+        await Promise.all(
+            fixture.productZones?.map( async ( zone ) => {
+              const vms = zone.products.filter( ( vm ) => vm.isMerchandisingElement );
+              const vmConfig = fixtureConfigDoc.vmConfig.filter( ( vm ) => vm.position === zone.zoneName );
+              const pids = zone.products.filter( ( vm ) => !vm.isMerchandisingElement );
+
+              await Promise.all(
+                  vms.map( async ( vm ) => {
+                    let configData = vmConfig[0];
+
+                    if ( vm.productName === 'Creatr' && zone.zoneName === 'Mid' ) {
+                      configData = vmConfig.find( ( config ) => config.vmWidthmm === 905 );
+                    }
+
+                    if ( vm.productName === 'Creatr' && zone.zoneName === 'Mid' && pids.length ) {
+                      configData = vmConfig.find( ( config ) => config.vmWidthmm === 230 );
+                    }
+
+                    if ( !configData ) return;
+
+                    const insertData = {
+                      'clientId': '11',
+                      'productId': 'VMCR',
+                      'type': 'vm',
+                      'productName': vm.productName,
+                      'productHeight': {
+                        'value': configData.vmHeightmm,
+                        'unit': 'mm',
+                      },
+                      'productWidth': {
+                        'value': configData.vmWidthmm,
+                        'unit': 'mm',
+                      },
+                      'startYPosition': configData.startShelf,
+                      'endYPosition': configData.endShelf,
+                      'xZone': configData.zone,
+                      'fixtureConfigId': fixtureConfig._id,
+                    };
+
+                    const vmTemplate = await planoProductService.upsertOne(
+                        {
+                          'productName': vm.productName,
+                          'fixtureConfigId': fixtureConfig._id,
+                          'productHeight.value': configData.vmHeightmm,
+                          'productWidth.value': configData.vmWidthmm,
+                          'startYPosition': configData.startShelf,
+                          'endYPosition': configData.endShelf,
+                          'xZone': configData.zone,
+                        },
+                        insertData,
+                    );
+
+                    const vmData = {
+                      'clientId': layoutDoc.clientId,
+                      'storeName': layoutDoc.storeName,
+                      'storeId': layoutDoc.storeId,
+                      'planoId': layoutDoc.planoId,
+                      'floorId': layoutDoc._id,
+                      'type': 'vm',
+                      'fixtureId': createdFixture._id,
+                      'productId': vmTemplate._id,
+                    };
+
+                    await planoMappingService.upsertOne(
+                        {
+                          fixtureId: createdFixture._id,
+                          productId: vmTemplate._id,
+                        },
+                        vmData,
+                    );
+                  } ),
+              );
+            } ) || [],
+        );
+      } );
+
+      const floorFixturePromises = floorFixtures.map( async ( fixture, index ) => {
+        const centerRow = Math.floor( totalRows / 2 );
+
+        const startingX = roundToTwo( ( finalXDistance / 2 - ( maxFixturesPerRow / 2 ) * ( constantFixtureLength / mmToFeet ) ) );
+        const detailedStartingX = roundToTwo( ( finalXDetailedDistance / 2 - ( maxFixturesPerRow / 2 ) * ( constantDetailedFixtureLength / mmToFeet ) ) );
+
+        const startingY = finalYDistance / 2 - centerRow * ( constantFixtureWidth / mmToFeet );
+        const detailedStartingY = finalYDetailedDistance / 2 - centerRow * ( constantDetailedFixtureWidth / mmToFeet );
+
+        const colIndex = Math.floor( index / 2 );
+        const rowIndex = index % 2 === 0 ? 1 : 0;
+
+        const xPos = roundToTwo( startingX + colIndex * ( constantFixtureLength / mmToFeet ) );
+        const yPos = roundToTwo( startingY + rowIndex * ( constantFixtureWidth / mmToFeet ) );
+
+        const detailedXPos = roundToTwo( ( detailedStartingX + colIndex * ( constantDetailedFixtureLength / mmToFeet ) ) );
+        const detailedYPos = roundToTwo( ( detailedStartingY + rowIndex * ( constantDetailedFixtureWidth / mmToFeet ) ) );
+
+        console.log( fixture );
+
+        console.log( fixture.main );
+        const fixtureConfig = await fixtureConfigService.findOne( { fixtureCategory: fixture.main } );
+        if ( !fixtureConfig ) return;
+
+        const fixtureConfigDoc = fixtureConfig.toObject();
+
+        console.log( fixtureConfigDoc );
+
+        const fixtureData = {
+          'clientId': layoutDoc.clientId,
+          'storeName': layoutDoc.storeName,
+          'storeId': layoutDoc.storeId,
+          'planoId': layoutDoc.planoId,
+          'floorId': layoutDoc._id,
+          'fixtureName': `Fixture ${index+1} - ${fixture.main}`,
+          'fixtureCategory': fixtureConfigDoc.fixtureConfigType,
+          'fixtureBrandCategory': fixture.centerSubMain ? fixture.centerSubMain : undefined,
+          'fixtureBrandSubCategory': fixture.centerSubMain ? fixture.centerSubMain : undefined,
+          'fixtureCode': fixtureConfigDoc?.fixtureCode,
+          'fixtureCapacity': fixtureConfigDoc?.fixtureCapacity,
+          'fixtureType': 'floor',
+          'fixtureHeight': {
+            'value': 0,
+            'unit': 'mm',
+          },
+          'fixtureLength': {
+            'value': constantFixtureLength,
+            'unit': 'mm',
+          },
+          'fixtureWidth': {
+            'value': constantFixtureWidth,
+            'unit': 'mm',
+          },
+          'relativePosition': {
+            'x': xPos,
+            'y': yPos,
+            'unit': 'ft',
+          },
+          'fixtureNumber': fixtureCounter,
+          'detailedFixtureLength': {
+            'value': constantDetailedFixtureLength,
+            'unit': 'mm',
+          },
+          'detailedFixtureWidth': {
+            'value': constantDetailedFixtureWidth,
+            'unit': 'mm',
+          },
+          'relativeDetailedPosition': {
+            'x': detailedXPos,
+            'y': detailedYPos,
+            'unit': 'ft',
+          },
+          'productResolutionLevel': 'L2',
+          'associatedElementFixtureNumber': index+1,
+          'fixtureConfigId': fixtureConfigDoc._id,
+        };
+
+        console.log( fixtureData );
+
+
+        const createdFixture = await storeFixtureService.upsertOne(
+            {
+              floorId: layoutDoc._id,
+              fixtureNumber: fixtureCounter++,
+            },
+            fixtureData,
+        );
+
+        if ( !fixtureConfigDoc.shelfConfig.length || fixture.header === 'CL' || fixture.fixtureSubname?.includes( 'CL' ) ) return;
+
+        await Promise.all(
+            fixtureConfigDoc.shelfConfig.map( async ( configShelf, j ) => {
+              const shelfSection = fixture.centerSuperSubMain.find(
+                  ( product ) => product.isVisualMerchandiser === false || product.isVisualMerchandiser === true,
+              );
+
+              const shelfData = {
+                'clientId': '11',
+                'storeName': layoutDoc.storeName,
+                'storeId': layoutDoc.storeId,
+                'planoId': layoutDoc.planoId,
+                'floorId': layoutDoc._id,
+                'fixtureId': createdFixture._id,
+                'shelfNumber': j + 1,
+                'shelfOrder': 'LTR',
+                'shelfCapacity': configShelf.shelfCapacity,
+                'sectionName': fixture.centerSuperSubMain.find( ( product ) => product.isVisualMerchandiser === true ) ? shelfSection?.name + ' PIDs' : shelfSection?.name,
+                'shelfSplitup': configShelf?.shelfSplitup ? configShelf.shelfSplitup : 0,
+              };
+
+              await fixtureShelfService.upsertOne(
+                  {
+                    fixtureId: createdFixture._id,
+                    shelfNumber: j + 1,
+                  },
+                  shelfData,
+              );
+            } ),
+        );
+
+        const vm = fixture.centerSuperSubMain.find( ( vm ) => vm.isVisualMerchandiser );
+        const vmConfig = fixtureConfigDoc.vmConfig;
+
+        if ( vm ) {
+          const [ configData1, configData2 ] = [ vmConfig[0], vmConfig[1] ];
+
+          const insertData1 = {
+            'clientId': '11',
+            'productId': 'VMCR',
+            'type': 'vm',
+            'productName': vm.name,
+            'productHeight': {
+              'value': configData1.vmHeightmm,
+              'unit': 'mm',
+            },
+            'productWidth': {
+              'value': configData1.vmWidthmm,
+              'unit': 'mm',
+            },
+            'startYPosition': configData1.startShelf,
+            'endYPosition': configData1.endShelf,
+            'xZone': configData1.zone,
+            'fixtureConfigId': fixtureConfig._id,
+          };
+          const insertData2 = {
+            'clientId': '11',
+            'productId': 'VMCR',
+            'type': 'vm',
+            'productName': ' ',
+            'productHeight': {
+              'value': configData2.vmHeightmm,
+              'unit': 'mm',
+            },
+            'productWidth': {
+              'value': configData2.vmWidthmm,
+              'unit': 'mm',
+            },
+            'startYPosition': configData2.startShelf,
+            'endYPosition': configData2.endShelf,
+            'xZone': configData2.zone,
+            'fixtureConfigId': fixtureConfig._id,
+          };
+
+          const [ vmTemplate1, vmTemplate2 ] = await Promise.all( [
+            planoProductService.upsertOne(
+                {
+                  'productName': vm.name,
+                  'fixtureConfigId': fixtureConfig._id,
+                  'productHeight.value': configData1.vmHeightmm,
+                  'productWidth.value': configData1.vmWidthmm,
+                  'startYPosition': configData1.startShelf,
+                  'endYPosition': configData1.endShelf,
+                  'xZone': configData1.zone,
+                },
+                insertData1,
+            ),
+            planoProductService.upsertOne(
+                {
+                  'productName': ' ',
+                  'fixtureConfigId': fixtureConfig._id,
+                  'productHeight.value': configData2.vmHeightmm,
+                  'productWidth.value': configData2.vmWidthmm,
+                  'startYPosition': configData2.startShelf,
+                  'endYPosition': configData2.endShelf,
+                  'xZone': configData2.zone,
+                },
+                insertData2,
+            ),
+          ] );
+
+          const vmData1 = {
+            'clientId': layoutDoc.clientId,
+            'storeName': layoutDoc.storeName,
+            'storeId': layoutDoc.storeId,
+            'planoId': layoutDoc.planoId,
+            'floorId': layoutDoc._id,
+            'type': 'vm',
+            'fixtureId': createdFixture._id,
+            'productId': vmTemplate1._id,
+          };
+          const vmData2 = {
+            'clientId': layoutDoc.clientId,
+            'storeName': layoutDoc.storeName,
+            'storeId': layoutDoc.storeId,
+            'planoId': layoutDoc.planoId,
+            'floorId': layoutDoc._id,
+            'type': 'vm',
+            'fixtureId': createdFixture._id,
+            'productId': vmTemplate2._id,
+          };
+
+          await Promise.all( [
+            planoMappingService.upsertOne(
+                {
+                  fixtureId: createdFixture._id,
+                  productId: vmTemplate1._id,
+                },
+                vmData1,
+            ),
+            planoMappingService.upsertOne(
+                {
+                  fixtureId: createdFixture._id,
+                  productId: vmTemplate2._id,
+                },
+                vmData2,
+            ),
+          ] );
+        }
+      } );
+
+      await Promise.all( [ ...frontFixturePromises, ...leftFixturePromises, ...backFixturePromises, ...rightFixturePromises, ...floorFixturePromises ] );
+
+      const now = Date.now();
+      const elapsedMinutes = ( now - startTime ) / 1000 / 60;
+      console.log( `Store name: ${storeData.storeName}, Iteration ${i + 1}: total elapsed time = ${elapsedMinutes.toFixed( 2 )} minutes` );
+    }
+
+    res.sendSuccess( finalData );
+  } catch ( e ) {
+    logger.error( { functionName: 'updateCrestPlanogram', error: e } );
+    return res.sendError( e.message || 'Internal Server Error', 500 );
+  }
+}