tango-app-api-store-builder 1.0.3-alpha → 1.0.4

package/src/controllers/managePlano.controller.js

@@ -0,0 +1,1986 @@
+import * as floorService from '../service/storeBuilder.service.js';
+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';
+import * as fixtureShelfService from '../service/fixtureShelf.service.js';
+// import * as planoProductService from '../service/planoProduct.service.js';
+import * as planoVmService from '../service/planoVm.service.js';
+// import * as planoMappingService from '../service/planoMapping.service.js';
+// import * as planoTaskService from '../service/planoTask.service.js';
+import * as processedTaskService from '../service/processedTaskservice.js';
+import * as planoproductCategoryService from '../service/planoproductCategory.service.js';
+import * as fixtureConfigService from '../service/fixtureConfig.service.js';
+import * as fixtureLibraryService from '../service/planoLibrary.service.js';
+import * as planoTaskService from '../service/planoTask.service.js';
+import * as planoGlobalCommentService from '../service/planoGlobalComment.service.js';
+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' ];
+    const filterByStatus = req.body.filterByStatus || [];
+    const filterByApprovalStatus = req.body.filterByApprovalStatus || '';
+    const resultMap = {};
+    const commentMap = {};
+    await Promise.all(
+        taskTypes.map( async ( type, index ) => {
+          const pipeline = buildPipelineByType( type, req.body.planoId, req.body.floorId, filterByStatus, filterByApprovalStatus, req.body.showtask );
+
+          let data = await planoTaskService.aggregate( pipeline );
+          if ( filterByApprovalStatus && filterByApprovalStatus?.length ) {
+            if ( type == 'fixture' ) {
+              let pendingData = [];
+              let agreeData = [];
+              let disAgreeData = [];
+              if ( filterByApprovalStatus.includes( 'pending' ) ) {
+                pendingData = data.filter( ( element ) => {
+                  return element?.approvalStatus == 'pending';
+                } );
+              } if ( filterByApprovalStatus.includes( 'agree' ) ) {
+                agreeData = data.filter( ( element ) => {
+                  return element?.answers?.[0]?.status == 'agree';
+                } );
+              } if ( filterByApprovalStatus.includes( 'disagree' ) ) {
+                disAgreeData = data.filter( ( element ) => {
+                  return element?.answers?.[0]?.status == 'disagree';
+                } );
+              }
+              data = [ ...pendingData, ...agreeData, ...disAgreeData ];
+            } else {
+              data.forEach( ( element ) => {
+                element.answers?.forEach( ( ans ) => {
+                  ans.issues = ans.issues?.filter(
+                      ( issue ) => issue.Details && issue.Details.length > 0,
+                  );
+                } );
+                element.answers = element.answers?.filter(
+                    ( ans ) => ans.issues && ans.issues.length > 0,
+                );
+              } );
+            }
+            data = data.filter(
+                ( element ) => element.answers && element.answers.length > 0,
+            );
+          }
+
+
+          resultMap[type] = data;
+
+          const comments = await planoGlobalCommentService.find( {
+            planoId: new mongoose.Types.ObjectId( req.body.planoId ),
+            floorId: new mongoose.Types.ObjectId( req.body.floorId ),
+            taskType: type,
+          } );
+          commentMap[type] = comments;
+        } ),
+    );
+
+    const response = {
+      layoutData: resultMap['layout'] || [],
+      fixtureData: resultMap['fixture'] || [],
+      VmData: resultMap['vm'] || [],
+      layoutComment: commentMap['layout'] || [],
+      fixtureComment: commentMap['fixture'] || [],
+      vmComment: commentMap['vm'] || [],
+    };
+
+    response.fixtureData = await Promise.all( response.fixtureData.map( async ( ele ) => {
+      if ( ele?.FixtureData && ele?.FixtureData?._id ) {
+        // 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 } );
+    return res.sendError( e, 500 );
+  }
+}
+export async function getplanoFeedbackv1( req, res ) {
+  try {
+    const taskTypes = req.body.filterByTask && req.body.filterByTask.length > 0 ? req.body.filterByTask : [ 'layout', 'fixture', 'vm' ];
+    const filterByStatus = req.body.filterByStatus || [];
+    const filterByApprovalStatus = req.body.filterByApprovalStatus || '';
+    const resultMap = {};
+    const commentMap = {};
+    await Promise.all(
+        taskTypes.map( async ( type, index ) => {
+          const pipeline = buildPipelineByType1( type, req.body.planoId, req.body.floorId, filterByStatus, filterByApprovalStatus, req.body.showtask );
+
+          let data = await planoTaskService.aggregate( pipeline );
+          if ( filterByApprovalStatus && filterByApprovalStatus !== '' ) {
+            data.forEach( ( element ) => {
+              element.answers?.forEach( ( ans ) => {
+                ans.issues = ans.issues?.filter(
+                    ( issue ) => issue.Details && issue.Details.length > 0,
+                );
+              } );
+              element.answers = element.answers?.filter(
+                  ( ans ) => ans.issues && ans.issues.length > 0,
+              );
+            } );
+            data = data.filter(
+                ( element ) => element.answers && element.answers.length > 0,
+            );
+          }
+
+
+          resultMap[type] = data;
+
+          const comments = await planoGlobalCommentService.find( {
+            planoId: new mongoose.Types.ObjectId( req.body.planoId ),
+            floorId: new mongoose.Types.ObjectId( req.body.floorId ),
+            taskType: type,
+          } );
+          commentMap[type] = comments;
+        } ),
+    );
+
+    const response = {
+      layoutData: resultMap['layout'] || [],
+      fixtureData: resultMap['fixture'] || [],
+      VmData: resultMap['vm'] || [],
+      layoutComment: commentMap['layout'] || [],
+      fixtureComment: commentMap['fixture'] || [],
+      vmComment: commentMap['vm'] || [],
+    };
+
+    res.sendSuccess( response );
+  } catch ( e ) {
+    logger.error( { functionName: 'getplanoFeedback', error: e, message: req.body } );
+    return res.sendError( e, 500 );
+  }
+}
+
+function buildPipelineByType( type, planoId, floorId, filterByStatus, filterByApprovalStatus, showtask, taskId = 0 ) {
+  const matchStage = {
+    $match: {
+      planoId: new mongoose.Types.ObjectId( planoId ),
+      floorId: new mongoose.Types.ObjectId( floorId ),
+      type: type,
+      ...( taskId && { taskId: new mongoose.Types.ObjectId( taskId ) } ),
+      ...( filterByStatus?.length ? { status: { $in: filterByStatus } } : {} ),
+    },
+  };
+
+
+  const conditionalMatchExpr = showtask ?
+    {
+      $eq: [ '$_id', '$$taskId' ],
+    } :
+    {
+      $and: [
+        {
+          $eq: [ '$_id', '$$taskId' ],
+        },
+        {
+          $or: [
+            { $eq: [ '$redoStatus', true ] },
+            {
+              $and: [
+                { $eq: [ '$redoStatus', false ] },
+                { $eq: [ '$checklistStatus', 'submit' ] },
+              ],
+            },
+          ],
+        },
+      ],
+    };
+
+  const taskLookup = {
+    $lookup: {
+      from: 'processedtasks',
+      let: { taskId: '$taskId' },
+      pipeline: [
+        {
+          $match: {
+            $expr: conditionalMatchExpr,
+          },
+        },
+        {
+          $project: {
+            userName: 1,
+            createdAt: 1,
+            createdByName: 1,
+            submitTime_string: 1,
+          },
+        },
+      ],
+      as: 'taskData',
+    },
+  };
+
+
+  const unwindTask = { $unwind: { path: '$taskData', preserveNullAndEmptyArrays: false } };
+
+  const commonLookups = type === 'layout' ? [] : [
+    {
+      $lookup: {
+        from: 'storefixtures',
+        let: { fixtureId: '$fixtureId' },
+        pipeline: [
+          {
+            $match: { $expr: { $eq: [ '$_id', '$$fixtureId' ] } },
+          },
+        ],
+        as: 'FixtureData',
+      },
+    },
+    {
+      $unwind: { path: '$FixtureData', preserveNullAndEmptyArrays: true },
+    },
+    {
+      $lookup: {
+        from: 'fixtureshelves',
+        let: { fixtureId: '$FixtureData._id' },
+        pipeline: [
+          {
+            $match: { $expr: { $eq: [ '$fixtureId', '$$fixtureId' ] } },
+          },
+        ],
+        as: 'Fixtureshelves',
+      },
+    },
+
+    {
+      $set: {
+        'FixtureData.shelfConfig': '$Fixtureshelves',
+      },
+    },
+  ];
+
+  const vmStages = [ 'vm', 'vmRollout' ].includes( type ) ? [
+    {
+      $unwind: { path: '$FixtureData.vmConfig', preserveNullAndEmptyArrays: true },
+    },
+    {
+      $lookup: {
+        from: 'planovmdetails',
+        let: { vmId: '$FixtureData.vmConfig.vmId' },
+        pipeline: [
+          {
+            $match: { $expr: { $eq: [ '$_id', '$$vmId' ] } },
+          },
+          {
+            $project: { vmName: 1, vmType: 1 },
+          },
+        ],
+        as: 'vmDetails',
+      },
+    },
+    {
+      $unwind: { path: '$vmDetails', preserveNullAndEmptyArrays: true },
+    },
+    {
+      $set: {
+        'FixtureData.vmConfig.vmName': '$vmDetails.vmName',
+        'FixtureData.vmConfig.vmType': '$vmDetails.vmType',
+      },
+    },
+    {
+      $group: {
+        _id: '$_id',
+        answers: { $first: '$answers' },
+        createdAt: { $first: '$createdAt' },
+        date_iso: { $first: '$date_iso' },
+        date_string: { $first: '$date_string' },
+        fixtureId: { $first: '$fixtureId' },
+        floorId: { $first: '$floorId' },
+        planoId: { $first: '$planoId' },
+        status: { $first: '$status' },
+        taskType: { $first: '$taskType' },
+        type: { $first: '$type' },
+        taskId: { $first: '$taskId' },
+        taskData: { $first: '$taskData' },
+        baseFixtureData: { $first: '$FixtureData' },
+        collectedVmConfigs: {
+          $push: {
+            $cond: [
+              { $ne: [ '$FixtureData.vmConfig', {} ] },
+              '$FixtureData.vmConfig',
+              '$$REMOVE',
+            ],
+          },
+        },
+      },
+    },
+    {
+      $set: {
+        FixtureData: {
+          $mergeObjects: [
+            '$baseFixtureData',
+            {
+              vmConfig: {
+                $reduce: {
+                  input: '$collectedVmConfigs',
+                  initialValue: [],
+                  in: {
+                    $cond: [
+                      { $isArray: '$$this' },
+                      { $concatArrays: [ '$$value', '$$this' ] },
+                      { $concatArrays: [ '$$value', [ '$$this' ] ] },
+                    ],
+                  },
+                },
+              },
+            },
+          ],
+        },
+      },
+    },
+  ] : [];
+
+
+  let pipeline = [
+    matchStage,
+    taskLookup,
+    unwindTask,
+    ...commonLookups,
+    ...vmStages,
+    { $sort: { _id: -1 } },
+  ];
+  if ( filterByApprovalStatus && filterByApprovalStatus != '' && type !== 'fixture' ) {
+    pipeline = [];
+    pipeline.push( matchStage );
+    pipeline.push(
+        {
+          $addFields: {
+            answers: {
+              $map: {
+                input: '$answers',
+                as: 'ans',
+                in: {
+                  $mergeObjects: [
+                    '$$ans',
+                    {
+                      issues: {
+                        $map: {
+                          input: '$$ans.issues',
+                          as: 'issue',
+                          in: {
+                            $mergeObjects: [
+                              '$$issue',
+                              {
+                                Details: {
+                                  $filter: {
+                                    input: '$$issue.Details',
+                                    as: 'detail',
+                                    cond: filterByApprovalStatus === 'pending' ?
+                                    { $eq: [ '$$detail.status', 'pending' ] } :
+                                    { $ne: [ '$$detail.status', 'pending' ] },
+                                  },
+                                },
+                              },
+                            ],
+                          },
+                        },
+                      },
+                    },
+                  ],
+                },
+              },
+            },
+          },
+        },
+    );
+    pipeline.push( taskLookup );
+    pipeline.push( unwindTask );
+    pipeline.push( ...commonLookups );
+    pipeline.push( ...vmStages );
+    pipeline.push( { $sort: { _id: -1 } } );
+  }
+
+
+  return pipeline;
+}
+
+function buildPipelineByType1( type, planoId, floorId, filterByStatus, filterByApprovalStatus, showtask, taskId = 0 ) {
+  const matchStage = {
+    $match: {
+      planoId: new mongoose.Types.ObjectId( planoId ),
+      floorId: new mongoose.Types.ObjectId( floorId ),
+      type: type,
+      ...( taskId && { taskId: new mongoose.Types.ObjectId( taskId ) } ),
+      ...( filterByStatus?.length ? { status: { $in: filterByStatus } } : {} ),
+    },
+  };
+
+
+  const conditionalMatchExpr = showtask ?
+    {
+      $eq: [ '$_id', '$$taskId' ],
+    } :
+    {
+      $and: [
+        {
+          $eq: [ '$_id', '$$taskId' ],
+        },
+        {
+          $or: [
+            { $eq: [ '$redoStatus', true ] },
+            {
+              $and: [
+                { $eq: [ '$redoStatus', false ] },
+                { $eq: [ '$checklistStatus', 'submit' ] },
+              ],
+            },
+          ],
+        },
+      ],
+    };
+
+  const taskLookup = {
+    $lookup: {
+      from: 'processedtasks',
+      let: { taskId: '$taskId' },
+      pipeline: [
+        {
+          $match: {
+            $expr: conditionalMatchExpr,
+          },
+        },
+        {
+          $project: {
+            userName: 1,
+            createdAt: 1,
+            createdByName: 1,
+            submitTime_string: 1,
+          },
+        },
+      ],
+      as: 'taskData',
+    },
+  };
+
+
+  const unwindTask = { $unwind: { path: '$taskData', preserveNullAndEmptyArrays: false } };
+
+  const commonLookups = type === 'layout' ? [] : [
+    {
+      $lookup: {
+        from: 'storefixtureduplicates',
+        let: { fixtureId: '$fixtureId' },
+        pipeline: [
+          {
+            $match: { $expr: { $eq: [ '$_id', '$$fixtureId' ] } },
+          },
+        ],
+        as: 'FixtureData',
+      },
+    },
+    {
+      $unwind: { path: '$FixtureData', preserveNullAndEmptyArrays: true },
+    },
+    {
+      $lookup: {
+        from: 'fixtureshelfduplicates',
+        let: { fixtureId: '$FixtureData._id' },
+        pipeline: [
+          {
+            $match: { $expr: { $eq: [ '$fixtureId', '$$fixtureId' ] } },
+          },
+        ],
+        as: 'Fixtureshelves',
+      },
+    },
+
+    {
+      $set: {
+        'FixtureData.shelfConfig': '$Fixtureshelves',
+      },
+    },
+  ];
+
+  const vmStages = [ 'vm', 'vmRollout' ].includes( type ) ? [
+    {
+      $unwind: { path: '$FixtureData.vmConfig', preserveNullAndEmptyArrays: true },
+    },
+    {
+      $lookup: {
+        from: 'planovmdetailduplicates',
+        let: { vmId: '$FixtureData.vmConfig.vmId' },
+        pipeline: [
+          {
+            $match: { $expr: { $eq: [ '$_id', '$$vmId' ] } },
+          },
+          {
+            $project: { vmName: 1, vmType: 1 },
+          },
+        ],
+        as: 'vmDetails',
+      },
+    },
+    {
+      $unwind: { path: '$vmDetails', preserveNullAndEmptyArrays: true },
+    },
+    {
+      $set: {
+        'FixtureData.vmConfig.vmName': '$vmDetails.vmName',
+        'FixtureData.vmConfig.vmType': '$vmDetails.vmType',
+      },
+    },
+    {
+      $group: {
+        _id: '$_id',
+        answers: { $first: '$answers' },
+        createdAt: { $first: '$createdAt' },
+        date_iso: { $first: '$date_iso' },
+        date_string: { $first: '$date_string' },
+        fixtureId: { $first: '$fixtureId' },
+        floorId: { $first: '$floorId' },
+        planoId: { $first: '$planoId' },
+        status: { $first: '$status' },
+        taskType: { $first: '$taskType' },
+        type: { $first: '$type' },
+        taskId: { $first: '$taskId' },
+        taskData: { $first: '$taskData' },
+        baseFixtureData: { $first: '$FixtureData' },
+        collectedVmConfigs: {
+          $push: {
+            $cond: [
+              { $ne: [ '$FixtureData.vmConfig', {} ] },
+              '$FixtureData.vmConfig',
+              '$$REMOVE',
+            ],
+          },
+        },
+      },
+    },
+    {
+      $set: {
+        FixtureData: {
+          $mergeObjects: [
+            '$baseFixtureData',
+            {
+              vmConfig: {
+                $reduce: {
+                  input: '$collectedVmConfigs',
+                  initialValue: [],
+                  in: {
+                    $cond: [
+                      { $isArray: '$$this' },
+                      { $concatArrays: [ '$$value', '$$this' ] },
+                      { $concatArrays: [ '$$value', [ '$$this' ] ] },
+                    ],
+                  },
+                },
+              },
+            },
+          ],
+        },
+      },
+    },
+  ] : [];
+
+
+  let pipeline = [
+    matchStage,
+    taskLookup,
+    unwindTask,
+    ...commonLookups,
+    ...vmStages,
+    { $sort: { _id: -1 } },
+  ];
+  if ( filterByApprovalStatus && filterByApprovalStatus != '' ) {
+    pipeline = [];
+    pipeline.push( matchStage );
+    pipeline.push(
+        {
+          $addFields: {
+            answers: {
+              $map: {
+                input: '$answers',
+                as: 'ans',
+                in: {
+                  $mergeObjects: [
+                    '$$ans',
+                    {
+                      issues: {
+                        $map: {
+                          input: '$$ans.issues',
+                          as: 'issue',
+                          in: {
+                            $mergeObjects: [
+                              '$$issue',
+                              {
+                                Details: {
+                                  $filter: {
+                                    input: '$$issue.Details',
+                                    as: 'detail',
+                                    cond: filterByApprovalStatus === 'pending' ?
+                                    { $eq: [ '$$detail.status', 'pending' ] } :
+                                    { $ne: [ '$$detail.status', 'pending' ] },
+                                  },
+                                },
+                              },
+                            ],
+                          },
+                        },
+                      },
+                    },
+                  ],
+                },
+              },
+            },
+          },
+        },
+    );
+    pipeline.push( taskLookup );
+    pipeline.push( unwindTask );
+    pipeline.push( ...commonLookups );
+    pipeline.push( ...vmStages );
+    pipeline.push( { $sort: { _id: -1 } } );
+  }
+
+
+  return pipeline;
+}
+
+export async function getStoreFixturesfeedback( req, res ) {
+  try {
+    let query = [];
+
+
+    query.push( {
+      $match: {
+        planoId: new mongoose.Types.ObjectId( req.body.planoId ),
+        floorId: new mongoose.Types.ObjectId( req.body.floorId ),
+        type: { $ne: 'layout' },
+      },
+    },
+    {
+      $lookup: {
+        from: 'processedtasks',
+        let: { 'taskId': '$taskId' },
+        pipeline: [
+          {
+            $match: {
+              $expr: {
+                $and: [
+                  { $eq: [ '$_id', '$$taskId' ] },
+                ],
+              },
+            },
+          },
+          {
+            $project: {
+              'userName': 1,
+              'createdAt': 1,
+              'createdByName': 1,
+              'submitTime_string': 1,
+            },
+          },
+        ],
+        as: 'taskData',
+      },
+
+    }, { $unwind: { path: '$taskData', preserveNullAndEmptyArrays: true } },
+    {
+      $lookup: {
+        from: 'fixtureconfigs',
+        let: { 'fixtureId': '$fixtureId' },
+        pipeline: [
+          {
+            $match: {
+              $expr: {
+                $and: [
+                  { $eq: [ '$_id', '$$fixtureId' ] },
+                ],
+              },
+            },
+          },
+        ],
+        as: 'FixtureData',
+      },
+    },
+    {
+      $unwind: { path: '$FixtureData', preserveNullAndEmptyArrays: true },
+    },
+    );
+
+
+    let findPlanoCompliance = await planoTaskService.aggregate( query );
+    res.sendSuccess( { count: findPlanoCompliance.length, data: findPlanoCompliance } );
+  } catch ( e ) {
+    logger.error( { functionName: 'getplanoFeedbackFixture', error: e, message: req.body } );
+    return res.sendError( e, 500 );
+  }
+}
+export async function updateStorePlano( req, res ) {
+  try {
+    const { floorId, data } = req.body;
+
+    const floorData = await floorService.findOne( { _id: new mongoose.Types.ObjectId( floorId ) } );
+
+    const additionalMeta = {
+      clientId: '11',
+      storeId: floorData.toObject().storeId,
+      storeName: floorData.toObject().storeName,
+      planoId: floorData.toObject().planoId,
+      floorId: floorData.toObject()._id,
+    };
+
+    const layoutPolygon = JSON.parse( JSON.stringify( data.layoutPolygon ) );
+
+    layoutPolygon.forEach( ( element ) => {
+      delete element.fixtures;
+    } );
+
+    await floorService.updateOne( { _id: new mongoose.Types.ObjectId( floorId ) },
+        {
+          layoutPolygon: layoutPolygon,
+          ...( req.body?.editMode === true && { isEdited: true } ),
+        } );
+
+    const currentWallFixtures = data.layoutPolygon.flatMap( ( element ) =>
+      ( element.fixtures || [] ).map( ( fixture ) => fixture ),
+    );
+    const currentFloorFixtures = ( data.centerFixture || [] );
+    const currentFixtures = [ ...currentWallFixtures, ...currentFloorFixtures ];
+
+    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() ),
+    );
+
+    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 && !currentFixtureIds.has( f._id.toString() ),
+    );
+
+    if ( removedFixtures.length ) {
+      const fixtureIds = removedFixtures.map( ( fixture ) => fixture.toObject()._id );
+      await storeFixtureService.deleteMany( { _id: { $in: fixtureIds } } );
+      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 ];
+
+    if ( newFixtures.length ) {
+      newFixtures.forEach( async ( fixture ) => {
+        delete fixture._id;
+        const fixturePayload = {
+          ...additionalMeta,
+          ...fixture,
+        };
+        const createdFixture = await storeFixtureService.create( fixturePayload );
+        fixture.shelfConfig.forEach( async ( shelf ) => {
+          delete shelf._id;
+          const shelfPayload = {
+            ...additionalMeta,
+            ...shelf,
+            fixtureId: createdFixture.toObject()._id,
+
+          };
+          await fixtureShelfService.create( shelfPayload );
+        } );
+      } );
+    }
+
+
+    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 );
+
+        await storeFixtureService.removeKeys( { fixtureType: 'floor', _id: fixture._id }, { $unset: { associatedElementType: '', associatedElementNumber: '' } } );
+
+        await fixtureShelfService.deleteMany( { fixtureId: new mongoose.Types.ObjectId( fixture._id ) } );
+
+        fixture.shelfConfig.forEach( async ( shelf ) => {
+          delete shelf._id;
+          const shelfPayload = {
+            ...additionalMeta,
+            ...shelf,
+            fixtureId: updatedFixture.toObject()._id,
+          };
+          await fixtureShelfService.create( shelfPayload );
+        } );
+      }
+    } );
+
+    await planoService.updateOne( { _id: floorData.toObject()?.planoId }, { $set: { updatedAt: new Date() } } );
+
+    res.sendSuccess( 'Updated Successfully' );
+  } catch ( e ) {
+    logger.error( { functionName: 'updateStorePlano', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+export async function fixtureList( req, res ) {
+  try {
+    let findData = await fixtureLibraryService.find( { clientId: req.query.clientId } );
+    if ( findData.length === 0 ) {
+      return res.sendError( 'nodata found', 204 );
+    }
+    res.sendSuccess( findData );
+  } catch ( e ) {
+    logger.error( { functionName: 'fixtureList', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+export async function templateList( req, res ) {
+  try {
+    let findData = await fixtureConfigService.find( { clientId: req.query.clientId, fixtureLibraryId: new mongoose.Types.ObjectId( req.query.fixtureId ) } );
+    if ( findData.length === 0 ) {
+      return res.sendError( 'nodata found', 204 );
+    }
+    res.sendSuccess( findData );
+  } catch ( e ) {
+    logger.error( { functionName: 'templateList', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+export async function fixtureBrandsList( req, res ) {
+  try {
+    let findData = await planoproductCategoryService.find( { clientId: req.query.clientId } );
+    if ( findData.length === 0 ) {
+      return res.sendError( 'nodata found', 204 );
+    }
+    res.sendSuccess( findData );
+  } catch ( e ) {
+    logger.error( { functionName: 'fixtureBrandsList', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+
+export async function fixtureVMList( req, res ) {
+  try {
+    let findData = await planoVmService.find( { clientId: req.query.clientId } );
+    if ( findData.length === 0 ) {
+      return res.sendError( 'nodata found', 204 );
+    }
+    res.sendSuccess( findData );
+  } catch ( e ) {
+    logger.error( { functionName: 'fixtureVMList', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+
+export async function fixtureVMListv1( req, res ) {
+  try {
+    let findData = await planoVmDuplicateService.find( { clientId: req.query.clientId } );
+    if ( findData.length === 0 ) {
+      return res.sendError( 'nodata found', 204 );
+    }
+    res.sendSuccess( findData );
+  } catch ( e ) {
+    logger.error( { functionName: 'fixtureVMListv1', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+export async function updateFixtureStatus( req, res ) {
+  try {
+    let comments = {
+      userId: req.user._id,
+      userName: req.user.userName,
+      role: req.user.role,
+      responsetype: req.body.type,
+      comment: req.body.comments,
+    };
+
+    if ( req.body.taskType.includes( 'fixture' ) ) {
+      await planoTaskService.updateOnefilters(
+          { _id: new mongoose.Types.ObjectId( req.body._id ) },
+          {
+            $set: { 'answers.$[ans].status': req.body.type },
+          },
+          [
+            { 'ans._id': new mongoose.Types.ObjectId( req.body.answerId ) },
+
+          ],
+      );
+      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', taskType: 'initial' } );
+      let fixtureTask = await planoTaskService.find(
+          {
+            planoId: new mongoose.Types.ObjectId( req.body.planoId ),
+            floorId: new mongoose.Types.ObjectId( req.body.floorId ),
+            type: 'fixture',
+          },
+      );
+      if ( fixtureTask.length > 0 ) {
+        let allTaskDone = fixtureTask.filter( ( data ) => !data?.answers?.[0]?.status || data?.answers?.[0]?.status == 'disagree' );
+        if ( allTaskDone.length === 0 ) {
+          await floorService.updateOne( { _id: new mongoose.Types.ObjectId( req.body.floorId ) }, { planoProgress: 100 } );
+        }
+      }
+    } else {
+      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' ) {
+        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' );
+  } catch ( e ) {
+    logger.error( { functionName: 'updateFixtureStatus', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+
+export async function updateApprovalStatus( req, res ) {
+  try {
+    await planoTaskService.updateOnefilters(
+        { _id: new mongoose.Types.ObjectId( req.body._id ) },
+        { $set: { approvalStatus: 'approved' } } );
+    res.sendSuccess( 'updated successfully' );
+  } catch ( e ) {
+    logger.error( { functionName: 'updateApprovalStatus', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+export async function updateRolloutStatus( req, res ) {
+  try {
+    let comments = {
+      userId: req.user._id,
+      userName: req.user.userName,
+      role: req.user.role,
+      responsetype: req.body.type,
+      comment: req.body.comments,
+    };
+
+    if ( req.body.issueId && req.body.DetailsId ) {
+      let updateResponse = await planoTaskService.updateOnefilters(
+          { _id: new mongoose.Types.ObjectId( req.body._id ) },
+          {
+            $set: {
+              'answers.$[ans].issues.$[iss].Details.$[det].status': req.body.type,
+              'answers.$[ans].issues.$[iss].Details.$[det].adminStatus': req.body.type === 'agree' ? 'approved' : 'Unapproved',
+            },
+          },
+          [
+            { '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',
+                'approvalStatus': 'approved',
+              },
+          );
+          let data = {};
+          if ( req.body.taskType == 'vmRollout' ) {
+            data['isVmEdited'] = false;
+          } else {
+            data['isMerchEdited'] = false;
+          }
+          await storeFixtureService.updateOne( { _id: updateResponse.fixtureId }, data );
+        }
+      }
+      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 ) },
+          ],
+      );
+    } else {
+      let updateResponse = await planoTaskService.updateOnefilters(
+          { _id: new mongoose.Types.ObjectId( req.body._id ) },
+          {
+            $set: {
+              'answers.$[ans].status': req.body.type,
+            },
+          },
+          [
+            { 'ans._id': new mongoose.Types.ObjectId( req.body.answerId ) },
+          ],
+      );
+      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 ) },
+          ],
+      );
+      if ( req.body.type == 'agree' ) {
+        await planoTaskService.updateOne(
+            {
+              _id: new mongoose.Types.ObjectId( req.body._id ),
+            },
+            {
+              'approvalStatus': 'approved',
+            },
+        );
+        let data = {};
+        if ( req.body.taskType == 'vmRollout' ) {
+          data['isVmEdited'] = false;
+        } else {
+          data['isMerchEdited'] = false;
+        }
+        await storeFixtureService.updateOne( { _id: updateResponse.fixtureId }, data );
+      }
+    }
+
+    res.sendSuccess( 'updated successfully' );
+  } catch ( e ) {
+    logger.error( { functionName: 'updateFixtureStatus', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+
+
+export async function updateStoreFixture( req, res ) {
+  try {
+    const { fixtureId, data } = req.body;
+
+    let configId;
+
+    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 );
+        if ( !ele?.zone ) {
+          ele.zone = findShelfProduct?.zone ?? 'Bottom';
+        }
+        if ( !ele?.productBrandName ) {
+          ele.productBrandName = findShelfProduct?.productBrandName ?? [];
+        }
+        if ( !ele?.productCategory ) {
+          ele.productCategory = findShelfProduct?.productCategory ?? [];
+        }
+        if ( !ele?.productSubCategory ) {
+          ele.productSubCategory = findShelfProduct?.productSubCategory ?? [];
+        }
+      } );
+      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}-variant-${templateIndex}`,
+        templateData.templateType = 'sub';
+        templateData.masterTemplateId = fixtureMasterTemplate._id;
+        templateData.templateIndex = templateIndex;
+        templateData.createdAt = new Date();
+        templateData.updatedAt = new Date();
+        let subTemplate = await fixtureConfigService.create( templateData );
+        configId = subTemplate._id;
+
+        data.fixtureConfigId = subTemplate._id;
+        data.masterTemplateId = fixtureMasterTemplate._id;
+      } else {
+        data.fixtureConfigId = fixturesubTemplate?.[0]?._id;
+      }
+    }
+
+    const productBrandName = new Set();
+    const productCategory = new Set();
+    const productSubCategory = new Set();
+
+    let fixtureCapacity = 0;
+
+    data.shelfConfig.forEach( ( shelf ) => {
+      const { productBrandName: brand, productCategory: category, productSubCategory: subCategory } = shelf;
+
+      if ( typeof shelf?.productPerShelf === 'number' ) {
+        if ( shelf?.shelfType === 'shelf' ) {
+          fixtureCapacity += shelf.productPerShelf;
+        }
+
+        if ( shelf?.shelfType === 'tray' ) {
+          fixtureCapacity += ( shelf?.productPerShelf * shelf?.trayRows );
+        }
+      }
+
+      if ( Array.isArray( brand ) ) {
+        brand.forEach( ( b ) => productBrandName.add( b ) );
+      }
+
+      if ( Array.isArray( category ) ) {
+        category.forEach( ( c ) => productCategory.add( c ) );
+      }
+
+      if ( Array.isArray( subCategory ) ) {
+        subCategory.forEach( ( s ) => productSubCategory.add( s ) );
+      }
+    } );
+
+
+    if ( data?.fixtureConfigId && currentFixtureDoc.fixtureConfigId.toString() !== data.fixtureConfigId ) {
+      const newTemplate = await fixtureConfigService.findOne( { _id: data.fixtureConfigId } );
+      currentFixtureDoc = {
+        ...currentFixtureDoc,
+        ...newTemplate.toObject(),
+        fixtureConfigId: newTemplate.toObject()._id,
+        fixtureCapacity: fixtureCapacity,
+        productBrandName: [ ...productBrandName ],
+        productCategory: [ ...productCategory ],
+        productSubCategory: [ ...productSubCategory ],
+      };
+    } else {
+      currentFixtureDoc = {
+        ...currentFixtureDoc,
+        ...data,
+        fixtureCapacity: fixtureCapacity,
+        productBrandName: [ ...productBrandName ],
+        productCategory: [ ...productCategory ],
+        productSubCategory: [ ...productSubCategory ],
+      };
+    }
+
+    if ( data.productResolutionLevel == 'L1' ) {
+      currentFixtureDoc.productBrandName = [ ...new Set( data.productBrandName.map( ( ele ) => ele ) ) ];
+      currentFixtureDoc.productCategory = [ ...new Set( data.productCategory.map( ( ele ) => ele ) ) ];
+      currentFixtureDoc.productSubCategory = [ ...new Set( data.productSubCategory.map( ( ele ) => ele ) ) ];
+    }
+
+
+    delete currentFixtureDoc._id;
+
+
+    await storeFixtureService.updateOne( { _id: new mongoose.Types.ObjectId( fixtureId ) }, currentFixtureDoc );
+
+    if ( data?.shelfConfig?.length ) {
+      await fixtureShelfService.deleteMany( { fixtureId: new mongoose.Types.ObjectId( fixtureId ) } );
+
+
+      data.shelfConfig.forEach( async ( shelf ) => {
+        delete shelf?._id;
+        const additionalMeta = {
+          clientId: currentFixture.clientId,
+          storeId: currentFixture.storeId,
+          storeName: currentFixture.storeName,
+          planoId: currentFixture.planoId,
+          floorId: currentFixture.floorId,
+          fixtureId: currentFixture._id,
+        };
+
+        await fixtureShelfService.create( { ...additionalMeta, ...shelf } );
+      } );
+    }
+    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 },
+          },
+      );
+    }
+    if ( req.body?.editMode ) {
+      await floorService.updateOne( { _id: new mongoose.Types.ObjectId( currentFixture.floorId ) }, { isEdited: true } );
+    }
+    res.sendSuccess( { message: 'Updated Successfully', ...( configId && { id: configId } ) } );
+  } catch ( e ) {
+    logger.error( { functionName: 'updateStoreFixture', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+
+export async function updateredostatus( req, res ) {
+  try {
+    if ( req.body.type === 'layout' ) {
+      await planoTaskService.updateOne(
+          {
+            planoId: new mongoose.Types.ObjectId( req.body.planoId ),
+            floorId: new mongoose.Types.ObjectId( req.body.floorId ),
+            type: req.body.type,
+          },
+          {
+            'answers.$[].issues.$[].status': 'completed',
+            'answers.$[].issues.$[].Details.$[].status': 'agree',
+            'status': 'complete',
+          },
+      );
+    } else {
+      await planoTaskService.updateOne(
+          {
+            planoId: new mongoose.Types.ObjectId( req.body.planoId ),
+            floorId: new mongoose.Types.ObjectId( req.body.floorId ),
+            fixtureId: new mongoose.Types.ObjectId( req.body.fixtureId ),
+            type: req.body.type,
+          },
+          {
+            'answers.$[].issues.$[].status': 'completed',
+            'answers.$[].issues.$[].Details.$[].status': 'agree',
+            'status': 'complete',
+          },
+      );
+    }
+    res.sendSuccess( 'updated successfully' );
+  } catch ( e ) {
+    logger.error( { functionName: 'updateredostatus', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+
+
+export async function updateGlobalComment( req, res ) {
+  try {
+    let payload = {
+      userId: req.user._id,
+      userName: req.user.userName,
+      comment: req.body.comment,
+      responsetype: req.body.responsetype,
+      planoId: new mongoose.Types.ObjectId( req.body.planoId ),
+      floorId: new mongoose.Types.ObjectId( req.body.floorId ),
+      taskType: req.body.taskType,
+      clientId: req.body.clientId,
+      taskId: req.body.taskId,
+    };
+    await planoGlobalCommentService.create( payload );
+    await insertOpenSearchData( JSON.parse( process.env.OPENSEARCH ).planoglobalcomments, payload );
+
+    res.sendSuccess( 'updated successfully' );
+  } catch ( e ) {
+    logger.error( { functionName: 'updateGlobalComment', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+export async function getGlobalComment( req, res ) {
+  try {
+    // let layoutComment = await planoGlobalCommentService.find( {
+    //   planoId: new mongoose.Types.ObjectId( req.body.planoId ),
+    //   floorId: new mongoose.Types.ObjectId( req.body.floorId ),
+    //   taskType: req.body.taskType,
+    // } );
+
+    let taskId = [];
+    if ( req.body?.taskId ) {
+      taskId.push( new mongoose.Types.ObjectId( req.body.taskId ) );
+    }
+
+    if ( req.body?.refTaskId ) {
+      taskId.push( new mongoose.Types.ObjectId( req.body.refTaskId ) );
+    }
+
+    let layoutComment = await planoGlobalCommentService.find( {
+      planoId: new mongoose.Types.ObjectId( req.body.planoId ),
+      floorId: new mongoose.Types.ObjectId( req.body.floorId ),
+      ...( taskId.length && { taskId: { $in: taskId } } ),
+      taskType: req.body.taskType,
+    } );
+
+    res.sendSuccess( layoutComment );
+  } catch ( e ) {
+    logger.error( { functionName: 'getGlobalComment', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+
+export async function getAllPlanoRevisions( req, res ) {
+  try {
+    const { clientId } = req.body;
+
+    if ( !clientId ) {
+      return res.sendError( 'Client Id is required', 400 );
+    }
+
+    const revisions = await planoRevisionService.find(
+        { clientId },
+        { storeName: 1, storeId: 1, planoId: 1, floorId: 1, createdAt: 1 },
+    );
+
+    res.sendSuccess( revisions );
+  } catch ( e ) {
+    logger.error( { functionName: 'getAllPlanoRevisions', error: e } );
+    res.sendError( 'Failed to fetch plano revisions', 500 );
+  }
+}
+
+export async function createPlanoRevision( req, res ) {
+  try {
+    const { storeName, storeId, clientId, planoId, floorId, floorData } = req.body;
+
+    if ( !storeName || !storeId || !clientId || !planoId || !floorId || !floorData ) {
+      return res.sendError( 'Missing required fields', 400 );
+    }
+
+    const newRevision = await planoRevisionService.create( {
+      storeName,
+      storeId,
+      clientId,
+      planoId,
+      floorId,
+      floorData,
+    } );
+
+    res.sendSuccess( newRevision );
+  } catch ( e ) {
+    logger.error( { functionName: 'createPlanoRevision', error: e } );
+    res.sendError( 'Failed to create plano revision', 500 );
+  }
+}
+
+export async function getPlanoRevisionById( req, res ) {
+  try {
+    const { id } = req.params;
+
+    if ( !id ) {
+      return res.sendError( 'Revision ID is required', 400 );
+    }
+
+    const revision = await planoRevisionService.findOne(
+        { _id: id },
+    );
+
+    if ( !revision ) {
+      return res.sendError( 'Plano revision not found', 404 );
+    }
+
+    res.sendSuccess( revision );
+  } catch ( e ) {
+    logger.error( { functionName: 'getPlanoRevisionById', error: e } );
+    res.sendError( 'Failed to fetch plano revision', 500 );
+  }
+}
+export async function getRolloutFeedback( req, res ) {
+  try {
+    const taskTypes = req.body.filterByTask && req.body.filterByTask.length > 0 ? req.body.filterByTask : [ 'merchRollout', 'vmRollout' ];
+    const filterByStatus = req.body.filterByStatus || [];
+    const filterByApprovalStatus = req.body.filterByApprovalStatus || '';
+    const resultMap = {};
+    const commentMap = {};
+    if ( req.body.redo ) {
+      let taskDetails = await planoTaskService.findOne( { taskId: req.body.taskId, fixtureId: req.body.fixtureId } );
+      if ( !taskDetails ) {
+        req.body.taskId = req.body.refTaskId;
+      }
+    }
+    await Promise.all(
+        taskTypes.map( async ( type, index ) => {
+          const pipeline = buildPipelineByType( type, req.body.planoId, req.body.floorId, filterByStatus, filterByApprovalStatus, req.body.showtask, req.body.taskId );
+
+          let data = await planoTaskService.aggregate( pipeline );
+          if ( filterByApprovalStatus && filterByApprovalStatus !== '' ) {
+            data.forEach( ( element ) => {
+              element.answers?.forEach( ( ans ) => {
+                ans.issues = ans.issues?.filter(
+                    ( issue ) => issue.Details && issue.Details.length > 0,
+                );
+              } );
+              element.answers = element.answers?.filter(
+                  ( ans ) => ans.issues && ans.issues.length > 0,
+              );
+            } );
+            data = data.filter(
+                ( element ) => element.answers && element.answers.length > 0,
+            );
+          }
+
+
+          resultMap[type] = data;
+
+          let taskId = [];
+          if ( req.body.taskId ) {
+            taskId.push( new mongoose.Types.ObjectId( req.body.taskId ) );
+          }
+          if ( req.body.refTaskId ) {
+            taskId.push( new mongoose.Types.ObjectId( req.body.refTaskId ) );
+          }
+
+          const comments = await planoGlobalCommentService.find( {
+            planoId: new mongoose.Types.ObjectId( req.body.planoId ),
+            floorId: new mongoose.Types.ObjectId( req.body.floorId ),
+            ...( taskId.length && { taskId: { $in: taskId } } ),
+            taskType: type,
+          } );
+          commentMap[type] = comments;
+        } ),
+    );
+    const response = {
+      merchRolloutData: resultMap['merchRollout'] || [],
+      vmRolloutData: resultMap['vmRollout'] || [],
+      merchRolloutComment: commentMap['merchRollout'] || [],
+      vmRolloutComment: commentMap['vmRollout'] || [],
+    };
+
+    res.sendSuccess( response );
+  } catch ( e ) {
+    logger.error( { functionName: 'getRolloutFeedback', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+
+
+export async function getRolloutFeedbackv2( req, res ) {
+  try {
+    const taskTypes = req.body.filterByTask && req.body.filterByTask.length > 0 ? req.body.filterByTask : [ 'merchRollout', 'vmRollout' ];
+    const filterByStatus = req.body.filterByStatus || [];
+    const filterByApprovalStatus = req.body.filterByApprovalStatus || '';
+    const resultMap = {};
+    const commentMap = {};
+    await Promise.all(
+        taskTypes.map( async ( type, index ) => {
+          const pipeline = pipelineStage( type, req.body.planoId, req.body.floorId, filterByStatus, filterByApprovalStatus, req.body.showtask );
+          const data = await processedTaskService.aggregate( pipeline );
+          resultMap[type] = data;
+        } ) );
+    const response = {
+      merchRolloutData: resultMap['merchRollout'] || [],
+      vmRolloutData: resultMap['vmRollout'] || [],
+      merchRolloutComment: commentMap['merchRollout'] || [],
+      vmRolloutComment: commentMap['vmRollout'] || [],
+    };
+    if ( filterByStatus.length || filterByApprovalStatus ) {
+      let data = response[`${req.body.type}RolloutData`].filter( ( ele ) => ele.storeFixtureList.length );
+      if ( filterByStatus.length == 1 ) {
+        data = data.filter( ( type ) => {
+          let fixtureList = type.storeFixtureList.filter( ( ele ) => filterByStatus.includes( ele.status ) );
+          if ( filterByStatus.includes( 'complete' ) ) {
+            return type.storeFixtureList.length == fixtureList.length;
+          } else {
+            return fixtureList.length;
+          }
+        },
+        );
+      }
+      if ( filterByApprovalStatus ) {
+        if ( filterByApprovalStatus === 'pending' ) {
+          data = data.filter( ( type ) => {
+            let fixtureList = type.storeFixtureList.filter( ( ele ) => {
+              if ( ele.status === 'complete' && !ele.answers?.[0]?.issues.length && !ele.answers?.[0]?.status ) {
+                return true;
+              } else {
+                return ele.answers?.some( ( ans ) =>
+                  ans.issues?.some( ( issue ) =>
+                    issue?.Details?.some( ( detail ) => detail.status === 'pending' ),
+                  ),
+                );
+              }
+            } );
+
+            return fixtureList.length;
+          } );
+        } else {
+          data = data.filter( ( type ) => {
+            let fixtureList = type.storeFixtureList.filter( ( ele ) => {
+              if ( ele.status === 'complete' && !ele.answers?.[0]?.issues.length && ele.answers?.[0]?.status ) {
+                return true;
+              } else {
+                return ele.answers?.some( ( ans ) =>
+                  ans.issues?.some( ( issue ) =>
+                    issue?.Details?.some( ( detail ) => detail.status !== 'pending' ),
+                  ),
+                );
+              }
+            } );
+
+            return fixtureList.length;
+          } );
+        }
+      }
+      response[`${req.body.type}RolloutData`] = data;
+    }
+    response.vmRolloutData = await Promise.all( response.vmRolloutData.map( async ( ele ) => {
+      ele.storeFixtureList = await Promise.all( ele.storeFixtureList.map( async ( fixt ) => {
+        if ( fixt?.FixtureData?.vmConfig?.length ) {
+          fixt.FixtureData.vmConfig = await Promise.all( fixt?.FixtureData?.vmConfig?.map( async ( config ) => {
+            let vmDetails = await planoVmService.findOne( { _id: config.vmId }, { vmType: 1, vmName: 1 } );
+            return { ...config, vmType: vmDetails.vmType, vmName: vmDetails.vmName };
+          } ) );
+        }
+        return fixt;
+      } ) );
+      return ele;
+    } ) );
+    res.sendSuccess( response );
+  } catch ( e ) {
+    logger.error( { functionName: 'getRolloutFeedbackv2', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+
+
+function pipelineStage( type, planoId, floorId, filterByStatus, filterByApprovalStatus, showtask, taskId = 0 ) {
+  let matchStage = [ {
+    $match: {
+      'planoType': type,
+      'planoId': new mongoose.Types.ObjectId( planoId ),
+      'floorId': new mongoose.Types.ObjectId( floorId ),
+    },
+  },
+
+  {
+    $project: {
+      'planoId': 1,
+      'floorId': 1,
+      'planoType': 1,
+      'userName': 1,
+      'date_string': 1,
+      'createdByName': 1,
+      'createdAt': 1,
+      'submitTime_string': 1,
+      'redoStatus': 1,
+      'checklistStatus': 1,
+    },
+  },
+  ];
+  let taskLookup = {
+    $lookup: {
+      from: 'planotaskcompliances',
+      let: { taskId: '$_id' },
+      pipeline: [
+        {
+          $match: {
+            $expr: {
+              $and: [
+                { $eq: [ '$taskId', '$$taskId' ] },
+              ],
+            },
+          },
+        },
+      ],
+      as: 'planoData',
+    },
+  };
+  let unwindTask = {
+    $unwind: {
+      path: '$planoData',
+      preserveNullAndEmptyArrays: true,
+    },
+  };
+
+  let commandLookup = {
+    $lookup: {
+      from: 'planoglobalcomments',
+      let: { taskId: '$_id' },
+      pipeline: [
+        {
+          $match: {
+            $expr: {
+              $eq: [ '$taskId', '$$taskId' ],
+            },
+          },
+        },
+
+      ],
+      as: 'commentData',
+    },
+  };
+
+
+  const commonLookups = type === 'layout' ? [] : [
+    {
+      $lookup: {
+        from: 'storefixtures',
+        let: { fixtureId: '$planoData.fixtureId' },
+        pipeline: [
+          {
+            $match: { $expr: { $eq: [ '$_id', '$$fixtureId' ] } },
+          },
+        ],
+        as: 'FixtureData',
+      },
+    },
+    {
+      $unwind: { path: '$FixtureData', preserveNullAndEmptyArrays: true },
+    },
+    {
+      $lookup: {
+        from: 'fixtureshelves',
+        let: { fixtureId: '$FixtureData._id' },
+        pipeline: [
+          {
+            $match: { $expr: { $eq: [ '$fixtureId', '$$fixtureId' ] } },
+          },
+        ],
+        as: 'Fixtureshelves',
+      },
+    },
+
+    {
+      $set: {
+        'FixtureData.shelfConfig': '$Fixtureshelves',
+      },
+    },
+  ];
+
+  let finalGrouping = [
+    {
+      $group: {
+        '_id': '$_id',
+        'planoId': { $first: '$planoId' },
+        'floorId': { $first: '$floorId' },
+        'planoType': { $first: '$planoType' },
+        'userName': { $first: '$userName' },
+        'date_string': { $first: '$date_string' },
+        'createdByName': { $first: '$createdByName' },
+        'createdAt': { $first: '$createdAt' },
+        'submitTime_string': { $first: '$submitTime_string' },
+        'redoStatus': { $first: '$redoStatus' },
+        'checklistStatus': { $first: '$checklistStatus' },
+        'storeFixtureList': {
+          $push: {
+            $cond: [
+              {
+                $and: [
+                  {
+                    $or: [
+                      { $eq: [ '$redoStatus', true ] },
+                      {
+                        $and: [
+                          { $eq: [ '$redoStatus', false ] },
+                          { $eq: [ '$checklistStatus', 'submit' ] },
+                        ],
+                      },
+                    ],
+                  },
+                  { $ne: [ { $ifNull: [ '$FixtureData.fixtureName', null ] }, null ] },
+                  // { $gt: [ { $size: { $ifNull: [ '$FixtureData' ] } }, 0 ] },
+                  // { $gt: [ { $size: { $ifNull: [ '$FixtureData.shelfConfig', [] ] } }, 0 ] },
+                ],
+              },
+              {
+                FixtureData: '$FixtureData',
+                Fixtureshelves: '$Fixtureshelves',
+                approvalStatus: '$planoData.approvalStatus',
+                answers: '$planoData.answers',
+                createdAt: '$planoData.createdAt',
+                date_iso: '$planoData.date_iso',
+                date_string: '$planoData.date_string',
+                fixtureId: '$planoData.fixtureId',
+                floorId: '$planoData.floorId',
+                planoId: '$planoData.planoId',
+                status: '$planoData.status',
+                storeId: '$planoData.storeId',
+                storeName: '$planoData.storeName',
+                taskId: '$planoData.taskId',
+                taskType: '$planoData.taskType',
+                type: '$planoData.type',
+                updatedAt: '$planoData.updatedAt',
+                _id: '$planoData._id',
+              },
+              '$$REMOVE',
+            ],
+          },
+        },
+        'comments': { $first: '$commentData' },
+      },
+    },
+  ];
+  let pipeline = [
+    ...matchStage,
+    taskLookup,
+    unwindTask,
+    commandLookup,
+    // unwindCommenTask,
+    ...commonLookups,
+    // ...vmStages,
+    ...finalGrouping,
+    { $sort: { _id: 1 } },
+  ];
+
+  return pipeline;
+}