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

package/src/controllers/script.controller.js

@@ -19,6 +19,12 @@ 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';
+
+const __filename = fileURLToPath( import.meta.url );
+const __dirname = path.dirname( __filename );
 
 
 export async function getStoreNames( req, res ) {
@@ -2650,12 +2656,18 @@ export async function createCrestPlanogram( req, res ) {
         for ( let i = 0; i < fixture.productZones?.length; i++ ) {
           const vms = fixture.productZones[i].products.filter( ( vm ) => vm.isMerchandisingElement );
           const vmConfig = fixtureConfigDoc.vmConfig.filter( ( vm ) => vm.position === fixture.productZones[i].zoneName );
+          const pids = fixture.productZones[i].products.filter( ( vm ) => !vm.isMerchandisingElement );
+
 
           for ( const vm of vms ) {
             let configData = vmConfig[0];
 
             if ( vm.productName === 'Creatr' && fixture.productZones[i].zoneName === 'Mid' ) {
-              configData = vmConfig.find( ( config ) => config.vmNumber === 3 );
+              configData = vmConfig.find( ( config ) => config.vmWidthmm === 905 );
+            }
+
+            if ( vm.productName === 'Creatr' && fixture.productZones[i].zoneName === 'Mid' && pids.length ) {
+              configData = vmConfig.find( ( config ) => config.vmWidthmm === 230 );
             }
 
             if ( !configData ) continue;
@@ -2809,12 +2821,17 @@ export async function createCrestPlanogram( req, res ) {
         for ( let i = 0; i < fixture.productZones?.length; i++ ) {
           const vms = fixture.productZones[i].products.filter( ( vm ) => vm.isMerchandisingElement );
           const vmConfig = fixtureConfigDoc.vmConfig.filter( ( vm ) => vm.position === fixture.productZones[i].zoneName );
+          const pids = fixture.productZones[i].products.filter( ( vm ) => !vm.isMerchandisingElement );
 
           for ( const vm of vms ) {
             let configData = vmConfig[0];
 
             if ( vm.productName === 'Creatr' && fixture.productZones[i].zoneName === 'Mid' ) {
-              configData = vmConfig.find( ( config ) => config.vmNumber === 3 );
+              configData = vmConfig.find( ( config ) => config.vmWidthmm === 905 );
+            }
+
+            if ( vm.productName === 'Creatr' && fixture.productZones[i].zoneName === 'Mid' && pids.length ) {
+              configData = vmConfig.find( ( config ) => config.vmWidthmm === 230 );
             }
 
 
@@ -2969,13 +2986,19 @@ export async function createCrestPlanogram( req, res ) {
         for ( let i = 0; i < fixture.productZones?.length; i++ ) {
           const vms = fixture.productZones[i].products.filter( ( vm ) => vm.isMerchandisingElement );
           const vmConfig = fixtureConfigDoc.vmConfig.filter( ( vm ) => vm.position === fixture.productZones[i].zoneName );
+          const pids = fixture.productZones[i].products.filter( ( vm ) => !vm.isMerchandisingElement );
+
 
           for ( const vm of vms ) {
             let configData = vmConfig[0];
 
 
             if ( vm.productName === 'Creatr' && fixture.productZones[i].zoneName === 'Mid' ) {
-              configData = vmConfig.find( ( config ) => config.vmNumber === 3 );
+              configData = vmConfig.find( ( config ) => config.vmWidthmm === 905 );
+            }
+
+            if ( vm.productName === 'Creatr' && fixture.productZones[i].zoneName === 'Mid' && pids.length ) {
+              configData = vmConfig.find( ( config ) => config.vmWidthmm === 230 );
             }
 
 
@@ -3289,6 +3312,249 @@ export async function updateCrestVms( req, res ) {
   }
 }
 
+
+async function filterStores() {
+  const stores = [
+    'ST338', 'LKST1304', 'ST303', 'LKST1228', 'LKST499', 'LKST479', 'ST320',
+    'LKST515', 'LKST406', 'ST392', 'ST328', 'ST332', 'LKST487', 'ST312',
+    'LKST615', 'LKST352', 'LKST457', 'LKST439', 'LKST347', 'LKST1084',
+    'LKST380', 'ST298', 'LKST356', 'LKST223', 'LKST480', 'ST30', 'ST285',
+    'LKST500', 'LKST466', 'LKST321', 'LKST678', 'LKST383', 'LKST365',
+    'LKST374', 'ST302', 'LKST420', 'LKST394', 'LKST444', 'LKST314',
+    'LKST01', 'LKST357', 'LKST465', 'LKST331', 'LKST440', 'LKST345',
+    'LKST389', 'ST330', 'LKST299', 'ST244', 'LKST294', 'ST314', 'LKST361',
+    'LKST377', 'LKST390', 'ST335', 'LKST416', 'ST293', 'LKST341', 'LKST501',
+    'LKST408', 'LKST227', 'LKST353', 'LKST364', 'ST318', 'LKST326',
+    'LKST344', 'ST321', 'LKST384', 'LKST496', 'LKST427', 'LKST325',
+    'LKST282', 'ST197', 'LKST388', 'LKST338', 'LKST371', 'ST326', 'LKST428',
+    'LKST112', 'LKST334', 'ST319', 'LKST464', 'LKST490', 'LKST11',
+    'LKST502', 'LKST1438',
+  ];
+
+  const rawData = fs.readFileSync( 'crest_scrap_v1.json', 'utf8' );
+  const allStores = JSON.parse( rawData );
+
+  const filteredStores = allStores.filter( ( store ) => stores.includes( store.storeName ) );
+
+  fs.writeFileSync( 'crest_filtered.json', JSON.stringify( filteredStores, null, 2 ) );
+}
+
+import fsp from 'fs/promises';
+
+import sharp from 'sharp';
+
+
+const stitchImagesFromZips = async () => {
+  const zip1Path = 'crest_plano.zip';
+  const zip2Path = 'tango_plano.zip';
+  const outputDir = 'stitched';
+
+  const loadZip = async ( zipPath ) => {
+    const buffer = await fsp.readFile( zipPath );
+    return await JSZip.loadAsync( buffer );
+  };
+
+  const extractImages = async ( zip ) => {
+    const imageFiles = {};
+    const imageRegex = /\.(png|jpe?g)$/i;
+
+    for ( const [ name, file ] of Object.entries( zip.files ) ) {
+      const base = path.basename( name );
+      if ( !file.dir && imageRegex.test( base ) ) {
+        imageFiles[base] = await file.async( 'nodebuffer' );
+      }
+    }
+
+    return imageFiles;
+  };
+
+  const stitchOrCenter = async ( buffer1, buffer2, outputPath ) => {
+    const totalWidth = 7000;
+    const width1 = Math.round( totalWidth * 0.3 );
+    const width2 = Math.round( totalWidth * 0.7 );
+
+    let img1 = buffer1 ? await sharp( buffer1 ).resize( { width: width1 } ).toBuffer() : null;
+    let img2 = buffer2 ? await sharp( buffer2 ).resize( { width: width2 } ).toBuffer() : null;
+
+    const [ meta1, meta2 ] = await Promise.all( [
+      img1 ? sharp( img1 ).metadata() : Promise.resolve( { height: 0 } ),
+      img2 ? sharp( img2 ).metadata() : Promise.resolve( { height: 0 } ),
+    ] );
+
+    const maxHeight = Math.max( meta1.height, meta2.height );
+
+    const composites = [];
+    if ( img1 ) composites.push( { input: img1, top: 0, left: 0 } );
+    if ( img2 ) composites.push( { input: img2, top: 0, left: width1 } );
+
+    await sharp( {
+      create: {
+        width: totalWidth,
+        height: maxHeight,
+        channels: 4,
+        background: { r: 255, g: 255, b: 255, alpha: 0 },
+      },
+    } )
+        .composite( composites )
+        .png()
+        .toFile( outputPath );
+  };
+
+  try {
+    await fsp.mkdir( outputDir, { recursive: true } );
+
+    const [ zip1, zip2 ] = await Promise.all( [ loadZip( zip1Path ), loadZip( zip2Path ) ] );
+    const [ images1, images2 ] = await Promise.all( [ extractImages( zip1 ), extractImages( zip2 ) ] );
+
+    const allFilenames = new Set( [ ...Object.keys( images1 ), ...Object.keys( images2 ) ] );
+
+    for ( const name of allFilenames ) {
+      const buffer1 = images1[name] || null;
+      const buffer2 = images2[name] || null;
+      const outputPath = path.join( outputDir, `${name.replace( /\.[^/.]+$/, '' )}.png` );
+
+      try {
+        await stitchOrCenter( buffer1, buffer2, outputPath );
+        console.log( ` Processed: ${name}` );
+      } catch ( err ) {
+        console.error( ` Error processing ${name}:`, err.message );
+      }
+    }
+  } catch ( err ) {
+    console.error( ' Unexpected error:', err.message );
+  }
+};
+
+// stitchImagesFromZips();
+
+
+import { Builder, By, until } from 'selenium-webdriver';
+import chrome from 'selenium-webdriver/chrome.js';
+import fetch from 'node-fetch';
+
+import fetchCookie from 'fetch-cookie';
+
+
+async function downloadCrestImages() {
+  const storeList = await planoService.find( {} );
+  const storeIds = storeList.map( ( store ) => store.toObject().storeName );
+
+  const invalidateUrl = 'https://app.getcrest.ai/api/ms_iam/user/session/override/';
+  const tokenUrl = 'https://app.getcrest.ai/api/ms_iam/token/';
+
+  let authToken = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ0b2tlbl90eXBlIjoiYWNjZXNzIiwiZXhwIjoxNzQ0NzE4MjUzLCJpYXQiOjE3NDQ3MTQ2NTMsImp0aSI6Ijk5ZTAyYjU4ODg2NjQ3MDk4Y2NlY2NmODZlYzYzYTU4IiwidXNlcl9pZCI6MTA4NSwiaWQiOjEwODUsImN1c3RvbWVyX2dyb3VwIjozOTgsImxpY2VuY2Vfc2NvcGVzIjpbeyJyZXNvdXJjZV9zZXQiOiJwcF9zZXQiLCJzY29wZV9yb2xlIjoiY29udHJpYnV0b3IifSx7InJlc291cmNlX3NldCI6ImRwX3NldCIsInNjb3BlX3JvbGUiOiJjb250cmlidXRvciJ9LHsicmVzb3VyY2Vfc2V0IjoiZGZfc2V0Iiwic2NvcGVfcm9sZSI6ImNvbnRyaWJ1dG9yIn0seyJyZXNvdXJjZV9zZXQiOiJkZWZhdWx0X3NldCIsInNjb3BlX3JvbGUiOiJjb250cmlidXRvciJ9XX0.7g1XS48l7mVsOcDXHLC7VFLFyJ-p13e2kkJlb8uFc_g';
+
+  const fetchWithCookies = fetchCookie( fetch );
+
+  async function fetchNewToken() {
+    const invalidate = await fetchWithCookies( invalidateUrl, {
+      'method': 'POST',
+      'headers': { 'Content-Type': 'application/json' },
+      'body': JSON.stringify( { 'email': 'tango.lenskart@getcrest.ai', 'password': 'Tangolenskart@123' } ),
+    } );
+
+    const invalidateData = await invalidate.json();
+
+    console.log( invalidateData );
+
+    console.log( 'Fetching new token...' );
+    const res = await fetchWithCookies( tokenUrl, {
+      'method': 'POST',
+      'Accept': 'application/json, text/javascript, */*; q=0.01',
+      'headers': { 'Content-Type': 'application/json' },
+      'body': JSON.stringify( { 'email': 'tango.lenskart@getcrest.ai', 'password': 'Tangolenskart@123' } ),
+    } );
+
+    if ( !res.ok ) {
+      throw new Error( `Failed to fetch token: ${res.status}` );
+    }
+
+    const data = await res.json();
+    console.log( data );
+    authToken = data.access;
+    return authToken;
+  }
+
+  async function runAutomation( token, storeId, retries = 3 ) {
+    let attempts = 0;
+
+    while ( attempts < retries ) {
+      const options = new chrome.Options();
+      options.addArguments( 'headless' );
+      options.addArguments( 'disable-gpu' );
+
+      const driver = await new Builder()
+          .forBrowser( 'chrome' )
+          .setChromeOptions( options )
+          .build();
+
+      try {
+        const url = `https://app.getcrest.ai/pvt/?auth=${token}&module=planno&store_id=${storeId}`;
+        await driver.get( url );
+        const currentUrl = await driver.getCurrentUrl();
+        if ( currentUrl.includes( '/login' ) ) {
+          console.warn( `Redirected to login for store ${storeId}. Retrying with new token...` );
+          await driver.quit();
+          const newToken = await fetchNewToken();
+          return await runAutomation( newToken, storeId, retries );
+        }
+
+        const button = await driver.wait( until.elementLocated(
+            By.xpath( '//*[contains(@class, "MuiButtonBase-root") and contains(@class, "MuiButton-root") and contains(@class, "MuiButton-text") and contains(@class, "MuiButton-disableElevation") and contains(@class, "jss35") and contains(@class, "jss47") and contains(@class, "jss37") and contains(@class, "jss144")]' ),
+        ), 10000 );
+        await button.click();
+
+        const checkbox = await driver.wait(
+            until.elementLocated(
+                By.xpath( '//*[contains(@class, "MuiCheckbox-root") and contains(@class, "MuiIconButton-root")]//input[@type="checkbox"]' ),
+            ),
+            10000,
+        );
+        await checkbox.click();
+
+        const downloadIcon = await driver.wait(
+            until.elementLocated(
+                By.xpath( '//button[contains(@class, "cool-tooltip")]' ),
+            ),
+            10000,
+        );
+        await downloadIcon.click();
+
+
+        console.log( `Download triggered for store: ${storeId}` );
+        await driver.sleep( 5000 );
+        return;
+      } catch ( err ) {
+        attempts++;
+        console.error( `Error for store ${storeId}, attempt ${attempts}: ${err.message}` );
+        if ( attempts >= retries ) {
+          console.error( `Failed for store ${storeId} after ${retries} attempts` );
+        } else {
+          console.log( `Retrying for store ${storeId}, attempt ${attempts + 1}` );
+        }
+      } finally {
+        try {
+          if ( driver && ( await driver.getSession() ) ) {
+            await driver.quit();
+          }
+        } catch ( e ) {
+
+        }
+      }
+    }
+  }
+
+  for ( const storeId of storeIds ) {
+    try {
+      console.log( `Starting automation for store: ${storeId}` );
+      await runAutomation( authToken, storeId );
+    } catch ( error ) {
+      console.error( `Automation failed for store ${storeId}: ${error.message}` );
+    }
+  }
+}
+
+// downloadCrestImages();
 export async function updatePlanoFixtureLayout( planoId, floorId ) {
   try {
     console.log( 'dfghj' );
@@ -3305,337 +3571,339 @@ export async function updatePlanoFixtureLayout( planoId, floorId ) {
     }
 
     const insertedPlano = await planoService.findOne( { _id: planoId } );
+    if ( insertedPlano ) {
+      const planoDoc = insertedPlano.toObject();
 
-    const planoDoc = insertedPlano.toObject();
-
-    const fixtureData = await storeFixtureService.findAndSort( { planoId: planoId, floorId: floorId }, {}, { fixtureNumber: 1 } );
+      const fixtureData = await storeFixtureService.findAndSort( { planoId: planoId, floorId: floorId }, {}, { fixtureNumber: 1 } );
 
-    const leftFixtures = fixtureData.filter( ( fixture ) => fixture.associatedElementType == 'wall' && fixture.associatedElementNumber == 1 );
-    const rightFixtures = fixtureData.filter( ( fixture ) => fixture.associatedElementType == 'wall' && fixture.associatedElementNumber == 3 );
-    const backFixtures = fixtureData.filter( ( fixture ) => fixture.associatedElementType == 'wall' && fixture.associatedElementNumber == 2 );
-    const floorFixtures = fixtureData.filter( ( fixture ) => fixture.fixtureType == 'floor' );
+      const leftFixtures = fixtureData.filter( ( fixture ) => fixture.associatedElementType == 'wall' && fixture.associatedElementNumber == 1 );
+      const rightFixtures = fixtureData.filter( ( fixture ) => fixture.associatedElementType == 'wall' && fixture.associatedElementNumber == 3 );
+      const backFixtures = fixtureData.filter( ( fixture ) => fixture.associatedElementType == 'wall' && fixture.associatedElementNumber == 2 );
+      const floorFixtures = fixtureData.filter( ( fixture ) => fixture.fixtureType == 'floor' );
 
-    // console.log( leftFixtures, 'left' );
-    // console.log( rightFixtures, 'rightFixtures' );
-    // console.log( backFixtures, 'backFixtures' );
-    // console.log( floorFixtures, 'floorFixtures' );
+      // console.log( leftFixtures, 'left' );
+      // console.log( rightFixtures, 'rightFixtures' );
+      // console.log( backFixtures, 'backFixtures' );
+      // console.log( floorFixtures, 'floorFixtures' );
 
-    const leftXDistanceFeet = leftFixtures.length ? roundToTwo( ( leftFixtures.length * ( constantFixtureLength / mmToFeet ) ) ) : 0;
-    const leftXDetailedDistanceFeet = leftFixtures.length ? roundToTwo( ( leftFixtures.length * ( constantDetailedFixtureLength / mmToFeet ) ) ) : 0;
+      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 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 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 rightYDistanceFeet = rightFixtures.length ? roundToTwo( ( constantFixtureWidth / mmToFeet ) ) : 0;
+      const rightYDetailedDistanceFeet = rightFixtures.length ? roundToTwo( ( constantDetailedFixtureWidth / mmToFeet ) ): 0;
 
-    const maxFixturesPerRow = floorFixtures.length/2;
-    const totalRows = 2;
+      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 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 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 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 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 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 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 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 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,
-    };
-
-    await storeBuilderService.upsertOne( { planoId: planoDoc._id }, floorInsertData );
-
-    for ( let index = 0; index < leftFixtures.length; index++ ) {
-      const fixture = leftFixtures[index];
-
-      const fixtureData = {
-        'fixtureHeight': {
-          'value': 0,
-          'unit': 'mm',
-        },
-        'fixtureLength': {
-          'value': constantFixtureLength,
-          'unit': 'mm',
-        },
-        'fixtureWidth': {
-          'value': constantFixtureWidth,
-          'unit': 'mm',
-        },
-        'relativePosition': {
-          'x': roundToTwo( ( index * ( constantFixtureLength / mmToFeet ) ) ),
-          'y': 0,
-          'unit': 'ft',
-        },
-        'detailedFixtureLength': {
-          'value': constantDetailedFixtureLength,
-          'unit': 'mm',
-        },
-        'detailedFixtureWidth': {
-          'value': constantDetailedFixtureWidth,
-          'unit': 'mm',
-        },
-        'relativeDetailedPosition': {
-          'x': roundToTwo( ( index * ( constantDetailedFixtureLength / mmToFeet ) ) ),
-          'y': 0,
-          'unit': 'ft',
-        },
+      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,
       };
 
-      await storeFixtureService.updateOne(
-          {
-            _id: fixture._id,
+      await storeBuilderService.upsertOne( { planoId: planoDoc._id }, floorInsertData );
+
+      for ( let index = 0; index < leftFixtures.length; index++ ) {
+        const fixture = leftFixtures[index];
+
+        const fixtureData = {
+          'fixtureHeight': {
+            'value': 0,
+            'unit': 'mm',
           },
-          fixtureData );
-    }
+          'fixtureLength': {
+            'value': constantFixtureLength,
+            'unit': 'mm',
+          },
+          'fixtureWidth': {
+            'value': constantFixtureWidth,
+            'unit': 'mm',
+          },
+          'relativePosition': {
+            'x': roundToTwo( ( index * ( constantFixtureLength / mmToFeet ) ) ),
+            'y': 0,
+            'unit': 'ft',
+          },
+          'detailedFixtureLength': {
+            'value': constantDetailedFixtureLength,
+            'unit': 'mm',
+          },
+          'detailedFixtureWidth': {
+            'value': constantDetailedFixtureWidth,
+            'unit': 'mm',
+          },
+          'relativeDetailedPosition': {
+            'x': roundToTwo( ( index * ( constantDetailedFixtureLength / mmToFeet ) ) ),
+            'y': 0,
+            'unit': 'ft',
+          },
+        };
 
-    for ( let index = 0; index < backFixtures.length; index++ ) {
-      const fixture = backFixtures[index];
+        await storeFixtureService.updateOne(
+            {
+              _id: fixture._id,
+            },
+            fixtureData );
+      }
 
-      const fixtureData = {
-        'fixtureHeight': {
-          'value': 0,
-          'unit': 'mm',
-        },
-        'fixtureLength': {
-          'value': constantFixtureWidth,
-          'unit': 'mm',
-        },
-        'fixtureWidth': {
-          'value': constantFixtureLength,
-          'unit': 'mm',
-        },
-        'relativePosition': {
-          'x': roundToTwo( ( finalXDistance - ( constantFixtureWidth/mmToFeet ) ) ),
-          'y': roundToTwo( ( ( index * ( ( constantFixtureLength/mmToFeet ) ) ) + ( ( leftFixtures.length ? 1 : 0 ) * constantFixtureWidth/mmToFeet ) ) ),
-          'unit': 'ft',
-        },
-        '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',
-        },
-      };
+      for ( let index = 0; index < backFixtures.length; index++ ) {
+        const fixture = backFixtures[index];
 
-      await storeFixtureService.updateOne(
-          {
-            _id: fixture._id,
+        const fixtureData = {
+          'fixtureHeight': {
+            'value': 0,
+            'unit': 'mm',
           },
-          fixtureData );
-    }
+          'fixtureLength': {
+            'value': constantFixtureWidth,
+            'unit': 'mm',
+          },
+          'fixtureWidth': {
+            'value': constantFixtureLength,
+            'unit': 'mm',
+          },
+          'relativePosition': {
+            'x': roundToTwo( ( finalXDistance - ( constantFixtureWidth/mmToFeet ) ) ),
+            'y': roundToTwo( ( ( index * ( ( constantFixtureLength/mmToFeet ) ) ) + ( ( leftFixtures.length ? 1 : 0 ) * constantFixtureWidth/mmToFeet ) ) ),
+            'unit': 'ft',
+          },
+          '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',
+          },
+        };
 
-    for ( let index = 0; index < rightFixtures.length; index++ ) {
-      const fixture = rightFixtures[index];
+        await storeFixtureService.updateOne(
+            {
+              _id: fixture._id,
+            },
+            fixtureData );
+      }
 
-      const fixtureData = {
-        'fixtureHeight': {
-          'value': 0,
-          'unit': 'mm',
-        },
-        'fixtureLength': {
-          'value': constantFixtureLength,
-          'unit': 'mm',
-        },
-        'fixtureWidth': {
-          'value': constantFixtureWidth,
-          'unit': 'mm',
-        },
-        'relativePosition': {
-          'x': roundToTwo( ( index * ( constantFixtureLength / mmToFeet ) ) ),
-          'y': roundToTwo( ( finalYDistance - ( constantFixtureWidth / mmToFeet ) ) ),
-          'unit': 'ft',
-        },
-        'detailedFixtureLength': {
-          'value': constantDetailedFixtureLength,
-          'unit': 'mm',
-        },
-        'detailedFixtureWidth': {
-          'value': constantDetailedFixtureWidth,
-          'unit': 'mm',
-        },
-        'relativeDetailedPosition': {
-          'x': roundToTwo( ( index * ( constantDetailedFixtureLength / mmToFeet ) ) ),
-          'y': roundToTwo( ( finalYDetailedDistance - ( constantDetailedFixtureWidth / mmToFeet ) ) ),
-          'unit': 'ft',
-        },
-      };
+      for ( let index = 0; index < rightFixtures.length; index++ ) {
+        const fixture = rightFixtures[index];
 
-      await storeFixtureService.updateOne(
-          {
-            _id: fixture._id,
+        const fixtureData = {
+          'fixtureHeight': {
+            'value': 0,
+            'unit': 'mm',
           },
-          fixtureData );
-    }
+          'fixtureLength': {
+            'value': constantFixtureLength,
+            'unit': 'mm',
+          },
+          'fixtureWidth': {
+            'value': constantFixtureWidth,
+            'unit': 'mm',
+          },
+          'relativePosition': {
+            'x': roundToTwo( ( index * ( constantFixtureLength / mmToFeet ) ) ),
+            'y': roundToTwo( ( finalYDistance - ( constantFixtureWidth / mmToFeet ) ) ),
+            'unit': 'ft',
+          },
+          'detailedFixtureLength': {
+            'value': constantDetailedFixtureLength,
+            'unit': 'mm',
+          },
+          'detailedFixtureWidth': {
+            'value': constantDetailedFixtureWidth,
+            'unit': 'mm',
+          },
+          'relativeDetailedPosition': {
+            'x': roundToTwo( ( index * ( constantDetailedFixtureLength / mmToFeet ) ) ),
+            'y': roundToTwo( ( finalYDetailedDistance - ( constantDetailedFixtureWidth / mmToFeet ) ) ),
+            'unit': 'ft',
+          },
+        };
 
-    for ( let index = 0; index < floorFixtures.length; index++ ) {
-      const fixture = floorFixtures[index];
-      const centerRow = Math.floor( totalRows / 2 );
+        await storeFixtureService.updateOne(
+            {
+              _id: fixture._id,
+            },
+            fixtureData );
+      }
 
-      const startingX =roundToTwo( ( ( finalXDistance / 2 ) - ( ( maxFixturesPerRow / 2 ) * ( constantFixtureLength / mmToFeet ) ) ) );
-      const detailedStartingX = roundToTwo( ( ( finalXDetailedDistance / 2 ) - ( ( maxFixturesPerRow / 2 ) * ( constantDetailedFixtureLength / mmToFeet ) ) ) );
+      for ( let index = 0; index < floorFixtures.length; index++ ) {
+        const fixture = floorFixtures[index];
+        const centerRow = Math.floor( totalRows / 2 );
 
-      const startingY = ( finalYDistance / 2 ) - ( centerRow * ( constantFixtureWidth / mmToFeet ) );
-      const detailedStartingY = ( finalYDetailedDistance / 2 ) - ( centerRow * ( constantDetailedFixtureWidth / mmToFeet ) );
+        const startingX =roundToTwo( ( ( finalXDistance / 2 ) - ( ( maxFixturesPerRow / 2 ) * ( constantFixtureLength / mmToFeet ) ) ) );
+        const detailedStartingX = roundToTwo( ( ( finalXDetailedDistance / 2 ) - ( ( maxFixturesPerRow / 2 ) * ( constantDetailedFixtureLength / mmToFeet ) ) ) );
 
-      const colIndex = Math.floor( index / 2 );
-      const rowIndex = index % 2 === 0 ? 1 : 0;
+        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 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 fixtureData = {
-        'fixtureHeight': {
-          'value': 0,
-          'unit': 'mm',
-        },
-        'fixtureLength': {
-          'value': constantFixtureLength,
-          'unit': 'mm',
-        },
-        'fixtureWidth': {
-          'value': constantFixtureWidth,
-          'unit': 'mm',
-        },
-        'relativePosition': {
-          'x': xPos,
-          'y': yPos,
-          'unit': 'ft',
-        },
-        'detailedFixtureLength': {
-          'value': constantDetailedFixtureLength,
-          'unit': 'mm',
-        },
-        'detailedFixtureWidth': {
-          'value': constantDetailedFixtureWidth,
-          'unit': 'mm',
-        },
-        'relativeDetailedPosition': {
-          'x': detailedXPos,
-          'y': detailedYPos,
-          'unit': 'ft',
-        },
-      };
 
-      await storeFixtureService.updateOne(
-          {
-            _id: fixture._id,
+        const fixtureData = {
+          'fixtureHeight': {
+            'value': 0,
+            'unit': 'mm',
           },
-          fixtureData );
+          'fixtureLength': {
+            'value': constantFixtureLength,
+            'unit': 'mm',
+          },
+          'fixtureWidth': {
+            'value': constantFixtureWidth,
+            'unit': 'mm',
+          },
+          'relativePosition': {
+            'x': xPos,
+            'y': yPos,
+            'unit': 'ft',
+          },
+          'detailedFixtureLength': {
+            'value': constantDetailedFixtureLength,
+            'unit': 'mm',
+          },
+          'detailedFixtureWidth': {
+            'value': constantDetailedFixtureWidth,
+            'unit': 'mm',
+          },
+          'relativeDetailedPosition': {
+            'x': detailedXPos,
+            'y': detailedYPos,
+            'unit': 'ft',
+          },
+        };
+
+        await storeFixtureService.updateOne(
+            {
+              _id: fixture._id,
+            },
+            fixtureData );
+      }
     }
   } catch ( e ) {
+    console.log( e );
     logger.error( { functionName: 'createCrestPlanogram', error: e } );
-    return res.sendError( e.message || 'Internal Server Error', 500 );
+    return false;
   }
 }
 
 export async function updatelayout( req, res ) {
   try {
-    let getLayoutTaskDetails = await planoTaskService.find( { date_string: dayjs().format( 'YYYY-MM-DD' ), status: 'incomplete', type: 'layout' } );
+    let getLayoutTaskDetails = await planoTaskService.find( { date_string: { $gte: req.body.date }, status: 'incomplete', type: 'layout' } );
     if ( !getLayoutTaskDetails.length ) {
       return res.sendError( 'No data found', 204 );
     }
     for ( let layout of getLayoutTaskDetails ) {
       let layoutAnswer = layout.answers[1];
       let planoDetails = await planoService.findOne( { _id: layout.planoId } );
-      let fixtureDetails = await storeFixtureService.find( { planoId: layout.planoId, floorId: layout.floorId } );
+      let fixtureDetails = await storeFixtureService.findAndSort( { planoId: layout.planoId, floorId: layout.floorId }, {}, { fixtureNumber: 1 } );
       if ( layoutAnswer?.extraFixture?.length ) {
         let deletedFixtureList = layoutAnswer.extraFixture.map( ( fixture ) => fixture.fixtureId );
         fixtureDetails = fixtureDetails.filter( ( fixture ) => !deletedFixtureList.includes( fixture._id.toString() ) );
@@ -3655,6 +3923,11 @@ export async function updatelayout( req, res ) {
           return acc;
         }, {} );
         Object.entries( elementsGroup ).forEach( async ( [ key, values ] ) => {
+          let removeFixtures = layoutAnswer.wronglyLocatedFixtures.filter( ( rmFx ) => {
+            if ( rmFx.fixtureElement == key && rmFx.location != key ) {
+              return rmFx;
+            }
+          } ).map( ( fxtu ) => fxtu.fixtureId );
           let matchingFixtures = [];
           let maxFixtureNumber = 0;
           let elementType = '';
@@ -3674,6 +3947,8 @@ export async function updatelayout( req, res ) {
             );
           }
           if ( matchingFixtures.length ) {
+            matchingFixtures.sort( ( a, b ) => a.associatedElementFixtureNumber - b.associatedElementFixtureNumber );
+            matchingFixtures = matchingFixtures.filter( ( fxt ) => !removeFixtures.includes( fxt._id.toString() ) );
             maxFixtureNumber = Math.max(
                 ...matchingFixtures.map( ( f ) => f.associatedElementFixtureNumber ),
             );
@@ -3843,3 +4118,185 @@ export async function updatelayout( req, res ) {
   }
 }
 
+
+export async function downloadPlanoImage( req, res ) {
+  try {
+    let query = [
+      {
+        $match: {
+          date_string: { $gte: req.body.fromDate, $lte: req.body.toDate },
+          type: 'layout',
+          status: 'incomplete',
+        },
+      },
+      {
+        $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,
+        },
+      },
+    ];
+
+    let taskDetails = await planoTaskService.aggregate( query );
+    if ( !taskDetails.length ) {
+      return res.sendError( 'No data found', 204 );
+    }
+    let planoList = taskDetails.map( ( ele ) => ele.planoId );
+    let storeList = taskDetails.map( ( ele ) => ele.storeName );
+    async function sleep( ms ) {
+      return new Promise( ( resolve ) => setTimeout( resolve, ms ) );
+    }
+
+    async function openPlanoUrls( planoList ) {
+      for ( let id of planoList ) {
+        const url = `http://localhost:8080/#/plano?planoId=${id}&token&url=http://localhost:3008`;
+        const driver = await new Builder().forBrowser( 'chrome' ).build();
+
+        try {
+          await driver.get( url );
+          await sleep( 20000 );
+        } catch ( err ) {
+          console.error( `Error while opening planoId ${id}:`, err );
+        } finally {
+          try {
+            if ( driver && await driver.getSession() ) {
+              await driver.quit();
+            }
+          } catch ( quitErr ) {
+            console.warn( `Error while quitting driver for planoId ${id}:`, quitErr );
+          }
+        }
+      }
+    }
+    if ( !req.body?.merge ) {
+      const downloadsPath = path.join( os.homedir(), 'Downloads' );
+      const targetFolder = path.join( __dirname, '..', '..', `${req.body.file}Images` );
+      await openPlanoUrls( planoList );
+      if ( !fs.existsSync( targetFolder ) ) {
+        fs.mkdirSync( targetFolder, { recursive: true } );
+        console.log( 'Created folder:', targetFolder );
+      }
+      fs.readdir( downloadsPath, async ( err, files ) => {
+        if ( err ) {
+          return console.error( 'Failed to read Downloads folder:', err );
+        }
+        console.log( files );
+        for ( let file of files ) {
+          let fileName = file.split( '.' )[0];
+          const sourcePath = path.join( downloadsPath, file );
+          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}` );
+                  }
+                } );
+              }
+            } else {
+              console.warn( 'File not found in Downloads:', fileName );
+            }
+          }
+        }
+      } );
+    }
+
+    if ( req.body?.merge ) {
+      const targetFolder = path.join( __dirname, '..', '..', `mergedImages` );
+      if ( !fs.existsSync( targetFolder ) ) {
+        fs.mkdirSync( targetFolder, { recursive: true } );
+        console.log( 'Created folder:', targetFolder );
+      }
+      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 [ img1, img2 ] = await Promise.all( [
+            sharp( image1 ),
+            sharp( image2 ),
+          ] );
+
+          const [ meta1, meta2 ] = await Promise.all( [ img1.metadata(), img2.metadata() ] );
+
+          const canvasWidth = meta1.width + meta2.width;
+          const canvasHeight = Math.max( meta1.height, meta2.height );
+
+          const [ img1Buffer, img2Buffer ] = await Promise.all( [
+            img1.toBuffer(),
+            img2.toBuffer(),
+          ] );
+
+          await sharp( {
+            create: {
+              width: canvasWidth,
+              height: canvasHeight,
+              channels: 3,
+              background: { r: 255, g: 255, b: 255 },
+            },
+          } )
+              .composite( [
+                { input: img1Buffer, top: 0, left: 0 },
+                { input: img2Buffer, top: 0, left: meta1.width },
+              ] )
+              .toFile( output );
+
+          console.log( 'Images merged successfully!' );
+        }
+      }
+    }
+    return res.sendSuccess( 'Image Generated SuccessFully' );
+  } catch ( e ) {
+    console.log( e );
+    return res.sendError( e, 500 );
+  }
+}