tango-app-api-store-builder 1.0.0-beta-208 → 1.0.0-beta-210

package/package.json

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

package/src/controllers/managePlano.controller.js

@@ -1,5 +1,5 @@
 import * as floorService from '../service/storeBuilder.service.js';
-import { logger, insertOpenSearchData } from 'tango-app-api-middleware';
+import { logger, insertOpenSearchData, getOpenSearchData } from 'tango-app-api-middleware';
 // import * as storeService from '../service/store.service.js';
 import * as planoService from '../service/planogram.service.js';
 import * as storeFixtureService from '../service/storeFixture.service.js';
@@ -17,6 +17,7 @@ import * as planoGlobalCommentService from '../service/planoGlobalComment.servic
 import mongoose from 'mongoose';
 import * as planoRevisionService from '../service/planoRevision.service.js';
 import * as planoVmDuplicateService from '../service/planoVmDuplicate.service.js';
+import * as vmTypeService from '../service/vmType.service.js';
 export async function getplanoFeedback( req, res ) {
   try {
     const taskTypes = req.body.filterByTask && req.body.filterByTask.length > 0 ? req.body.filterByTask : [ 'layout', 'fixture', 'vm' ];
@@ -66,6 +67,43 @@ export async function getplanoFeedback( req, res ) {
       vmComment: commentMap['vm'] || [],
     };
 
+    response.fixtureData = await Promise.all( response.fixtureData.map( async ( ele ) => {
+      if ( ele?.FixtureData ) {
+        if ( !ele?.FixtureData._id ) {
+          return res.sendError( 'Fixture Id is required', 400 );
+        }
+        let query = {
+          query: {
+            bool: {
+              must: [
+                {
+                  term: {
+                    fixtureId: ele?.FixtureData._id,
+                  },
+                },
+              ],
+            },
+          },
+          sort: [
+            { storeDate: { order: 'desc' } },
+          ],
+        };
+
+
+        let aiDetails = await getOpenSearchData( JSON.parse( process.env.OPENSEARCH ).planoAIValidation, query );
+        if ( aiDetails.statusCode == 200 ) {
+          let data = {};
+          if ( aiDetails?.body?.hits?.hits.length ) {
+            data = aiDetails?.body?.hits?.hits?.[0]?._source;
+            delete data.isEmpty;
+            delete data.fixtureFound;
+          }
+          ele.fixtureAIData = data;
+        }
+      }
+      return ele;
+    } ) );
+
     res.sendSuccess( response );
   } catch ( e ) {
     logger.error( { functionName: 'getplanoFeedback', error: e, message: req.body } );
@@ -713,16 +751,38 @@ export async function updateStorePlano( req, res ) {
     const currentWallFixtures = data.layoutPolygon.flatMap( ( element ) =>
       ( element.fixtures || [] ).map( ( fixture ) => fixture ),
     );
-
     const currentFloorFixtures = ( data.centerFixture || [] );
-
     const currentFixtures = [ ...currentWallFixtures, ...currentFloorFixtures ];
 
-    const existingFixtures = await storeFixtureService.find( { floorId: new mongoose.Types.ObjectId( floorId ) } );
+    const wallOtherElements = data.layoutPolygon.flatMap( ( element ) =>
+      ( element.otherElements || [] ).map( ( el ) => el ),
+    );
+    const floorOtherElements = ( data.otherElements || [] );
+    const currentOtherElements = [ ...wallOtherElements, ...floorOtherElements ];
+
+    const existingFixtures = await storeFixtureService.find( {
+      floorId: new mongoose.Types.ObjectId( floorId ),
+      fixtureType: { $ne: 'other' },
+    } );
+
+    const existingOtherElements = await storeFixtureService.find( {
+      floorId: new mongoose.Types.ObjectId( floorId ),
+      fixtureType: 'other',
+    } );
+
+    const currentOtherElementsIds = new Set( currentOtherElements.map( ( f ) => f._id ) );
+    const removedOtherElements = existingOtherElements.filter(
+        ( f ) => f._id && !currentOtherElementsIds.has( f._id.toString() ),
+    );
 
-    const currentIds = new Set( currentFixtures.map( ( f ) => f._id ) );
+    if ( removedOtherElements.length ) {
+      const otherElementIds = removedOtherElements.map( ( ele ) => ele.toObject()._id );
+      await storeFixtureService.deleteMany( { _id: { $in: otherElementIds } } );
+    }
+
+    const currentFixtureIds = new Set( currentFixtures.map( ( f ) => f._id ) );
     const removedFixtures = existingFixtures.filter(
-        ( f ) => f._id && !currentIds.has( f._id.toString() ),
+        ( f ) => f._id && !currentFixtureIds.has( f._id.toString() ),
     );
 
     if ( removedFixtures.length ) {
@@ -731,9 +791,7 @@ export async function updateStorePlano( req, res ) {
       await fixtureShelfService.deleteMany( { fixtureId: { $in: fixtureIds } } );
     }
 
-
     const newWallFixtures = currentWallFixtures.filter( ( fixture ) => fixture?._id?.startsWith( 'new' ) );
-
     const newFloorFixtures = currentFloorFixtures.filter( ( fixture ) => fixture?._id?.startsWith( 'new' ) );
 
     const newFixtures = [ ...newWallFixtures, ...newFloorFixtures ];
@@ -759,6 +817,28 @@ export async function updateStorePlano( req, res ) {
       } );
     }
 
+
+    const newOtherElements = currentOtherElements.filter( ( ele ) => ele?._id?.startsWith( 'new' ) );
+
+
+    currentOtherElements.forEach( async ( ele ) => {
+      if ( ele?._id && mongoose.Types.ObjectId.isValid( ele._id ) ) {
+        await storeFixtureService.upsertOne( { _id: new mongoose.Types.ObjectId( ele._id ) }, ele );
+      }
+    } );
+
+
+    if ( newOtherElements.length ) {
+      newOtherElements.forEach( async ( ele ) => {
+        delete ele._id;
+        const payload = {
+          ...ele,
+          ...additionalMeta,
+        };
+        await storeFixtureService.create( payload );
+      } );
+    }
+
     currentFixtures.forEach( async ( fixture ) => {
       if ( mongoose.Types.ObjectId.isValid( fixture._id ) ) {
         const updatedFixture = await storeFixtureService.upsertOne( { _id: new mongoose.Types.ObjectId( fixture._id ) }, fixture );
@@ -859,93 +939,115 @@ export async function updateFixtureStatus( req, res ) {
       comment: req.body.comments,
     };
 
-
-    let updateResponse = await planoTaskService.updateOnefilters(
-        { _id: new mongoose.Types.ObjectId( req.body._id ) },
-        {
-          $set: { 'answers.$[ans].issues.$[iss].Details.$[det].status': req.body.type },
-        },
-        [
-          { 'ans._id': new mongoose.Types.ObjectId( req.body.answerId ) },
-          { 'iss._id': new mongoose.Types.ObjectId( req.body.issueId ) },
-          { 'det._id': new mongoose.Types.ObjectId( req.body.DetailsId ) },
-
-        ] );
-    if ( updateResponse && updateResponse.answers.length > 0 ) {
-      let findissuse = updateResponse.answers[0].issues.filter( ( data ) => data._id == req.body.issueId );
-      let findDetails = findissuse[0].Details.filter( ( det ) => det.status === 'agree' );
-      if ( findissuse[0].Details.length === findDetails.length ) {
-        await planoTaskService.updateOnefilters(
-            { _id: new mongoose.Types.ObjectId( req.body._id ) },
-            {
-              $set: { 'answers.$[ans].issues.$[iss].status': 'completed' },
-            },
-            [
-              { 'ans._id': new mongoose.Types.ObjectId( req.body.answerId ) },
-              { 'iss._id': new mongoose.Types.ObjectId( req.body.issueId ) },
-            ] );
-      }
-      let findoneplanoData = await planoTaskService.findOne( { _id: new mongoose.Types.ObjectId( req.body._id ) } );
-      let totalApproved = findoneplanoData.answers[0].issues.filter( ( data ) => data.status === 'pending' );
-      if ( totalApproved.length === 0 ) {
-        await planoTaskService.updateOne(
-            {
-              _id: new mongoose.Types.ObjectId( req.body._id ),
-            },
-            {
-              'status': 'complete',
-            },
-        );
-        if ( req.body.taskType === 'layout' ) {
-          await planoTaskService.updateMany(
-              {
-                planoId: new mongoose.Types.ObjectId( req.body.planoId ),
-                floorId: new mongoose.Types.ObjectId( req.body.floorId ),
-                type: 'layout',
-              },
-              {
-                'status': 'complete',
-              },
-          );
-        }
-      }
-    }
-
-    if ( req.body.taskType === 'layout' ) {
+    if ( req.body.taskType.includes( 'fixture' ) ) {
       await planoTaskService.updateOnefilters(
           { _id: new mongoose.Types.ObjectId( req.body._id ) },
           {
-            $push: { 'answers.$[ans].issues.$[iss].Details.$[det].comments': comments },
+            $set: { 'answers.$[ans].status': req.body.type },
           },
           [
             { 'ans._id': new mongoose.Types.ObjectId( req.body.answerId ) },
-            { 'iss._id': new mongoose.Types.ObjectId( req.body.issueId ) },
-            { 'det._id': new mongoose.Types.ObjectId( req.body.DetailsId ) },
 
+          ],
+      );
+      await planoTaskService.updateOnefilters(
+          { _id: new mongoose.Types.ObjectId( req.body._id ) },
+          {
+            $push: { 'answers.$[ans].comments': comments },
+          },
+          [
+            { 'ans._id': new mongoose.Types.ObjectId( req.body.answerId ) },
           ] );
+
+      await planoTaskService.updateOne( { _id: req.body._id }, { approvalStatus: 'approved' } );
     } else {
-      await planoTaskService.updateOnefilters(
+      let updateResponse = await planoTaskService.updateOnefilters(
           { _id: new mongoose.Types.ObjectId( req.body._id ) },
           {
-            $push: { 'answers.$[ans].issues.$[iss].comments': comments },
+            $set: { 'answers.$[ans].issues.$[iss].Details.$[det].status': req.body.type },
           },
           [
             { 'ans._id': new mongoose.Types.ObjectId( req.body.answerId ) },
             { 'iss._id': new mongoose.Types.ObjectId( req.body.issueId ) },
+            { 'det._id': new mongoose.Types.ObjectId( req.body.DetailsId ) },
+
           ] );
-    }
-    let vmTask = await planoTaskService.find(
-        {
-          planoId: new mongoose.Types.ObjectId( req.body.planoId ),
-          floorId: new mongoose.Types.ObjectId( req.body.floorId ),
-          type: 'vm',
-        },
+      if ( updateResponse && updateResponse.answers.length > 0 ) {
+        let findissuse = updateResponse.answers[0].issues.filter( ( data ) => data._id == req.body.issueId );
+        let findDetails = findissuse[0].Details.filter( ( det ) => det.status === 'agree' );
+        if ( findissuse[0].Details.length === findDetails.length ) {
+          await planoTaskService.updateOnefilters(
+              { _id: new mongoose.Types.ObjectId( req.body._id ) },
+              {
+                $set: { 'answers.$[ans].issues.$[iss].status': 'completed' },
+              },
+              [
+                { 'ans._id': new mongoose.Types.ObjectId( req.body.answerId ) },
+                { 'iss._id': new mongoose.Types.ObjectId( req.body.issueId ) },
+              ] );
+        }
+        let findoneplanoData = await planoTaskService.findOne( { _id: new mongoose.Types.ObjectId( req.body._id ) } );
+        let totalApproved = findoneplanoData.answers[0].issues.filter( ( data ) => data.status === 'pending' );
+        if ( totalApproved.length === 0 ) {
+          await planoTaskService.updateOne(
+              {
+                _id: new mongoose.Types.ObjectId( req.body._id ),
+              },
+              {
+                'status': 'complete',
+              },
+          );
+          if ( req.body.taskType === 'layout' ) {
+            await planoTaskService.updateMany(
+                {
+                  planoId: new mongoose.Types.ObjectId( req.body.planoId ),
+                  floorId: new mongoose.Types.ObjectId( req.body.floorId ),
+                  type: 'layout',
+                },
+                {
+                  'status': 'complete',
+                },
+            );
+          }
+        }
+      }
 
-    );
-    if ( vmTask.length > 0 ) {
-      let allTaskDone = vmTask.filter( ( data ) => data.status === 'incomplete' );
-      if ( allTaskDone.length === 0 ) {
-        await floorService.updateOne( { _id: new mongoose.Types.ObjectId( req.body.floorId ) }, { planoProgress: 100 } );
+      if ( req.body.taskType === 'layout' ) {
+        await planoTaskService.updateOnefilters(
+            { _id: new mongoose.Types.ObjectId( req.body._id ) },
+            {
+              $push: { 'answers.$[ans].issues.$[iss].Details.$[det].comments': comments },
+            },
+            [
+              { 'ans._id': new mongoose.Types.ObjectId( req.body.answerId ) },
+              { 'iss._id': new mongoose.Types.ObjectId( req.body.issueId ) },
+              { 'det._id': new mongoose.Types.ObjectId( req.body.DetailsId ) },
+
+            ] );
+      } else {
+        await planoTaskService.updateOnefilters(
+            { _id: new mongoose.Types.ObjectId( req.body._id ) },
+            {
+              $push: { 'answers.$[ans].issues.$[iss].comments': comments },
+            },
+            [
+              { 'ans._id': new mongoose.Types.ObjectId( req.body.answerId ) },
+              { 'iss._id': new mongoose.Types.ObjectId( req.body.issueId ) },
+            ] );
+      }
+      let vmTask = await planoTaskService.find(
+          {
+            planoId: new mongoose.Types.ObjectId( req.body.planoId ),
+            floorId: new mongoose.Types.ObjectId( req.body.floorId ),
+            type: 'vm',
+          },
+
+      );
+      if ( vmTask.length > 0 ) {
+        let allTaskDone = vmTask.filter( ( data ) => data.status === 'incomplete' );
+        if ( allTaskDone.length === 0 ) {
+          await floorService.updateOne( { _id: new mongoose.Types.ObjectId( req.body.floorId ) }, { planoProgress: 100 } );
+        }
       }
     }
     res.sendSuccess( 'updated successfully' );
@@ -1091,6 +1193,141 @@ export async function updateStoreFixture( req, res ) {
 
     const currentFixture = await storeFixtureService.findOne( { _id: new mongoose.Types.ObjectId( fixtureId ) } );
     let currentFixtureDoc = currentFixture.toObject();
+    if ( req?.body?.taskType?.includes( 'fixture' ) || data?.taskType?.includes( 'fixture' ) ) {
+      let shelfDetails = await fixtureShelfService.find( { fixtureId: fixtureId } );
+      data.shelfConfig.forEach( ( ele ) => {
+        let findShelfProduct = shelfDetails.find( ( shelf ) => shelf.shelfNumber == ele.shelfNumber );
+        ele.productBrandName = findShelfProduct?.productBrandName ?? [];
+        ele.productCategory = findShelfProduct?.productCategory ?? [];
+        ele.productSubCategory = findShelfProduct?.productSubCategory ?? [];
+        ele.zone = findShelfProduct?.zone ?? 'Bottom';
+      } );
+      let vmConfig = [];
+      for ( let vm of data.vmConfig ) {
+        let checkvmType = await vmTypeService.findOne( { vmType: vm.vmType } );
+        if ( !checkvmType ) {
+          let vmData = {
+            vmType: vm.vmType,
+            imageUrls: [ vm.vmImage ],
+            clientId: '11',
+          };
+          checkvmType = await vmTypeService.create( vmData );
+        }
+        let vmDetails = await planoVmService.findOne( { ...( vm.vmName ) ? { vmName: vm.vmName } : { _id: vm.vmId } } );
+        if ( !vmDetails ) {
+          let planovmData = {
+            vmType: vm.vmType,
+            vmName: vm.vmName,
+            clientId: '11',
+            status: 'complete',
+            vmHeight: {
+              'value': 100,
+              'unit': 'mm',
+            },
+            vmWidth: {
+              'value': 100,
+              'unit': 'mm',
+            },
+            vmImageUrl: vm.vmImage,
+          };
+          vmDetails = await planoVmService.create( planovmData );
+        }
+        vmConfig.push( { ...vm, vmId: vmDetails._id } );
+      }
+      data.vmConfig = vmConfig;
+      let groupName = {
+        'Vincent Chase Lenskart air': 'VC Eye / LK Air',
+        'John Jacobs': 'JJ Eye',
+        'Vincent Chase': 'VC Eye',
+        'OwnDays': 'OD Eye',
+      };
+      let header = ( data?.header?.label && data?.header?.label != 'Unknown' ) ? groupName?.[data?.header?.label] ? groupName?.[data?.header?.label] : data?.header?.label : currentFixture.header?.label;
+      let mapKey = `${data.fixtureCategory}${currentFixtureDoc.fixtureWidth.value}${currentFixtureDoc.fixtureWidth.unit}${header}`;
+      mapKey += data.shelfConfig.map( ( ele ) => `${ele.shelfNumber}=${ele.productBrandName.toString()}` ).join( '+' );
+      data?.vmConfig?.forEach( ( ele ) => {
+        mapKey += `${ele.vmName}${ele.startYPosition}${ele.endYPosition}${ele.xZone}${ele.yZone}`;
+      } );
+      let query = [
+        {
+          $addFields: {
+            crestMapKey: { $toLower: '$crestMapKey' },
+          },
+        },
+        {
+          $match: {
+            crestMapKey: mapKey.toLowerCase(),
+            templateType: 'sub',
+          },
+        },
+      ];
+      let masterMapKey = `${data.fixtureCategory}${currentFixtureDoc.fixtureWidth.value}${currentFixtureDoc.fixtureWidth.unit}${header}`;
+      let masterQuery = [
+        {
+          $addFields: {
+            crestMapKey: { $toLower: '$crestMapKey' },
+          },
+        },
+        {
+          $match: {
+            crestMapKey: masterMapKey.toLowerCase(),
+            templateType: 'master',
+          },
+        },
+      ];
+      let [ fixturesubTemplate, fixtureMasterTemplate ] = await Promise.all( [
+        await fixtureConfigService.aggregate( query ),
+        await fixtureConfigService.aggregate( masterQuery ),
+      ] );
+
+      if ( !fixturesubTemplate.length ) {
+        let tempGroupName = ( data?.header?.label && data?.header?.label != 'Unknown' ) ? groupName?.[data?.header?.label] ? groupName?.[data?.header?.label] : data?.header?.label : currentFixture.templateGroupName;
+        let templateIndex = 1;
+        let templateData = {
+          ...currentFixtureDoc,
+          ...data,
+          templateGroupName: tempGroupName,
+          fixtureLibraryId: currentFixture.fixtureLibraryId,
+          status: 'complete',
+          templateIndex: fixtureMasterTemplate.length ? fixtureMasterTemplate.length + 1 : 1,
+          crestMapKey: mapKey,
+        };
+        delete templateData._id;
+        delete templateData.masterTemplateId;
+        if ( !fixtureMasterTemplate.length ) {
+          let masterTemplate = {
+            ...templateData,
+            fixtureName: `${templateData.header.label}-${templateData.fixtureCategory}`,
+            templateType: 'master',
+            crestMapKey: masterMapKey,
+          };
+          fixtureMasterTemplate = await fixtureConfigService.create( masterTemplate );
+        } else {
+          fixtureMasterTemplate = fixtureMasterTemplate[0];
+          let tempQuery = [
+            {
+              $match: {
+                masterTemplateId: new mongoose.Types.ObjectId( fixtureMasterTemplate._id ),
+              },
+            },
+            {
+              $group: {
+                _id: '',
+                tempId: { $max: '$templateIndex' },
+              },
+            },
+          ];
+          let getMaxTemp = await fixtureConfigService.aggregate( tempQuery );
+          templateIndex = getMaxTemp?.[0]?.tempId + 1;
+        }
+        templateData.fixtureName= `${header}-${data.fixtureCategory}-varient-${templateIndex}`,
+        templateData.templateType = 'sub';
+        templateData.masterTemplateId = fixtureMasterTemplate._id;
+        let subTemplate = await fixtureConfigService.create( templateData );
+
+        data.fixtureConfigId = subTemplate._id;
+        data.masterTemplateId = fixtureMasterTemplate._id;
+      }
+    }
 
     const productBrandName = new Set();
     const productCategory = new Set();
@@ -1125,7 +1362,7 @@ export async function updateStoreFixture( req, res ) {
     } );
 
 
-    if ( currentFixtureDoc.fixtureConfigId.toString() !== data.fixtureConfigId ) {
+    if ( data?.fixtureConfigId && currentFixtureDoc.fixtureConfigId.toString() !== data.fixtureConfigId ) {
       const newTemplate = await fixtureConfigService.findOne( { _id: data.fixtureConfigId } );
       currentFixtureDoc = {
         ...currentFixtureDoc,
@@ -1178,7 +1415,22 @@ export async function updateStoreFixture( req, res ) {
       } );
     }
     await planoService.updateOne( { _id: currentFixtureDoc?.planoId }, { $set: { updatedAt: new Date() } } );
-
+    if ( data?.taskType?.includes( 'fixture' ) ) {
+      let comments = {
+        userId: req.user._id,
+        userName: req.user.userName,
+        role: req.user.role,
+        responsetype: 'agree',
+        comment: '',
+      };
+      await planoTaskService.updateOne( { planoId: currentFixture.planoId, floorId: currentFixture.floorId, fixtureId: currentFixture._id }, { 'answers.0.status': 'agree', 'approvalStatus': 'approved' } );
+      await planoTaskService.updateOnefilters(
+          { planoId: new mongoose.Types.ObjectId( currentFixture.planoId ), floorId: new mongoose.Types.ObjectId( currentFixture.floorId ), fixtureId: new mongoose.Types.ObjectId( currentFixture._id ) },
+          {
+            $push: { 'answers.0.comments': comments },
+          },
+      );
+    }
     res.sendSuccess( 'Updated Successfully' );
   } catch ( e ) {
     logger.error( { functionName: 'updateStoreFixture', error: e } );

package/src/controllers/script.controller.js

@@ -9549,147 +9549,147 @@ async function updateHeaders() {
   } );
 }
 
-export async function productMappings(req, res) {
+export async function productMappings( req, res ) {
   try {
     const CLEAR_COL_BEFORE_INSERT = false;
-    if (req?.headers?.authorization?.split(" ")[1] !== "hwjXfCD6TgMvc82cuSGZ9bNv9MuXsaiQ6uvx") {
-      return res.sendError("Unauthorized", 401);
+    if ( req?.headers?.authorization?.split( ' ' )[1] !== 'hwjXfCD6TgMvc82cuSGZ9bNv9MuXsaiQ6uvx' ) {
+      return res.sendError( 'Unauthorized', 401 );
     }
 
-    if (!req.files?.file) {
-      return res.sendError("Excel file is required", 400);
+    if ( !req.files?.file ) {
+      return res.sendError( 'Excel file is required', 400 );
     }
 
-    const payload = JSON.parse(req.body.payload);
+    const payload = JSON.parse( req.body.payload );
 
     const { fixtureId, Top, Mid, Bottom } = payload;
 
-    const storeName = "LKST98";
-    const storeId = "11-4";
+    const storeName = 'LKST98';
+    const storeId = '11-4';
 
-    if (!fixtureId) {
-      return res.sendError("fixtureId is required", 400);
+    if ( !fixtureId ) {
+      return res.sendError( 'fixtureId is required', 400 );
     }
 
     const fixtureData = { Top, Mid, Bottom };
 
-    const workbook = xlsx.read(req.files.file.data, { type: "buffer" });
-    const sheetName = "Unique Mapping";
-    const raw = xlsx.utils.sheet_to_json(workbook.Sheets[sheetName]);
+    const workbook = xlsx.read( req.files.file.data, { type: 'buffer' } );
+    const sheetName = 'Unique Mapping';
+    const raw = xlsx.utils.sheet_to_json( workbook.Sheets[sheetName] );
 
-    const pidsList = Object.values(fixtureData).flat();
+    const pidsList = Object.values( fixtureData ).flat();
 
     let pDetailsList = [];
-    for (const pid of pidsList) {
-      const pDetails = raw.find((pd) => pd["product_id"] == pid);
-      if (pDetails) {
-        pDetailsList.push({
-          clientId: "11",
+    for ( const pid of pidsList ) {
+      const pDetails = raw.find( ( pd ) => pd['product_id'] == pid );
+      if ( pDetails ) {
+        pDetailsList.push( {
+          clientId: '11',
           productId: pDetails.product_id,
           productName: pDetails.parent_brand,
           pid: pDetails.product_id,
           rfId: pDetails.barcode,
           productImageUrl: pDetails.image_front,
-          productType: pDetails.classification_name ?? "",
-          brandName: pDetails.collection ?? "",
-          category: pDetails.collection_group ?? "",
-          subCategory: pDetails.sub_collection ?? "",
-          type: "product",
-        });
+          productType: pDetails.classification_name ?? '',
+          brandName: pDetails.collection ?? '',
+          category: pDetails.collection_group ?? '',
+          subCategory: pDetails.sub_collection ?? '',
+          type: 'product',
+        } );
       }
     }
 
-    if(CLEAR_COL_BEFORE_INSERT) await planoProductService.deleteMany({});
+    if ( CLEAR_COL_BEFORE_INSERT ) await planoProductService.deleteMany( {} );
 
     // const uniqueProducts = await fixtureShelfService.find();
-    
-    const fixtureTemplateData = await fixtureShelfService.find({ fixtureId });
 
-    if (!fixtureTemplateData?.length) {
-      return res.sendError("No shelves found for fixtureId", 404);
+    const fixtureTemplateData = await fixtureShelfService.find( { fixtureId } );
+
+    if ( !fixtureTemplateData?.length ) {
+      return res.sendError( 'No shelves found for fixtureId', 404 );
     }
 
     const planoId = fixtureTemplateData[0].planoId;
     const floorId = fixtureTemplateData[0].floorId;
 
-    const fixtureShelve = fixtureTemplateData.map((f) => ({
+    const fixtureShelve = fixtureTemplateData.map( ( f ) => ( {
       id: f._id,
       zone: f.zone,
-    }));
-    
-    const result = await planoProductService.insertMany(pDetailsList);
+    } ) );
+
+    const result = await planoProductService.insertMany( pDetailsList );
 
-    let planoMappings = result.map((pd) => ({
-      clientId: "11",
+    let planoMappings = result.map( ( pd ) => ( {
+      clientId: '11',
       storeName: storeName,
       storeId: storeId,
-      type: "product",
+      type: 'product',
       productId: pd._id,
       pid: pd.pid,
       planoId,
       floorId,
       fixtureId,
-      shelfId: "temp", // will be reassigned in transformProducts
-    }));
+      shelfId: 'temp', // will be reassigned in transformProducts
+    } ) );
 
-    if(CLEAR_COL_BEFORE_INSERT) await planoMappingService.deleteMany({});
+    if ( CLEAR_COL_BEFORE_INSERT ) await planoMappingService.deleteMany( {} );
 
     const shelfGroups = {
-      Top: fixtureShelve.filter((f) => f.zone === "Top").map((f) => f.id),
-      Mid: fixtureShelve.filter((f) => f.zone === "Mid").map((f) => f.id),
-      Bottom: fixtureShelve.filter((f) => f.zone === "Bottom").map((f) => f.id),
+      Top: fixtureShelve.filter( ( f ) => f.zone === 'Top' ).map( ( f ) => f.id ),
+      Mid: fixtureShelve.filter( ( f ) => f.zone === 'Mid' ).map( ( f ) => f.id ),
+      Bottom: fixtureShelve.filter( ( f ) => f.zone === 'Bottom' ).map( ( f ) => f.id ),
     };
 
-    const transformed = transformProducts(planoMappings, shelfGroups, fixtureData);
+    const transformed = transformProducts( planoMappings, shelfGroups, fixtureData );
 
-    const result2 = await planoMappingService.insertMany(transformed);
+    const result2 = await planoMappingService.insertMany( transformed );
 
-    res.sendSuccess({
+    res.sendSuccess( {
       fixtureData,
       shelfGroups,
       planoMappings: result2,
-    });
-  } catch (error) {
-    console.log("@@ ~ error:", error);
-    res.sendError("Internal Server Error", 500);
+    } );
+  } catch ( error ) {
+    console.log( '@@ ~ error:', error );
+    res.sendError( 'Internal Server Error', 500 );
   }
 }
 
-function transformProducts(products, shelvesByZone, fixtureData) {
+function transformProducts( products, shelvesByZone, fixtureData ) {
   const result = [];
 
   // Build lookup: pid → zone
   const pidToZone = {};
-  for (const [zone, pids] of Object.entries(fixtureData)) {
-    pids.forEach(pid => {
+  for ( const [ zone, pids ] of Object.entries( fixtureData ) ) {
+    pids.forEach( ( pid ) => {
       pidToZone[pid] = zone;
-    });
+    } );
   }
 
   // Group products by zone
   const productsByZone = {};
-  for (const doc of products) {
+  for ( const doc of products ) {
     const zone = pidToZone[doc.pid];
-    if (!zone) continue;
-    if (!productsByZone[zone]) productsByZone[zone] = [];
-    productsByZone[zone].push(doc);
+    if ( !zone ) continue;
+    if ( !productsByZone[zone] ) productsByZone[zone] = [];
+    productsByZone[zone].push( doc );
   }
 
   // Round-robin distribute products across shelves
-  for (const [zone, docs] of Object.entries(productsByZone)) {
+  for ( const [ zone, docs ] of Object.entries( productsByZone ) ) {
     const shelves = shelvesByZone[zone] || [];
-    if (shelves.length === 0) {
-      result.push(...docs);
+    if ( shelves.length === 0 ) {
+      result.push( ...docs );
       continue;
     }
 
-    docs.forEach((doc, idx) => {
+    docs.forEach( ( doc, idx ) => {
       const shelfId = shelves[idx % shelves.length]; // cycle through shelves
-      result.push({
+      result.push( {
         ...doc,
-        shelfId
-      });
-    });
+        shelfId,
+      } );
+    } );
   }
 
   return result;

package/src/controllers/storeBuilder.controller.js

@@ -1,7 +1,7 @@
 import * as storeBuilderService from '../service/storeBuilder.service.js';
 import * as storeService from '../service/store.service.js';
 import * as planoService from '../service/planogram.service.js';
-import { logger, fileUpload, signedUrl, sendMessageToQueue } from 'tango-app-api-middleware';
+import { logger, fileUpload, signedUrl, sendMessageToQueue, getOpenSearchData } from 'tango-app-api-middleware';
 import dayjs from 'dayjs';
 import customParseFormat from 'dayjs/plugin/customParseFormat.js';
 import utc from 'dayjs/plugin/utc.js';
@@ -2811,11 +2811,12 @@ export async function storeFixturesv2( req, res ) {
                 const masterTemplateIds = new Set();
                 const layoutPolygonWithFixtures = await Promise.all(
                     floor.layoutPolygon.map( async ( element ) => {
-                      const fixtures = await storeFixtureService.findAndSort( {
+                        const fixtures = await storeFixtureService.findAndSort( {
                         floorId: floor._id,
                         associatedElementType: element.elementType,
                         associatedElementNumber: element.elementNumber,
-                      }, { shelfcount: 0 }, { associatedElementFixtureNumber: 1 } );
+                        fixtureType: { $ne: 'other' },
+                        }, { shelfcount: 0 }, { associatedElementFixtureNumber: 1 } );
 
                       const fixturesWithStatus = await Promise.all(
                           fixtures.map( async ( fixture ) => {
@@ -2916,6 +2917,7 @@ export async function storeFixturesv2( req, res ) {
                   $and: [
                     { associatedElementType: { $exists: false } },
                     { associatedElementNumber: { $exists: false } },
+                    { fixtureType: { $ne: 'other' } }
                   ],
                 }, { shelfcount: 0 }, { associatedElementFixtureNumber: 1 } );
 
@@ -2996,7 +2998,6 @@ export async function storeFixturesv2( req, res ) {
                         vmCount: vmCount,
                         shelfConfig: shelfDetails,
                         vmConfig: vmDetails,
-
                       };
                     } ),
                 );
@@ -3494,6 +3495,7 @@ export async function storeFixturesTaskv2( req, res ) {
                         floorId: floor._id,
                         associatedElementType: element.elementType,
                         associatedElementNumber: element.elementNumber,
+                        fixtureType: { $ne: 'other' }
                       }, { shelfcount: 0 }, { associatedElementFixtureNumber: 1 } );
 
                       const fixturesWithStatus = await Promise.all(
@@ -3571,6 +3573,7 @@ export async function storeFixturesTaskv2( req, res ) {
                               vmCount: vmCount,
                               shelfConfig: shelfDetails,
                               vmConfig: vmDetails,
+                              ...( req.body.type == 'fixtureMeasurement' && { fixtureMeasurement: compliance.answers?.[0]?.fixtureWidth } ),
                             };
                           } ),
                       );
@@ -3595,6 +3598,7 @@ export async function storeFixturesTaskv2( req, res ) {
                   $and: [
                     { associatedElementType: { $exists: false } },
                     { associatedElementNumber: { $exists: false } },
+                    { fixtureType: { $ne: 'other' } }
                   ],
                 }, { shelfcount: 0 }, { associatedElementFixtureNumber: 1 } );
 
@@ -3673,6 +3677,7 @@ export async function storeFixturesTaskv2( req, res ) {
                         vmCount: vmCount,
                         shelfConfig: shelfDetails,
                         vmConfig: vmDetails,
+                        ...( req.body.type == 'fixtureMeasurement' && { fixtureMeasurement: compliance.answers?.[0]?.fixtureWidth } ),
                       };
                     } ),
                 );
@@ -4121,7 +4126,6 @@ export async function planoList( req, res ) {
                 $expr: {
                   $and: [
                     { $eq: [ '$floorId', '$$floor' ] },
-                    { $eq: [ '$status', 'incomplete' ] },
                     { $in: [ '$type', [ 'layout', 'fixture', 'vm' ] ] },
                   ],
                 },
@@ -4130,6 +4134,15 @@ export async function planoList( req, res ) {
             { $sort: { _id: -1 } },
             {
               $set: {
+                hasCompletedAnswers: {
+                  $anyElementTrue: {
+                    $map: {
+                      input: '$answers',
+                      as: 'ans',
+                      in: { $eq: [ { $ifNull: [ '$$ans.status', null ] }, null ] },
+                    },
+                  },
+                },
                 hasPendingIssues: {
                   $anyElementTrue: {
                     $map: {
@@ -4169,33 +4182,36 @@ export async function planoList( req, res ) {
                   $anyElementTrue: {
                     $map: {
                       input: {
-                        $reduce: {
-                          input: '$answers',
-                          initialValue: [],
-                          in: {
-                            $concatArrays: [
-                              '$$value',
-                              {
-                                $reduce: {
-                                  input: { $ifNull: [ '$$this.issues', [] ] },
-                                  initialValue: [],
-                                  in: {
-                                    $concatArrays: [
-                                      '$$value',
-                                      { $ifNull: [ '$$this.Details', [] ] },
-                                    ],
+                        $concatArrays: [
+                          '$answers',
+                          {
+                            $reduce: {
+                              input: '$answers',
+                              initialValue: [],
+                              in: {
+                                $concatArrays: [
+                                  '$$value',
+                                  {
+                                    $reduce: {
+                                      input: { $ifNull: [ '$$this.issues', [] ] },
+                                      initialValue: [],
+                                      in: {
+                                        $concatArrays: [
+                                          '$$value',
+                                          { $ifNull: [ '$$this.Details', [] ] },
+                                        ],
+                                      },
+                                    },
                                   },
-                                },
+                                ],
                               },
-                            ],
+                            },
                           },
-                        },
+                        ],
                       },
                       as: 'detail',
                       in: {
-                        $or: [
-                          { $eq: [ '$$detail.status', 'disagree' ] },
-                        ],
+                        $or: [ { $eq: [ '$$detail.status', 'disagree' ] } ],
                       },
                     },
                   },
@@ -4226,12 +4242,26 @@ export async function planoList( req, res ) {
                 fixturePending: {
                   $sum: {
                     $cond: [
-                      { $and: [ { $eq: [ '$type', 'fixture' ] }, '$hasPendingIssues' ] },
+                      { $and: [ { $eq: [ '$type', 'fixture' ] }, { $or: [ '$hasPendingIssues', '$hasCompletedAnswers' ] } ] },
                       1,
                       0,
                     ],
                   },
                 },
+                fixtureApproved: {
+                  $push: {
+                    $cond: [
+                      {
+                        $and: [
+                          { $eq: [ '$type', 'fixture' ] },
+                          { $eq: [ '$approvalStatus', 'approved' ] },
+                        ],
+                      },
+                      '$approvalStatus',
+                      '$$REMOVE',
+                    ],
+                  },
+                },
                 vmPending: {
                   $sum: {
                     $cond: [
@@ -4333,6 +4363,9 @@ export async function planoList( req, res ) {
                         {
                           $eq: [ '$fixtureDisagree', 0 ],
                         },
+                        {
+                          $eq: [ { $size: '$fixtureApproved' }, '$fixtureCount' ],
+                        },
                       ],
                     },
                     then: 'complete',
@@ -4685,6 +4718,15 @@ export async function planoList( req, res ) {
       },
       {
         $set: {
+          hasCompletedAnswers: {
+            $anyElementTrue: {
+              $map: {
+                input: '$answers',
+                as: 'ans',
+                in: { $eq: [ { $ifNull: [ '$$ans.status', null ] }, null ] },
+              },
+            },
+          },
           hasPendingIssues: {
             $anyElementTrue: {
               $map: {
@@ -4737,7 +4779,7 @@ export async function planoList( req, res ) {
           fixturePending: {
             $sum: {
               $cond: [
-                { $and: [ { $eq: [ '$type', 'fixture' ] }, '$hasPendingIssues' ] },
+                { $and: [ { $eq: [ '$type', 'fixture' ] }, { $or: [ '$hasPendingIssues', '$hasCompletedAnswers' ] } ] },
                 1,
                 0,
               ],
@@ -4872,7 +4914,6 @@ export async function getTaskDetails( req, res ) {
                   $and: [
                     { $eq: [ '$planoId', new mongoose.Types.ObjectId( req.query.planoId ) ] },
                     { $in: [ '$taskId', '$$task' ] },
-                    { $eq: [ '$status', 'incomplete' ] },
                   ],
                 },
               },
@@ -4880,6 +4921,15 @@ export async function getTaskDetails( req, res ) {
             { $sort: { _id: -1 } },
             {
               $set: {
+                hasCompletedAnswers: {
+                  $anyElementTrue: {
+                    $map: {
+                      input: '$answers',
+                      as: 'ans',
+                      in: { $eq: [ { $ifNull: [ '$$ans.status', null ] }, null ] },
+                    },
+                  },
+                },
                 hasPendingIssues: {
                   $anyElementTrue: {
                     $map: {
@@ -4919,33 +4969,36 @@ export async function getTaskDetails( req, res ) {
                   $anyElementTrue: {
                     $map: {
                       input: {
-                        $reduce: {
-                          input: '$answers',
-                          initialValue: [],
-                          in: {
-                            $concatArrays: [
-                              '$$value',
-                              {
-                                $reduce: {
-                                  input: { $ifNull: [ '$$this.issues', [] ] },
-                                  initialValue: [],
-                                  in: {
-                                    $concatArrays: [
-                                      '$$value',
-                                      { $ifNull: [ '$$this.Details', [] ] },
-                                    ],
+                        $concatArrays: [
+                          '$answers',
+                          {
+                            $reduce: {
+                              input: '$answers',
+                              initialValue: [],
+                              in: {
+                                $concatArrays: [
+                                  '$$value',
+                                  {
+                                    $reduce: {
+                                      input: { $ifNull: [ '$$this.issues', [] ] },
+                                      initialValue: [],
+                                      in: {
+                                        $concatArrays: [
+                                          '$$value',
+                                          { $ifNull: [ '$$this.Details', [] ] },
+                                        ],
+                                      },
+                                    },
                                   },
-                                },
+                                ],
                               },
-                            ],
+                            },
                           },
-                        },
+                        ],
                       },
                       as: 'detail',
                       in: {
-                        $or: [
-                          { $eq: [ '$$detail.status', 'disagree' ] },
-                        ],
+                        $or: [ { $eq: [ '$$detail.status', 'disagree' ] } ],
                       },
                     },
                   },
@@ -4976,12 +5029,26 @@ export async function getTaskDetails( req, res ) {
                 fixturePending: {
                   $sum: {
                     $cond: [
-                      { $and: [ { $eq: [ '$type', 'fixture' ] }, '$hasPendingIssues' ] },
+                      { $and: [ { $eq: [ '$type', 'fixture' ] }, { $or: [ '$hasPendingIssues', '$hasCompletedAnswers' ] } ] },
                       1,
                       0,
                     ],
                   },
                 },
+                fixtureApproved: {
+                  $push: {
+                    $cond: [
+                      {
+                        $and: [
+                          { $eq: [ '$type', 'fixture' ] },
+                          { $eq: [ '$approvalStatus', 'approved' ] },
+                        ],
+                      },
+                      '$approvalStatus',
+                      '$$REMOVE',
+                    ],
+                  },
+                },
                 vmPending: {
                   $sum: {
                     $cond: [
@@ -5020,41 +5087,6 @@ export async function getTaskDetails( req, res ) {
                 },
               },
             },
-            // {
-            //   $group: {
-            //     _id: null,
-            //     layoutCount: { $sum: '$layoutCount' },
-            //     fixtureCount: { $sum: '$fixtureCount' },
-            //     vmCount: { $sum: '$vmCount' },
-            //     completeLayout: {
-            //       $sum: {
-            //         $cond: {
-            //           if: {
-            //             $and: [
-            //               { '$gt': [ '$layoutCount', 0 ] },
-            //               { '$eq': [ '$layoutPending', 0 ] },
-            //               { '$eq': [ '$layoutDisagree', 0 ] },
-            //               { '$gt': [ '$fixtureCount', 0 ] },
-            //               { '$eq': [ '$fixturePending', 0 ] },
-            //               { '$eq': [ '$fixtureDisagree', 0 ] },
-            //               { '$gt': [ '$vmCount', 0 ] },
-            //               { '$eq': [ '$vmPending', 0 ] },
-            //               { '$eq': [ '$vmDisagree', 0 ] },
-            //             ],
-            //           },
-            //           then: 1,
-            //           else: 0,
-            //         },
-            //       },
-            //     },
-            //     layoutPending: { $sum: '$layoutPending' },
-            //     fixturePending: { $sum: '$fixturePending' },
-            //     vmPending: { $sum: '$vmPending' },
-            //     layoutDisagree: { $sum: '$layoutDisagree' },
-            //     fixtureDisagree: { $sum: '$fixtureDisagree' },
-            //     vmDisagree: { $sum: '$vmDisagree' },
-            //   },
-            // },
             {
               $project: {
                 _id: 0,
@@ -5118,6 +5150,9 @@ export async function getTaskDetails( req, res ) {
                         {
                           $eq: [ '$fixtureDisagree', 0 ],
                         },
+                        {
+                          $eq: [ { $size: '$fixtureApproved' }, '$fixtureCount' ],
+                        },
                       ],
                     },
                     then: 'complete',
@@ -6059,10 +6094,9 @@ export async function getRolloutTaskDetails( req, res ) {
             },
             { $sort: { _id: -1 } },
           ],
-          as: 'taskStatus.taskDetails', // ✅ correctly attaches inside taskStatus
+          as: 'taskStatus.taskDetails',
         },
       },
-      // 🔹 Group back into array
       {
         $group: {
           _id: null,
@@ -6089,7 +6123,7 @@ export async function getRolloutTaskDetails( req, res ) {
                 createdAt: '$$task.createdAt',
                 userName: '$$task.userName',
                 submitTime_string: '$$task.submitTime_string',
-                taskDetails: '$$task.taskDetails', // ✅ fixed reference
+                taskDetails: '$$task.taskDetails',
               },
             },
           },
@@ -6216,3 +6250,39 @@ export async function getScandid( req, res ) {
     return res.sendError( e, 500 );
   }
 }
+
+
+export async function getFixtureAIDetails( req, res ) {
+  try {
+    if ( !req.query.fixtureId ) {
+      return res.sendError( 'Fixture Id is required', 400 );
+    }
+    let query = {
+      bool: {
+        must: [
+          {
+            term: {
+              fixtureId: req.query.fixtureId,
+            },
+          },
+        ],
+      },
+    };
+
+    let aiDetails = await getOpenSearchData( JSON.parse( process.env.OPENSEARCH ).planoAIValidation, { query } );
+    if ( aiDetails.statusCode == 200 ) {
+      let data = {};
+      if ( aiDetails?.body?.hits?.hits.length ) {
+        data = aiDetails?.body?.hits?.hits?.[0]?._source;
+        delete data.isEmpty;
+        delete data.fixtureFound;
+      }
+      return res.sendSuccess( data );
+    }
+    return res.sendError( 'No data found', 204 );
+  } catch ( e ) {
+    console.log( e );
+    logger.error( { functionName: 'getFixtureAIDetails', error: e } );
+    return res.sendError( e, 500 );
+  }
+}

package/src/controllers/task.controller.js

@@ -240,6 +240,9 @@ export async function createTask( req, res ) {
           first = 'merchRollout';
         }
       }
+      if ( req.body?.checkListName.toLowerCase().includes( 'measurement' ) ) {
+        first = 'fixtureMeasurement';
+      }
       let startDate = dayjs().format( 'YYYY-MM-DD hh:mm A' );
       let data = {
         client_id: req.body.clientId,
@@ -345,6 +348,7 @@ export async function createTask( req, res ) {
               } else {
                 let type = req.body.checkListName == 'Fixture Verification' ? 'fixture' : 'vm';
                 await planoTaskService.deleteMany( { planoId: planoDetails?._id, floorId: taskData?.floorId, type: type } );
+                await processedService.deleteMany( { planoId: planoDetails?._id, floorId: taskData?.floorId, isPlano: true, type: type } );
               }
               await floorService.updateOne( { _id: taskData?.floorId }, { planoProgress } );
             }

package/src/routes/managePlano.routes.js

@@ -17,7 +17,7 @@ managePlanoRouter
     .get( '/fixtureVMListv1', managePlanoController.fixtureVMListv1 )
     .post( '/updateFixtureStatus', isAllowedSessionHandler, managePlanoController.updateFixtureStatus )
     .post( '/updateApprovalStatus', isAllowedSessionHandler, managePlanoController.updateApprovalStatus )
-    .post( '/updateStoreFixture', managePlanoController.updateStoreFixture )
+    .post( '/updateStoreFixture', isAllowedSessionHandler, managePlanoController.updateStoreFixture )
     .post( '/updateredostatus', managePlanoController.updateredostatus )
     .post( '/updateGlobalComment', isAllowedSessionHandler, managePlanoController.updateGlobalComment )
     .post( '/getGlobalComment', isAllowedSessionHandler, managePlanoController.getGlobalComment )

package/src/routes/storeBuilder.routes.js

@@ -59,4 +59,5 @@ storeBuilderRouter
     .post( '/planoRolloutList', isAllowedSessionHandler, storeBuilderController.getRolloutDetails )
     .get( '/getRolloutTaskDetails', isAllowedSessionHandler, storeBuilderController.getRolloutTaskDetails )
     .get( '/getScandid', storeBuilderController.getScandid )
-    .get( '/getPlanoStoreList', isAllowedSessionHandler, storeBuilderController.getPlanoStoreList );
+    .get( '/getPlanoStoreList', isAllowedSessionHandler, storeBuilderController.getPlanoStoreList )
+    .get( '/getFixtureAIDetails', isAllowedSessionHandler, storeBuilderController.getFixtureAIDetails );

package/src/service/storeFixture.service.js

@@ -68,3 +68,17 @@ export async function count( query ) {
 export async function updateOneArrayItem( query, record, filter ) {
   return model.storeFixtureModel.updateOne( query, record, filter );
 }
+
+export async function bulkUpsert(dataList = [], matchKey = '_id') {
+  if (!Array.isArray(dataList) || dataList.length === 0) return [];
+
+  const operations = dataList.map(item => ({
+    updateOne: {
+      filter: { [matchKey]: item[matchKey] },
+      update: { $set: item },
+      upsert: true,
+    },
+  }));
+
+  return model.storeFixtureModel.bulkWrite(operations);
+}