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

package/src/controllers/fixtureTemplate.controller.js

@@ -0,0 +1,1767 @@
+import { logger, download } from 'tango-app-api-middleware';
+import * as fixtureConfigService from '../service/fixtureConfig.service.js';
+import * as fixtureLibService from '../service/planoLibrary.service.js';
+import * as storeFixtureService from '../service/storeFixture.service.js';
+import * as planoService from '../service/planogram.service.js';
+import * as storeService from '../service/store.service.js';
+import * as processedTaskService from '../service/processedTaskservice.js';
+import * as fixtureShelfService from '../service/fixtureShelf.service.js';
+import * as vmService from '../service/planoVm.service.js';
+import * as templateLogService from '../service/templateLog.service.js';
+import * as storeLayoutService from '../service/storeBuilder.service.js';
+import { createTask } from './task.controller.js';
+import mongoose from 'mongoose';
+import dayjs from 'dayjs';
+const ObjectId = mongoose.Types.ObjectId;
+import customParseFormat from 'dayjs/plugin/customParseFormat.js';
+dayjs.extend( customParseFormat );
+
+
+export async function createTemplate( req, res ) {
+  try {
+    let inputData = req.body;
+    const templateType =  inputData?.templateType ?? 'sub';
+    let getLibDetails = await fixtureLibService.findOne( { _id: inputData.fixtureLibraryId, clientId: inputData.clientId } );
+    if ( !getLibDetails ) {
+      return res.sendError( 'Fixture library id is wrong', 400 );
+    }
+    let templateId = await getTemplateId( getLibDetails.fixtureCategory, getLibDetails.fixtureWidth );
+    let templateData = {
+      clientId: inputData.clientId,
+      fixtureLibraryId: inputData.fixtureLibraryId,
+      fixtureName: `${templateId}-${getLibDetails.fixtureCategory}`,
+      fixtureCategory: getLibDetails.fixtureCategory,
+      fixtureType: getLibDetails.fixtureType,
+      fixtureHeight: getLibDetails.fixtureHeight,
+      fixtureLength: getLibDetails.fixtureLength,
+      fixtureWidth: getLibDetails.fixtureWidth,
+      shelfConfig: getLibDetails.shelfConfig,
+      header: getLibDetails.header,
+      footer: getLibDetails.footer,
+      isBodyEnabled: getLibDetails.isBodyEnabled,
+      fixtureCapacity: getLibDetails.fixtureCapacity,
+      fixtureStaticLength: {
+        value: 1524,
+        unit: 'mm',
+      },
+      fixtureStaticWidth: {
+        value: 1220,
+        unit: 'mm',
+      },
+      templateType: templateType,
+      templateIndex: parseInt( templateId.split( '-' )[1] ),
+    };
+    let fixtureData = await fixtureConfigService.create( templateData );
+    return res.sendSuccess( { message: 'Fixture template created successfully', fixtureData } );
+  } catch ( e ) {
+    logger.error( { functionName: 'createTemplate', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+
+async function getTemplateId( name, width ) {
+  let templateId = 'Template-1';
+  let fixtureTemplateData = await fixtureConfigService.sortAndFindOne( { 'fixtureCategory': name, 'fixtureWidth.unit': width.unit, 'fixtureWidth.value': width.value }, { templateIndex: 1 }, { _id: -1 } );
+  if ( fixtureTemplateData.length ) {
+    templateId = `Template-${fixtureTemplateData[0].templateIndex + 1}`;
+  }
+  return templateId;
+}
+
+export async function updateTemplate( req, res ) {
+  try {
+    let inputData = req.body;
+    let templateDetails = await fixtureConfigService.findOne( { _id: req.params.templateId } );
+    if ( !templateDetails ) {
+      return res.sendError( 'No data found', 204 );
+    }
+    let checkName = await fixtureConfigService.findOne( { _id: { $ne: req.params.templateId }, fixtureName: inputData.fixtureName } );
+    if ( checkName ) {
+      return res.sendError( 'Fixture name already exist', 400 );
+    }
+    let checkstoreMapped = await storeFixtureService.findOne( { fixtureConfigId: req.params.templateId } );
+    if ( checkstoreMapped ) {
+      inputData.isEdited = true;
+    } else {
+      inputData.isEdited = false;
+    }
+    await fixtureConfigService.updateOne( { _id: req.params.templateId }, inputData );
+    return res.sendSuccess( 'Fixture template details updated successfully' );
+  } catch ( e ) {
+    logger.error( { functionName: 'updateTemplate', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+
+export async function deleteTemplate( req, res ) {
+  try {
+    let templateDetails = await fixtureConfigService.findOne( { _id: req.body.templateId } );
+    if ( !templateDetails ) {
+      return res.sendError( 'No data found', 204 );
+    }
+    if ( templateDetails.templateType == 'master' ) {
+      return res.sendError( `Can't delete master template`, 400 );
+    }
+    let getFixtureDetails = await storeFixtureService.find( { fixtureConfigId: req.body.templateId }, { _id: 1, planoId: 1 } );
+    if ( getFixtureDetails.length ) {
+      let planoDetails = await planoService.find( { _id: getFixtureDetails.map( ( ele ) => ele.planoId ) } );
+      return res.sendError( `Fixture template is mapped with ${planoDetails.length}`, 400 );
+    }
+    await fixtureConfigService.deleteOne( { _id: req.body.templateId } );
+    return res.sendSuccess( 'Fixture template is deleted successfully' );
+  } catch ( e ) {
+    logger.error( { functionName: 'deleteTemplate', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+
+export async function duplicateTemplateOld( req, res ) {
+  try {
+    let templateDetails = await fixtureConfigService.findOne( { _id: req.body.templateId }, { createdAt: 0, updatedAt: 0 } );
+    if ( !templateDetails ) {
+      return res.sendError( 'No data found', 204 );
+    }
+    let getAllTemplate = await fixtureConfigService.findAndSort( { fixtureName: { $regex: templateDetails.fixtureName.replace( /[.*+?^${}()|[\]\\]/g, '\\$&' ), $options: 'i' } }, { fixtureName: 1 }, { fixtureName: -1 } );
+    let counter = 1;
+    let newFixtureName = templateDetails.fixtureName + ` (${counter})`;
+    if ( getAllTemplate?.length ) {
+      let fixtureNameList = getAllTemplate.map( ( ele ) => ele.fixtureName );
+      while ( fixtureNameList.includes( newFixtureName ) ) {
+        newFixtureName = templateDetails.fixtureName + ` (${counter})`;
+        counter++;
+      }
+    }
+    templateDetails = templateDetails.toObject();
+    delete templateDetails._id;
+    templateDetails.fixtureName = newFixtureName;
+    templateDetails.status = 'draft';
+    let duplicateDetails = await fixtureConfigService.create( templateDetails );
+    return res.sendSuccess( { message: 'Fixture template duplicated successfully', id: duplicateDetails._id } );
+  } catch ( e ) {
+    logger.error( { functionName: 'duplicateFixture', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+
+export async function getTemplateDetails( req, res ) {
+  try {
+    let templateDetails = await fixtureConfigService.findOne( { _id: req.query.templateId } );
+    if ( !templateDetails ) {
+      return res.sendError( 'No data found', 204 );
+    }
+    templateDetails = templateDetails.toObject();
+    templateDetails.vmConfig = await Promise.all( templateDetails.vmConfig.map( async ( vm ) => {
+      let vmDetails = await vmService.findOne( { _id: vm.vmId } );
+      if ( vmDetails ) {
+        vm = { ...vm, ...vmDetails.toObject() };
+        return vm;
+      }
+    } ) );
+    templateDetails.status = templateDetails.status == 'draft' ? 'draft' : 'inactive';
+    let storeFixtureDetails = await storeFixtureService.find( { fixtureConfigId: req.query.templateId } );
+    if ( storeFixtureDetails.length ) {
+      let fixtureId = storeFixtureDetails.map( ( ele ) => ele.planoId );
+      let planoDetails = await planoService.find( { _id: { $in: fixtureId } }, { status: 1 } );
+      planoDetails = planoDetails.map( ( ele ) => ele.status );
+      templateDetails.status = planoDetails.includes( 'completed' ) ? 'active' : templateDetails.status;
+    }
+    let data = {
+      ...templateDetails,
+    };
+    if ( templateDetails.templateType == 'master' ) {
+      let variantCount = await fixtureConfigService.count( { masterTemplateId: templateDetails._id } );
+      data = { ...data, variantCount };
+    } else {
+      let query = [
+        {
+          $match: {
+            fixtureConfigId: new ObjectId( req.query.templateId ),
+          },
+        },
+        {
+          $group: {
+            _id: '',
+            storeId: { $addToSet: '$storeId' },
+          },
+        },
+        {
+          $project: {
+            storeCount: { $size: '$storeId' },
+          },
+        },
+      ];
+
+      let templateStoreList = await storeFixtureService.aggregate( query );
+      data = { ...data, storeCount: templateStoreList?.[0]?.storeCount || 0 };
+    }
+
+    return res.sendSuccess( data );
+  } catch ( e ) {
+    logger.error( { functionName: 'getTemplateDetails', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+
+export async function getTemplateList( req, res ) {
+  try {
+    let limit = req.body?.limit || 10;
+    let page = req.body?.offset || 1;
+    let skip = limit * ( page - 1 );
+
+    const matchStage = {
+      clientId: req.body.clientId,
+      ...( req.body?.searchValue ?
+        { fixtureName: { $regex: req.body.searchValue, $options: 'i' } } :
+        {} ),
+      ...( req.body?.filter?.brand?.length ?
+        {
+          $or: [
+            { 'productBrandName': { $in: req.body.filter.brand } },
+            { 'shelfConfig.productBrandName': { $in: req.body.filter.brand } },
+          ],
+        } :
+        {} ),
+      ...( req.body?.filter?.category?.length ?
+        { fixtureCategory: { $in: req.body.filter.category } } :
+        {} ),
+      ...( req.body?.filter?.subCategory?.length ?
+        { productSubCategory: { $in: req.body.subCategory.category } } :
+        {} ),
+    };
+
+    const query = [
+      { $match: matchStage },
+      {
+        $lookup: {
+          from: 'storefixtures',
+          let: { templateId: '$_id' },
+          pipeline: [
+            {
+              $match: {
+                $expr: {
+                  $eq: [ '$$templateId', '$fixtureConfigId' ],
+                },
+              },
+            },
+            {
+              $group: {
+                _id: null,
+                planoId: { $addToSet: '$planoId' },
+                storeList: { $addToSet: '$storeName' },
+              },
+            },
+            {
+              $project: {
+                _id: 0,
+                planoId: 1,
+                storeList: 1,
+              },
+            },
+          ],
+          as: 'storeFixtureDetails',
+        },
+      },
+      {
+        $project: {
+          fixtureCategory: 1,
+          fixtureName: 1,
+          fixtureWidth: 1,
+          productBrandName: 1,
+          productCategory: 1,
+          shelfProduct: {
+            $reduce: {
+              input: '$shelfConfig',
+              initialValue: [],
+              in: {
+                $concatArrays: [
+                  '$$value',
+                  { $ifNull: [ '$$this.productBrandName', [] ] },
+                ],
+              },
+            },
+          },
+          shelfProductCategory: {
+            $reduce: {
+              input: '$shelfConfig',
+              initialValue: [],
+              in: {
+                $concatArrays: [
+                  '$$value',
+                  { $ifNull: [ '$$this.productCategory', [] ] },
+                ],
+              },
+            },
+          },
+          shelfProductSubCategory: {
+            $reduce: {
+              input: '$shelfConfig',
+              initialValue: [],
+              in: {
+                $concatArrays: [
+                  '$$value',
+                  { $ifNull: [ '$$this.productSubCategory', [] ] },
+                ],
+              },
+            },
+          },
+          clientId: 1,
+          productSubCategory: 1,
+          status: 1,
+          fixtureType: 1,
+          vmCapacity: { $size: '$vmConfig' },
+          productCapacity: {
+            $sum: {
+              $map: {
+                input: '$shelfConfig',
+                as: 'shelf',
+                in: '$$shelf.productPerShelf',
+              },
+            },
+          },
+          planoId: { $ifNull: [ { $arrayElemAt: [ '$storeFixtureDetails.planoId', 0 ] }, [] ] },
+          storeList: { $ifNull: [ { $arrayElemAt: [ '$storeFixtureDetails.storeList', 0 ] }, [] ] },
+        },
+      },
+      {
+        $lookup: {
+          from: 'planograms',
+          let: { planoIds: '$planoId' },
+          pipeline: [
+            {
+              $match: {
+                $expr: {
+                  $in: [ '$_id', { $ifNull: [ '$$planoIds', [] ] } ],
+                },
+              },
+            },
+            {
+              $group: {
+                _id: null,
+                statusList: { $addToSet: '$status' },
+              },
+            },
+          ],
+          as: 'planoStatus',
+        },
+      },
+      {
+        $project: {
+          fixtureCategory: 1,
+          fixtureName: 1,
+          fixtureWidth: 1,
+          productBrandName: { $concatArrays: [ '$productBrandName', '$shelfProduct' ] },
+          productCategory: { $concatArrays: [ '$productCategory', '$shelfProductCategory' ] },
+          clientId: 1,
+          fixtureType: 1,
+          productSubCategory: { $concatArrays: [ '$productSubCategory', '$shelfProductSubCategory' ] },
+          status: 1,
+          templateId: 1,
+          planoId: 1,
+          vmCapacity: 1,
+          productCapacity: 1,
+          storeList: 1,
+          storeCount: { $size: '$storeList' },
+          planoStatus: { $ifNull: [ { $arrayElemAt: [ '$planoStatus.statusList', 0 ] }, [] ] },
+          status: {
+            $cond: {
+              if: { $in: [ 'completed', { $ifNull: [ { $arrayElemAt: [ '$planoStatus.statusList', 0 ] }, [] ] } ] },
+              then: 'active',
+              else: {
+                $cond: {
+                  if: {
+                    $eq: [
+                      '$status', 'draft',
+                    ],
+                  },
+                  then: 'draft',
+                  else: 'inactive',
+                },
+              },
+            },
+          },
+        },
+      },
+    ];
+
+    if ( req.body.filter.status.length ) {
+      query.push( {
+        $match: {
+          status: { $in: req.body.filter.status },
+        },
+      } );
+    }
+
+    if ( req.body?.sortColumnName && req.body?.sortBy ) {
+      query.push( {
+        $sort: {
+          [req.body.sortColumnName]: req.body.sortBy,
+        },
+      },
+      );
+    } else {
+      query.push( {
+        $sort: { _id: -1 },
+      } );
+    }
+
+    query.push(
+        {
+          $facet: {
+            templateData: [ { $skip: skip }, { $limit: limit } ],
+            count: [ { $count: 'total' } ],
+          },
+        },
+    );
+    let fixtureDetails = await fixtureConfigService.aggregate( query );
+    if ( !fixtureDetails[0]?.templateData.length ) {
+      return res.sendError( 'No data found', 204 );
+    }
+    if ( req.body.export ) {
+      let exportData = [];
+      fixtureDetails[0]?.templateData.forEach( ( ele ) => {
+        ele.productBrandName = [ ...new Set( ele.productBrandName.map( ( product ) => product ) ) ];
+        ele.productCategory = [ ...new Set( ele.productCategory.map( ( product ) => product ) ) ];
+        ele.productSubCategory = [ ...new Set( ele.productSubCategory.map( ( product ) => product ) ) ];
+        exportData.push( {
+          'Fixture Category': ele.fixtureCategory,
+          'Fixture Name': ele.fixtureName,
+          'Fixture Type': ele.fixtureType,
+          'Fixture Width': ele.fixtureWidth.value + ' ' +ele.fixtureWidth.unit,
+          'Product BrandName': ele.productBrandName?.toString(),
+          'Product Capacity': ele?.productCapacity,
+          'Product Category': ele?.productCategory?.toString(),
+          'Product SubCategory': ele?.productSubCategory?.toString(),
+          'Status': ele.status,
+          'Store Count': ele.storeCount,
+          'VM Capacity': ele.vmCapacity,
+        } );
+      } );
+      return download( exportData, res );
+    }
+
+    let result = {
+      count: fixtureDetails[0].count[0].total,
+      data: fixtureDetails[0].templateData,
+    };
+
+    result.data.forEach( ( ele ) => {
+      ele.productBrandName = [ ...new Set( ele.productBrandName.map( ( product ) => product ) ) ];
+      ele.productCategory = [ ...new Set( ele.productCategory.map( ( product ) => product ) ) ];
+      ele.productSubCategory = [ ...new Set( ele.productSubCategory.map( ( product ) => product ) ) ];
+    } );
+    return res.sendSuccess( result );
+  } catch ( e ) {
+    console.log( e );
+    logger.error( { functionName: 'getTemplateList', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+
+export async function updateFixtureTask( req, res ) {
+  try {
+    let storeList = req.body.storeList.map( ( ele ) => ele.toLowerCase() );
+    let query = [
+      {
+        $addFields: {
+          storeLower: { $toLower: '$storeName' },
+        },
+      },
+      {
+        $match: {
+          clientId: req.body.clientId,
+          status: 'active',
+          storeLower: { $in: storeList },
+        },
+      },
+    ];
+    let storeDetails = await storeService.aggregate( query );
+    if ( !storeDetails.length ) {
+      return res.sendError( 'No date found', 204 );
+    }
+    storeList = storeDetails.map( ( ele ) => {
+      return { store: ele.storeName, email: ele?.spocDetails?.[0]?.email };
+    } );
+    let fixtureTaskStore = [];
+    let layoutTaskStore = [];
+    await Promise.all( storeList.map( async ( ele ) => {
+      let getTaskDetails = await processedTaskService.findOne( { storeName: ele.store, userEmail: ele.email, isPlano: true, date_iso: new Date( dayjs().format( 'YYYY-MM-DD' ) ), type: 'layout' } );
+      if ( getTaskDetails && getTaskDetails.planoType == 'layout' && getTaskDetails.checklistStatus == 'submit' ) {
+        fixtureTaskStore.push( ele );
+      } else {
+        layoutTaskStore.push( ele );
+      }
+    } ) );
+    let currDate = dayjs();
+    let endDate = dayjs( req.body.endDate, 'YYYY-MM-DD' );
+    let todayDate = currDate.format( 'YYYY-MM-DD' ) == endDate.format( 'YYYY-MM-DD' );
+    let data = [
+      'Fixture Verification',
+      'Layout Verification',
+    ];
+    await Promise.all( data.map( async ( ele ) => {
+      req.body = {
+        clientId: req.body.clientId,
+        stores: ele.includes( 'Fixture' ) ? fixtureTaskStore : layoutTaskStore,
+        days: todayDate ? 1 : endDate.diff( currDate, 'day' ) + 2,
+        checkListName: ele,
+        geoFencing: req.body.geoFencing,
+        endTime: req.body.endTime,
+      };
+      if ( req.body.stores.length ) {
+        await createTask( req, res );
+      }
+    } ) );
+  } catch ( e ) {
+    logger.error( { functionName: 'updateFixtureTask', error: e } );
+  }
+}
+
+export async function getAllTemplates( req, res ) {
+  try {
+    if ( !req.body.clientId ) {
+      return res.sendError( 'Client Id is required', 400 );
+    }
+
+    const query = [
+      {
+        $match: {
+          clientId: req.body.clientId,
+          templateType: 'sub',
+        },
+      },
+      {
+        $project: {
+          'fixtureName': 1,
+          'fixtureWidth': 1,
+          'productBrandName': {
+            $cond: {
+              if: { $eq: [ '$productResolutionLevel', 'L1' ] },
+              then: '$productBrandName',
+              else: {
+                $reduce: {
+                  input: {
+                    $map: {
+                      input: '$shelfConfig',
+                      as: 'shelf',
+                      in: '$$shelf.productBrandName',
+                    },
+                  },
+                  initialValue: [],
+                  in: {
+                    $setUnion: [ '$$value', '$$this' ],
+                  },
+                },
+              },
+            },
+          },
+        },
+      },
+    ];
+
+    const fixtureTemplates = await fixtureConfigService.aggregate( query );
+
+    res.sendSuccess( fixtureTemplates );
+  } catch ( e ) {
+    logger.error( { functionName: 'getAllTemplates', error: e } );
+  }
+}
+
+export async function getFixtureTemplate( req, res ) {
+  try {
+    let fixtureTemplate = await fixtureConfigService.findOne( { _id: new mongoose.Types.ObjectId( req.query.templateId ) } );
+
+    if ( !fixtureTemplate ) {
+      return res.sendError( 'No data found', 204 );
+    }
+
+    const templateDoc = fixtureTemplate.toObject();
+
+
+    if ( templateDoc?.vmConfig?.length ) {
+      templateDoc.vmConfig = await Promise.all( templateDoc.vmConfig.map( async ( vm ) => {
+        let vmDetails = await vmService.findOne( { _id: vm.vmId } );
+        if ( vmDetails ) {
+          vm = { ...vm, ...vmDetails.toObject() };
+          return vm;
+        }
+      } ) );
+    }
+
+
+    res.sendSuccess( templateDoc );
+  } catch ( e ) {
+    logger.error( { functionName: 'getFixtureTemplate', error: e } );
+  }
+}
+
+
+export async function assigedTemplate( req, res ) {
+  try {
+    let findFixtureList = await fixtureConfigService.aggregate( [
+      {
+        $match: {
+          templateType: 'sub',
+        },
+      },
+      {
+        $project: {
+          fixtureCategory: 1,
+          fixtureName: 1,
+          fixtureWidth: 1,
+          productBrandName: 1,
+          productCategory: 1,
+        },
+      },
+      {
+        $lookup: {
+          from: 'storefixtures',
+          let: { fixtureConfigId: '$_id' },
+          pipeline: [
+            { $match: { $expr: { $eq: [ '$fixtureConfigId', '$$fixtureConfigId' ] } } },
+            {
+              $project: {
+                storeId: 1,
+              },
+            },
+          ],
+          as: 'storeCount',
+        },
+      },
+      {
+        $unwind: {
+          path: '$storeCount',
+          preserveNullAndEmptyArrays: true,
+        },
+      },
+      {
+        $group: {
+          _id: '$_id',
+          fixtureCategory: { $first: '$fixtureCategory' },
+          fixtureName: { $first: '$fixtureName' },
+          fixtureWidth: { $first: '$fixtureWidth' },
+          productBrandName: { $first: '$productBrandName' },
+          productCategory: { $first: '$productCategory' },
+          storeCount: { $addToSet: '$storeCount.storeId' },
+        },
+      },
+      {
+        $project: {
+          fixtureCategory: 1,
+          fixtureName: 1,
+          fixtureWidth: 1,
+          productBrandName: 1,
+          productCategory: 1,
+          storeCount: { $size: '$storeCount' },
+        },
+      },
+
+    ] );
+    res.sendSuccess( findFixtureList );
+  } catch ( e ) {
+    logger.error( { functionName: 'assigedTemplate', error: e } );
+  }
+}
+
+
+export async function TemplateStoresList( req, res ) {
+  try {
+    let query = [];
+    let inputData = req.body;
+    let limit = inputData?.limit || 10;
+    let page = inputData?.offset || 1;
+    let skip = limit * ( page - 1 );
+
+    query.push( {
+      $match: {
+        clientId: inputData.clientId,
+        fixtureConfigId: new mongoose.Types.ObjectId( inputData.fixtureConfigId ),
+      },
+    },
+    {
+      $sort: {
+        _id: -1,
+      },
+    },
+    {
+      $project: {
+        storeId: 1,
+        storeName: 1,
+        planoId: 1,
+        floorId: 1,
+      },
+    },
+    {
+      $group: {
+        _id: { store: '$storeId', floor: '$floorId' },
+        storeName: { $first: '$storeName' },
+        planoId: { $first: '$planoId' },
+        storeId: { $first: '$storeId' },
+        floorId: { $first: '$floorId' },
+      },
+    },
+    {
+      $lookup: {
+        from: 'storelayouts',
+        let: { floor: '$floorId' },
+        pipeline: [
+          {
+            $match: {
+              $expr: {
+                $eq: [ '$_id', '$$floor' ],
+              },
+            },
+          },
+          {
+            $project: {
+              floorName: 1,
+            },
+          },
+        ],
+        as: 'floorDetails',
+      },
+    },
+    {
+      $unwind: {
+        path: '$floorDetails',
+        preserveNullAndEmptyArrays: true,
+      },
+    },
+
+    );
+    if ( inputData.showlookup ) {
+      query.push(
+          {
+            $lookup: {
+              from: 'stores',
+              let: { storeId: '$storeId' },
+              pipeline: [
+                { $match: { $expr: { $eq: [ '$storeId', '$$storeId' ] } } },
+                {
+                  $project: {
+                    spocDetails: { $arrayElemAt: [ '$spocDetails', 0 ] },
+                  },
+                },
+              ],
+              as: 'storeData',
+            },
+          },
+          { $unwind: { path: '$storeData', preserveNullAndEmptyArrays: true } },
+          {
+            $project: {
+              storeId: 1,
+              storeName: 1,
+              planoId: 1,
+              floorId: 1,
+              spocName: { $ifNull: [ '$storeData.spocDetails.name', '' ] },
+              spocEmail: { $ifNull: [ '$storeData.spocDetails.email', '' ] },
+              floorDetails: 1,
+              _id: '$_id.store',
+            },
+          },
+      );
+    }
+
+    if ( inputData.sortColumnName && inputData.sortBy ) {
+      query.push( { $sort: { [inputData.sortColumnName]: inputData.sortBy } } );
+    }
+    if ( inputData.searchValue ) {
+      query.push( {
+        $match: {
+          storeName: { $regex: inputData.searchValue, $options: 'i' },
+        },
+      } );
+    }
+    let count = await storeFixtureService.aggregate( query );
+    if ( !inputData?.export ) {
+      query.push( { $skip: skip }, { $limit: limit } );
+    }
+    if ( inputData.showlookup ) {
+      query.push( {
+        $lookup: {
+          from: 'clusters',
+          let: { storeId: '$storeId' },
+          pipeline: [
+            {
+              $match: {
+                $expr: {
+                  $anyElementTrue: {
+                    $map: {
+                      input: '$stores',
+                      as: 'store',
+                      in: { $eq: [ '$$store.storeId', '$$storeId' ] },
+                    },
+                  },
+                },
+              },
+            },
+            {
+              $project: {
+                clusterName: 1,
+              },
+            },
+          ],
+          as: 'clusterData',
+        },
+      }, {
+        $addFields: {
+          clusterData: {
+            $map: {
+              input: '$clusterData',
+              as: 'cd',
+              in: '$$cd.clusterName',
+            },
+          },
+        },
+      },
+      );
+    }
+
+    let floorQuery = [
+      {
+        $match: {
+          clientId: req.body.clientId,
+        },
+      },
+      {
+        $group: {
+          _id: '$storeId',
+          count: { $sum: 1 },
+        },
+      },
+      {
+        $match: {
+          count: { $gt: 1 },
+        },
+      },
+      {
+        $project: {
+          _id: 0,
+          store: '$_id',
+        },
+      },
+    ];
+    const [ response, floorDetails ] = await Promise.all( [
+      storeFixtureService.aggregate( query ),
+      storeLayoutService.aggregate( floorQuery ),
+    ] );
+
+    if ( !req.body.export && !response.length ) {
+      return res.sendError( 'No data found', 204 );
+    }
+    let result = {
+      count: count.length || 0,
+      data: response || [],
+      doubleStore: floorDetails?.map( ( ele ) => ele.store ) ?? [],
+    };
+    if ( !req.body.export ) {
+      return res.sendSuccess( result );
+    }
+  } catch ( e ) {
+    logger.error( { functionName: 'TemplateStoresList', error: e } );
+    res.sendError( e, 500 );
+  }
+}
+
+
+export async function replaceFixtureDetails( req, res ) {
+  try {
+    let inputData = req.body;
+    let replaceFixtureData = await fixtureConfigService.findOne( { _id: inputData.replaceFixture } );
+
+    if ( !replaceFixtureData ) {
+      return res.sendError( 'No data found', 204 );
+    }
+    if ( inputData.storeList.length == 0 && inputData.publishAll ) {
+      await fixtureConfigService.updateOne( { _id: inputData.replaceFixture }, { isEdited: false } );
+      let query = [
+        {
+          $match: {
+            fixtureConfigId: new ObjectId( inputData.findFixture ),
+          },
+        },
+        {
+          $group: {
+            _id: '$storeId',
+            floorDetails: {
+              $first: {
+                _id: '$floorId',
+              },
+            },
+          },
+        },
+        {
+          $project: {
+            storeId: '$_id',
+            floorDetails: 1,
+            _id: 0,
+          },
+        },
+      ];
+
+      // inputData.storeList = await storeFixtureService.find( { fixtureConfigId: inputData.findFixture }, { storeId: 1 } );
+      inputData.storeList = await storeFixtureService.aggregate( query );
+      let data = {
+        templateId: inputData.replaceFixture,
+        data: replaceFixtureData,
+      };
+      await templateLogService.create( data );
+    }
+    if ( inputData.storeList.length ) {
+      // let storeList = inputData.storeList.map( ( ele ) => ele.storeId );
+      // let getDetails = await storeFixtureService.find( { storeId: { $in: storeList }, fixtureConfigId: inputData.findFixture, $or: [ { isMerchEdited: true }, { isVmEdited: true } ] }, { storeId: 1 } );
+      // if ( getDetails.length ) {
+      //   await Promise.all( getDetails.map( async ( ele ) => {
+      //     let taskDetails = await processedTaskService.findOne( { store_id: ele.storeId, isPlano: true, planoType: [ 'merchRollout', 'vmRollout' ] }, {}, { _id: -1 } );
+      //     if ( taskDetails ) {
+      //       await processedTaskService.deleteOne( { _id: taskDetails._id } );
+      //     }
+      //   } ) );
+      // }
+      const updateData = {
+        ...replaceFixtureData.toObject(),
+        fixtureConfigId: replaceFixtureData._id,
+      };
+      delete updateData._id;
+
+      await Promise.all(
+          inputData.storeList.map( async ( store ) => {
+            const replaceFixture = await storeFixtureService.find( {
+              fixtureConfigId: inputData.findFixture,
+              ...( store?.floorDetails?._id ) ? { floorId: store?.floorDetails?._id } : {},
+              storeId: store.storeId,
+            } );
+
+
+            if ( !replaceFixture.length ) return;
+
+            const deleteFixShelves = await fixtureShelfService.deleteMany( {
+              fixtureId: { $in: replaceFixture.map( ( ele ) => ele._id ) },
+            } );
+            await storeFixtureService.updateMany(
+                { fixtureConfigId: inputData.findFixture, ...( store?.floorDetails?._id ) ? { floorId: store?.floorDetails?._id } : {}, storeId: store.storeId },
+                updateData,
+            );
+
+            if ( replaceFixtureData.shelfConfig?.length ) {
+              replaceFixtureData.shelfConfig.forEach( async ( shelf ) => {
+                let shelfData = [];
+                shelf = { ...shelf.toObject() };
+                delete shelf._id;
+                replaceFixture.forEach( async ( data ) => {
+                  shelfData.push( {
+                    ...shelf,
+                    floorId: data.floorId,
+                    planoId: data.planoId,
+                    clientId: data.clientId,
+                    fixtureId: data._id,
+                    storeId: data.storeId,
+                    storeName: data.storeName,
+                  } );
+                } );
+                try {
+                  await fixtureShelfService.insertMany( shelfData );
+                } catch ( err ) {
+                  console.error( 'Insert failed:', err );
+                }
+              } );
+              // const shelfList = replaceFixtureData.shelfConfig.map( ( shelf ) => {
+              //   const shelfData = {
+              //     ...shelf.toObject(),
+              //     floorId: replaceFixture.floorId,
+              //     planoId: replaceFixture.planoId,
+              //     clientId: replaceFixture.clientId,
+              //     // fixtureId: replaceFixture._id,
+              //     storeId: replaceFixture.storeId,
+              //     storeName: replaceFixture.storeName,
+              //   };
+
+              //   delete shelfData._id;
+              //   return shelfData;
+              // } );
+
+              // try {
+              //   await fixtureShelfService.insertMany( shelfList );
+              // } catch ( err ) {
+              //   console.error( 'Insert failed:', err );
+              // }
+            }
+          } ),
+      );
+    } else {
+      return res.sendError( 'Store Not found', 500 );
+    }
+    res.sendSuccess( 'updatedSucessfully' );
+  } catch ( e ) {
+    logger.error( { functionName: 'replaceFixtureDetails', error: e } );
+    res.sendError( e, 500 );
+  }
+}
+
+export async function getMasterList( req, res ) {
+  try {
+    let limit = req.body?.limit || 10;
+    let page = req.body?.offset || 1;
+    let skip = limit * ( page - 1 );
+
+    let searchMasterList = [];
+
+    if ( req.body?.searchValue ) {
+      let searchQuery = [
+        {
+          $match: {
+            clientId: req.body.clientId,
+            templateType: 'sub',
+            fixtureName: { $regex: req.body.searchValue, $options: 'i' },
+          },
+        },
+        {
+          $group: {
+            _id: '$masterTemplateId',
+          },
+        },
+      ];
+
+      let subTemplateDetails = await fixtureConfigService.aggregate( searchQuery );
+      if ( subTemplateDetails.length ) {
+        searchMasterList = subTemplateDetails.map( ( ele ) => ele._id );
+      }
+    }
+
+    const matchStage = {
+      clientId: req.body.clientId,
+      templateType: 'master',
+      ...( req.body?.searchValue ?
+        { $or: [ { fixtureName: { $regex: req.body.searchValue, $options: 'i' } }, { _id: { $in: searchMasterList } } ] } :
+        {} ),
+      ...( req.body?.filter?.brand?.length ?
+        {
+          $or: [
+            { 'productBrandName': { $in: req.body.filter.brand } },
+            { 'shelfConfig.productBrandName': { $in: req.body.filter.brand } },
+          ],
+        } :
+        {} ),
+      ...( req.body?.filter?.category?.length ?
+        { fixtureCate: { $in: req.body.filter.category } } :
+        {} ),
+      ...( req.body?.filter?.subCategory?.length ?
+        { productSubCategory: { $in: req.body.subCategory.category } } :
+        {} ),
+    };
+
+    const query = [
+      {
+        $addFields: {
+          fixtureCate: {
+            $concat: [
+              '$fixtureCategory',
+              ' - ',
+              { $toString: '$fixtureWidth.value' },
+              '$fixtureWidth.unit',
+            ],
+          },
+        },
+      },
+      { $match: matchStage },
+      {
+        $lookup: {
+          from: 'fixtureconfigs',
+          let: { mainId: '$_id' },
+          pipeline: [
+            {
+              $match: {
+                $expr: {
+                  $eq: [ '$masterTemplateId', '$$mainId' ],
+                },
+              },
+            },
+            {
+              $group: {
+                _id: '$masterTemplateId',
+                count: { $sum: 1 },
+              },
+            },
+          ],
+          as: 'childtemplate',
+        },
+      },
+      { $unwind: { path: '$childtemplate', preserveNullAndEmptyArrays: true } },
+      {
+        $project: {
+          fixtureCategory: 1,
+          fixtureCate: 1,
+          fixtureName: 1,
+          fixtureWidth: 1,
+          clientId: 1,
+          fixtureType: 1,
+          childCount: { $ifNull: [ '$childtemplate.count', 0 ] },
+          productBrandName: {
+            $setUnion: [
+              { $ifNull: [ '$productBrandName', [] ] },
+              {
+                $reduce: {
+                  input: '$shelfConfig',
+                  initialValue: [],
+                  in: {
+                    $concatArrays: [
+                      '$$value',
+                      { $ifNull: [ '$$this.productBrandName', [] ] },
+                    ],
+                  },
+                },
+              },
+            ],
+          },
+          productCategory: {
+            $setUnion: [
+              { $ifNull: [ '$productCategory', [] ] },
+              {
+                $reduce: {
+                  input: '$shelfConfig',
+                  initialValue: [],
+                  in: {
+                    $concatArrays: [
+                      '$$value',
+                      { $ifNull: [ '$$this.productCategory', [] ] },
+                    ],
+                  },
+                },
+              },
+            ],
+          },
+          productSubCategory: {
+            $setUnion: [
+              { $ifNull: [ '$productSubCategory', [] ] },
+              {
+                $reduce: {
+                  input: '$shelfConfig',
+                  initialValue: [],
+                  in: {
+                    $concatArrays: [
+                      '$$value',
+                      { $ifNull: [ '$$this.productSubCategory', [] ] },
+                    ],
+                  },
+                },
+              },
+            ],
+          },
+        },
+      },
+
+    ];
+
+    if ( req.body.filter.status.length ) {
+      query.push( {
+        $match: {
+          status: { $in: req.body.filter.status },
+        },
+      } );
+    }
+
+    if ( req.body?.sortColumnName && req.body?.sortBy ) {
+      query.push( {
+        $sort: {
+          [req.body.sortColumnName]: req.body.sortBy,
+        },
+      },
+      );
+    } else {
+      query.push( {
+        $sort: { _id: -1 },
+      } );
+    }
+    query.push(
+        {
+          $facet: {
+            ...( !req.body?.export ) ? {
+              templateData: [ { $skip: skip }, { $limit: limit } ],
+            } : { templateData: [ { $skip: skip } ] },
+            count: [ { $count: 'total' } ],
+          },
+        },
+    );
+    let fixtureDetails = await fixtureConfigService.aggregate( query );
+
+
+    if ( !fixtureDetails[0]?.templateData.length ) {
+      return res.sendError( 'No data found', 204 );
+    }
+    let result = {
+      count: fixtureDetails[0].count[0].total,
+      data: fixtureDetails[0].templateData,
+    };
+
+    return res.sendSuccess( result );
+  } catch ( e ) {
+    logger.error( { functionName: 'getMasterList', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+
+export async function getChildList( req, res ) {
+  try {
+    let limit = req.body?.limit || 10;
+    let page = req.body?.offset || 1;
+    let skip = limit * ( page - 1 );
+
+    const matchStage = {
+      clientId: req.body.clientId,
+      templateType: 'sub',
+      masterTemplateId: new ObjectId( req.body.masterTemplateId ),
+      ...( req.body?.searchValue ?
+      { fixtureName: { $regex: req.body.searchValue, $options: 'i' } } :
+      {} ),
+    };
+
+    const query = [
+      { $match: matchStage },
+      {
+        $lookup: {
+          from: 'storefixtures',
+          let: { templateId: '$_id' },
+          pipeline: [
+            {
+              $match: {
+                $expr: {
+                  $eq: [ '$$templateId', '$fixtureConfigId' ],
+                },
+              },
+            },
+            {
+              $group: {
+                _id: null,
+                planoId: { $addToSet: '$planoId' },
+                storeList: { $addToSet: '$storeName' },
+              },
+            },
+            {
+              $project: {
+                _id: 0,
+                planoId: 1,
+                storeList: 1,
+              },
+            },
+          ],
+          as: 'storeFixtureDetails',
+        },
+      },
+      {
+        $project: {
+          fixtureCategory: 1,
+          fixtureName: 1,
+          fixtureWidth: 1,
+          productBrandName: {
+            $setUnion: [
+              { $ifNull: [ '$productBrandName', [] ] },
+              {
+                $reduce: {
+                  input: '$shelfConfig',
+                  initialValue: [],
+                  in: {
+                    $concatArrays: [
+                      '$$value',
+                      { $ifNull: [ '$$this.productBrandName', [] ] },
+                    ],
+                  },
+                },
+              },
+            ],
+          },
+          productCategory: {
+            $setUnion: [
+              { $ifNull: [ '$productCategory', [] ] },
+              {
+                $reduce: {
+                  input: '$shelfConfig',
+                  initialValue: [],
+                  in: {
+                    $concatArrays: [
+                      '$$value',
+                      { $ifNull: [ '$$this.productCategory', [] ] },
+                    ],
+                  },
+                },
+              },
+            ],
+          },
+          productSubCategory: {
+            $setUnion: [
+              { $ifNull: [ '$productSubCategory', [] ] },
+              {
+                $reduce: {
+                  input: '$shelfConfig',
+                  initialValue: [],
+                  in: {
+                    $concatArrays: [
+                      '$$value',
+                      { $ifNull: [ '$$this.productSubCategory', [] ] },
+                    ],
+                  },
+                },
+              },
+            ],
+          },
+          clientId: 1,
+          status: 1,
+          fixtureType: 1,
+          planoId: { $ifNull: [ { $arrayElemAt: [ '$storeFixtureDetails.planoId', 0 ] }, [] ] },
+          storeList: { $ifNull: [ { $arrayElemAt: [ '$storeFixtureDetails.storeList', 0 ] }, [] ] },
+          updatedAt: 1,
+        },
+      },
+      {
+        $lookup: {
+          from: 'planograms',
+          let: { planoIds: '$planoId' },
+          pipeline: [
+            {
+              $match: {
+                $expr: {
+                  $in: [ '$_id', { $ifNull: [ '$$planoIds', [] ] } ],
+                },
+              },
+            },
+            {
+              $group: {
+                _id: null,
+                statusList: { $addToSet: '$status' },
+              },
+            },
+          ],
+          as: 'planoStatus',
+        },
+      },
+      {
+        $project: {
+          fixtureCategory: 1,
+          fixtureName: 1,
+          fixtureWidth: 1,
+          productBrandName: 1,
+          productCategory: 1,
+          clientId: 1,
+          fixtureType: 1,
+          productSubCategory: 1,
+          status: 1,
+          templateId: 1,
+          planoId: 1,
+          vmCapacity: 1,
+          productCapacity: 1,
+          storeList: 1,
+          storeCount: { $size: '$storeList' },
+          planoStatus: { $ifNull: [ { $arrayElemAt: [ '$planoStatus.statusList', 0 ] }, [] ] },
+          status: {
+            $cond: {
+              if: { $in: [ 'completed', { $ifNull: [ { $arrayElemAt: [ '$planoStatus.statusList', 0 ] }, [] ] } ] },
+              then: 'active',
+              else: {
+                $cond: {
+                  if: {
+                    $eq: [
+                      '$status', 'draft',
+                    ],
+                  },
+                  then: 'draft',
+                  else: 'inactive',
+                },
+              },
+            },
+          },
+          updatedAt: 1,
+        },
+      },
+    ];
+
+    if ( req.body.searchValue ) {
+      query.push( {
+        $match: {
+          fixtureName: { $regex: req.body.searchValue, $options: 'i' },
+        },
+      } );
+    }
+
+    if ( req.body?.sortColumnName && req.body?.sortBy ) {
+      query.push( {
+        $sort: {
+          [req.body.sortColumnName]: req.body.sortBy,
+        },
+      },
+      );
+    } else {
+      query.push( {
+        $sort: { _id: -1 },
+      } );
+    }
+    query.push(
+        {
+          $facet: {
+            templateData: [ { $skip: skip }, { $limit: limit } ],
+            count: [ { $count: 'total' } ],
+          },
+        },
+    );
+    let fixtureDetails = await fixtureConfigService.aggregate( query );
+    if ( !fixtureDetails[0]?.templateData.length ) {
+      return res.sendError( 'No data found', 204 );
+    }
+    let result = {
+      count: fixtureDetails[0].count[0].total,
+      data: fixtureDetails[0].templateData,
+    };
+    return res.sendSuccess( result );
+  } catch ( e ) {
+    logger.error( { functionName: 'getChildList', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+
+export async function getTreeListOld( req, res ) {
+  try {
+    let query = [
+      {
+        $match: {
+          clientId: req.query.clientId,
+          templateType: 'master',
+          ...( req.query.masterId && { masterTemplateId: req.query.masterId } ),
+        },
+      },
+      {
+        $group: {
+          _id: '$templateGroupName',
+        },
+      },
+      {
+        $project: {
+          _id: 0,
+          group: '$_id',
+        },
+      },
+    ];
+    let getGroupDetails = await fixtureConfigService.aggregate( query );
+    if ( !getGroupDetails.length ) {
+      return res.sendError( 'No data found', 204 );
+    }
+    let treeList = await Promise.all( getGroupDetails.map( async ( ele ) => {
+      let groupDetails = await fixtureConfigService.find( { templateGroupName: ele.group, templateType: 'master' } );
+      let masterDetails = await Promise.all( groupDetails.map( async ( group ) => {
+        let templateDetails = await fixtureConfigService.find( { masterTemplateId: group._id } );
+        let templateList = await Promise.all( templateDetails.map( async ( temp ) => {
+          let storeFixtureCount = await storeFixtureService.count( { fixtureConfigId: ele._id } );
+          return { ...temp.toObject(), storeCount: storeFixtureCount };
+        } ) );
+        return { ...group.toObject(), subTemplateList: templateList };
+      } ) );
+      return { groupName: ele.group, masterTemplate: masterDetails };
+    } ) );
+    return res.sendSuccess( treeList );
+  } catch ( e ) {
+    logger.error( { functionName: 'getTreeList', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+
+export async function getTreeList( req, res ) {
+  try {
+    let query = [
+      {
+        $match: {
+          ...( req.query?.masterId ) ? { masterTemplateId: new ObjectId( req.query.masterId ) } :{ clientId: req.query.clientId, templateType: 'master' },
+        },
+      },
+      {
+        $sort: {
+          'header.label': 1,
+        },
+      },
+
+    ];
+
+    let fixtureDetails = await fixtureConfigService.aggregate( query );
+    if ( req?.query?.masterId ) {
+      fixtureDetails = await Promise.all( fixtureDetails.map( async ( fixt ) => {
+        let query = [
+          {
+            $match: {
+              fixtureConfigId: new ObjectId( fixt._id ),
+            },
+          },
+          {
+            $group: {
+              _id: '',
+              store: { $addToSet: '$storeId' },
+            },
+          },
+          {
+            $project: {
+              _id: 0,
+              storeCount: { $size: '$store' },
+            },
+          },
+        ];
+        let storeFixtureCount = await storeFixtureService.aggregate( query );
+        fixt.vmConfig = await Promise.all( fixt.vmConfig.map( async ( vm ) => {
+          let vmDetails = await vmService.findOne( { _id: vm.vmId }, { _id: 0 } );
+          return { ...vm, ...vmDetails?.toObject() };
+        } ) );
+        return { ...fixt, storeCount: storeFixtureCount?.[0]?.storeCount || 0 };
+      } ) );
+    }
+    return res.sendSuccess( fixtureDetails );
+  } catch ( e ) {
+    logger.error( { functionName: 'getTreeList', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+
+export async function duplicateTemplate( req, res ) {
+  try {
+    let templateDetails = await fixtureConfigService.findOne( { _id: req.body.templateId }, { createdAt: 0, updatedAt: 0 } );
+    if ( !templateDetails ) {
+      return res.sendError( 'No data found', 204 );
+    }
+    let getAllTemplate;
+    let counter = 1;
+    let newFixtureName;
+    templateDetails = templateDetails.toObject();
+    let type = templateDetails.templateType;
+    if ( templateDetails.templateType == 'master' ) {
+      templateDetails = { ...templateDetails, masterTemplateId: templateDetails._id, templateType: 'sub' };
+      getAllTemplate = await fixtureConfigService.findAndSort( { masterTemplateId: templateDetails.masterTemplateId }, {}, { templateIndex: -1 } );
+      newFixtureName = templateDetails.fixtureName + ` - Variant ${getAllTemplate.length + 1}`;
+      if ( getAllTemplate?.length ) {
+        let fixtureNameList = getAllTemplate.map( ( ele ) => ele.fixtureName );
+        while ( fixtureNameList.includes( newFixtureName ) ) {
+          newFixtureName = templateDetails.fixtureName + ` - Variant ${counter}`;
+          counter++;
+        }
+      }
+    } else {
+      getAllTemplate = await fixtureConfigService.findAndSort( { fixtureName: { $regex: templateDetails.fixtureName.replace( /[.*+?^${}()|[\]\\]/g, '\\$&' ), $options: 'i' } }, { fixtureName: 1, templateIndex: 1 }, { templateIndex: -1 } );
+      newFixtureName = templateDetails.fixtureName + ` (${counter})`;
+      if ( getAllTemplate?.length ) {
+        let fixtureNameList = getAllTemplate.map( ( ele ) => ele.fixtureName );
+        while ( fixtureNameList.includes( newFixtureName ) ) {
+          newFixtureName = templateDetails.fixtureName + ` (${counter})`;
+          counter++;
+        }
+      }
+    }
+    templateDetails.templateIndex = ( getAllTemplate?.[0]?.templateIndex ?? 0 )+ 1;
+    delete templateDetails._id;
+    delete templateDetails.templateGroupName;
+    templateDetails.fixtureName = newFixtureName;
+    templateDetails.status = 'complete';
+    templateDetails.isEdited = false;
+    let duplicateDetails = await fixtureConfigService.create( templateDetails );
+    return res.sendSuccess( { message: type == 'sub' ? 'Fixture template duplicated successfully' : 'Variant created successfully', id: duplicateDetails?._id } );
+  } catch ( e ) {
+    logger.error( { functionName: 'duplicateFixture', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+
+export async function getTemplateStoreList( req, res ) {
+  try {
+    let templateDetails = await fixtureConfigService.findOne( { _id: req.body.templateId } );
+    if ( !templateDetails ) {
+      return res.sendError( 'N0 data found', 204 );
+    }
+    let limit = req.body?.limit || 10;
+    let page = req.body?.offset || 0;
+    let skip = limit * ( page - 1 );
+    let query = [
+      {
+        $match: {
+          fixtureConfigId: new ObjectId( req.body.templateId ),
+        },
+      },
+      {
+        $group: {
+          _id: { store: '$storeName', floor: '$floorId' },
+          storeId: { $first: '$storeId' },
+          updatedAt: { $first: '$updatedAt' },
+          planoId: { $first: '$planoId' },
+        },
+      },
+      {
+        $project: {
+          storeName: '$_id.store',
+          storeId: 1,
+          updatedAt: 1,
+          planoId: 1,
+          floorId: '$_id.floor',
+        },
+      },
+      {
+        $lookup: {
+          from: 'storelayouts',
+          let: { floor: '$floorId' },
+          pipeline: [
+            {
+              $match: {
+                $expr: {
+                  $eq: [ '$_id', '$$floor' ],
+                },
+              },
+            },
+            {
+              $project: {
+                floorName: 1,
+              },
+            },
+          ],
+          as: 'floorDetails',
+        },
+      },
+      {
+        $unwind: {
+          path: '$floorDetails',
+          preserveNullAndEmptyArrays: true,
+        },
+      },
+      {
+        $lookup: {
+          from: 'stores',
+          let: { store: '$storeId' },
+          pipeline: [
+            {
+              $match: {
+                $expr: {
+                  $eq: [ '$storeId', '$$store' ],
+                },
+              },
+            },
+            {
+              $project: {
+                _id: 0,
+                storeProfile: 1,
+              },
+            },
+          ],
+          as: 'storeDetails',
+        },
+      },
+      {
+        $lookup: {
+          from: 'clusters',
+          let: { store: '$storeId' },
+          pipeline: [
+            {
+              $match: {
+                $expr: {
+                  $in: [ '$$store', '$stores.storeId' ],
+                },
+              },
+            },
+            {
+              $group: {
+                _id: '',
+                clusterName: { $addToSet: '$clusterName' },
+              },
+            },
+            {
+              $project: {
+                _id: 0,
+                clusterName: 1,
+              },
+            },
+          ],
+          as: 'clusterDetails',
+        },
+      },
+      {
+        $project: {
+          storeName: 1,
+          storeId: 1,
+          updatedAt: 1,
+          planoId: 1,
+          storeDetails: { $ifNull: [ { $arrayElemAt: [ '$storeDetails.storeProfile', 0 ] }, {} ] },
+          clusterDetails: { $ifNull: [ { $arrayElemAt: [ '$clusterDetails.clusterName', 0 ] }, {} ] },
+          floorId: 1,
+          floorName: { $ifNull: [ '$floorDetails.floorName', '' ] },
+        },
+      },
+    ];
+    if ( req.body.searchValue ) {
+      query.push( {
+        $match: {
+          storeName: { $regex: req.body.searchValue, $options: 'i' },
+        },
+      } );
+    }
+    if ( req.body.sortColumnName && req.body.sortBy ) {
+      query.push( { $sort: { [req.body.sortColumnName]: req.body.sortBy } } );
+    } else {
+      query.push( { $sort: { storeName: 1 } } );
+    }
+    query.push(
+        {
+          $facet: {
+            data: [
+              { $skip: skip }, { $limit: limit },
+            ],
+            count: [
+              { $count: 'total' },
+            ],
+          },
+        },
+    );
+    let floorQuery = [
+      {
+        $group: {
+          _id: '$storeId',
+          count: { $sum: 1 },
+        },
+      },
+      {
+        $match: {
+          count: { $gt: 1 },
+        },
+      },
+      {
+        $project: {
+          _id: 0,
+          store: '$_id',
+        },
+      },
+    ];
+    const [ getStoreDetails, floorDetails ] = await Promise.all( [
+      storeFixtureService.aggregate( query ),
+      storeLayoutService.aggregate( floorQuery ),
+    ] );
+    if ( !getStoreDetails[0].data.length ) {
+      return res.sendError( 'No data found', 204 );
+    }
+    let result = {
+      count: getStoreDetails?.[0]?.count?.[0]?.total || 0,
+      data: getStoreDetails?.[0]?.data || [],
+      doubleFloorStores: floorDetails?.map( ( ele ) => ele.store ) || [],
+    };
+    let status = templateDetails.isEdited ? 'Yet to publish' : 'Published';
+    result.data.forEach( ( ele ) => {
+      ele.status = status;
+    } );
+    return res.sendSuccess( result );
+  } catch ( e ) {
+    logger.error( { functionName: 'getTemplateStoreList', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+
+export async function templateVersionList( req, res ) {
+  try {
+    if ( !req.query?.templateId ) {
+      return res.sendError( 'Template id is required', 400 );
+    }
+    let configLogDetails = await templateLogService.find( { templateId: req.query.templateId }, {}, { _id: -1 } );
+    if ( !configLogDetails.length ) {
+      return res.sendError( 'NO data found', 204 );
+    }
+    return res.sendSuccess( configLogDetails );
+  } catch ( e ) {
+    logger.error( { functionName: 'templateVersionList', error: e } );
+    return res.sendError( e, 500 );
+  }
+}
+
+