tango-app-api-store-zone 3.3.1 → 3.3.2

package/src/controllers/zoneTagging.controller.js

@@ -1,22 +1,30 @@
 import { logger } from 'tango-app-api-middleware';
 import * as cameraService from '../services/camera.service.js';
 import * as taggingService from '../services/tagging.service.js';
+import * as customZoneTagService from '../services/customzonetag.service.js';
+import * as customzonegrouping from '../services/customzonegrouping.service.js';
 import * as storeService from '../services/store.service.js';
 import * as clientService from '../services/client.service.js';
 import * as externalService from '../services/external.service.js';
-import { signedUrl, listFileByPath, fileUpload, insertOpenSearchData } from 'tango-app-api-middleware';
+import { signedUrl, listFileByPath, fileUpload, insertOpenSearchData, download } from 'tango-app-api-middleware';
+import * as checklistconfigService from '../services/checklistconfig.services.js';
 import axios from 'axios';
+import _ from 'lodash';
+
 export const addCustomTag = async ( req, res ) => {
   try {
     let inputData = req.body;
     let taggingDetails = await taggingService.findOne( { clientId: inputData.clientId, storeId: inputData.storeId, tagName: inputData.tagName, isDeleted: false } );
+    let findgroup = await customZoneTagService.findOne( { clientId: inputData.clientId, storeId: inputData.storeId, tagName: inputData.tagName } );
     if ( !taggingDetails ) {
       let data = {
         clientId: inputData.clientId,
         storeId: inputData.storeId,
         tagName: inputData.tagName,
         rgbColor: inputData.rgbColor,
+        productName: inputData.productName,
         rgbBorderColor: inputData.rgbBorderColor,
+        groupName: findgroup.groupName,
       };
       await taggingService.deleteMany( { clientId: inputData.clientId, storeId: inputData.storeId, tagName: inputData.tagName, isDeleted: true } );
       await taggingService.create( data );
@@ -30,8 +38,8 @@ export const addCustomTag = async ( req, res ) => {
       date: new Date(),
       logType: 'zone',
       logSubType: 'addCustomTag',
-      changes: [ `${inputData.tagName} customtag Created.` ],
-      eventType: '',
+      changes: [ `${inputData.tagName} custom tag` ],
+      eventType: 'create',
       showTo: [ 'client', 'tango' ],
     };
     insertOpenSearchData( JSON.parse( process.env.OPENSEARCH )?.activityLog, logObj );
@@ -44,7 +52,7 @@ export const addCustomTag = async ( req, res ) => {
 
 export const customTagList = async ( req, res ) => {
   try {
-    let customTagList = [ 'Front', 'Back' ];
+    let customTagList = [ 'Front', 'Back', 'Tracker-in', 'Tracker-out' ];
     let storeDetails = await storeService.findOne( { storeId: req.query.storeId }, { product: 1 } );
     let clientDetails = await clientService.findOne( { clientId: req.query.clientId }, { featureConfigs: 1 } );
     if ( clientDetails && clientDetails?.featureConfigs?.isExcludedArea ) {
@@ -149,6 +157,14 @@ export const customTagList = async ( req, res ) => {
         i.rgbColor = 'rgba(193, 214, 114, 0.5)';
         i.rgbBorderColor = 'rgb(203, 224, 124)';
       }
+      if ( i.tagName === 'Tracker-in' ) {
+        i.rgbColor = 'rgba(123, 95, 105, 0.5)';
+        i.rgbBorderColor = 'rgb(133, 105, 115)';
+      }
+      if ( i.tagName === 'Tracker-out' ) {
+        i.rgbColor = 'rgba(12, 195, 111, 0.5)';
+        i.rgbBorderColor = 'rgb(22, 205, 125)';
+      }
     } );
 
     return res.sendSuccess( customTagList );
@@ -157,6 +173,526 @@ export const customTagList = async ( req, res ) => {
     return res.sendError( e, 500 );
   }
 };
+export const customTagListv2 = async ( req, res ) => {
+  try {
+    // Step 1: Base tag list
+    let customTagList = [
+      { tagName: 'Front', productName: 'tangoTraffic' },
+      { tagName: 'Back', productName: 'tangoTraffic' },
+      { tagName: 'Tracker-in', productName: 'tangoTracker' },
+      { tagName: 'Tracker-out', productName: 'tangoTracker' },
+    ];
+
+    // Step 2: Fetch store & client details in parallel
+    const [ storeDetails, clientDetails, camList ] = await Promise.all( [
+      storeService.findOne(
+          { storeId: req.query.storeId },
+          { product: 1 },
+      ),
+      clientService.findOne(
+          { clientId: req.query.clientId },
+          { featureConfigs: 1 },
+      ),
+      cameraService.find(
+          { storeId: req.query.storeId, isActivated: true, isUp: true },
+          { streamName: 1 },
+      ),
+    ] );
+
+    // Step 3: Add conditional tags
+    if ( clientDetails?.featureConfigs?.isExcludedArea ) {
+      customTagList.push( { tagName: 'Excluded Area', productName: 'tangoTraffic' } );
+    }
+    if ( clientDetails?.featureConfigs?.isPasserByData ) {
+      customTagList.push( { tagName: 'Passer By', productName: 'tangoTraffic' } );
+    }
+    if ( storeDetails?.product?.includes( 'tangoZone' ) ) {
+      customTagList.push(
+          { tagName: 'Entry/Exit', productName: 'tangoZone' },
+          { tagName: 'Billing', productName: 'tangoZone' },
+      );
+    }
+    if ( req.query.selectedProduct && req.query.selectedProduct != '' ) {
+      customTagList = customTagList.filter( ( ele ) => ele.productName === req.query.selectedProduct );
+    }
+    // Step 4: Fetch existing tags
+    const tagInfo = await taggingService.find(
+        { clientId: req.query.clientId, productName: req.query.selectedProduct },
+        { tagName: 1, rgbColor: 1, rgbBorderColor: 1, productName: 1, groupName: 1 },
+    );
+
+    // Merge all tags
+    const mergedTags = [ ...customTagList, ...tagInfo ];
+
+    // Step 5: Build unique tag list
+    const uniqueTags = [ ...new Map( mergedTags.map( ( tag ) => [ tag.tagName, tag ] ) ).values() ];
+
+    // Step 6: Query counts per tag
+    const tagNames = uniqueTags.map( ( t ) => t.tagName );
+    let activeCam = camList.map( ( data ) => data.streamName );
+    const taggingDetails = await taggingService.aggregate( [
+      {
+        $match: {
+          productName: req.query.selectedProduct,
+          clientId: req.query.clientId,
+          storeId: req.query.storeId,
+          coordinates: { $exists: true, $ne: [] },
+          tagName: { $in: tagNames },
+          streamName: { $in: activeCam },
+        },
+      },
+      { $group: { _id: '$tagName', count: { $sum: 1 } } },
+    ] );
+
+    const countMap = new Map( taggingDetails.map( ( t ) => [ t._id, t.count ] ) );
+
+    // Step 7: Tag colors config (instead of many ifs)
+    const tagColors = {
+      'Front': { rgbColor: 'rgba(89, 80, 5, 0.5)', rgbBorderColor: 'rgb(99, 90, 15)' },
+      'Back': { rgbColor: 'rgba(94, 60, 107, 0.5)', rgbBorderColor: 'rgb(104, 70, 117)' },
+      'Excluded Area': { rgbColor: 'rgba(186, 60, 214, 0.5)', rgbBorderColor: 'rgb(196, 70, 224)' },
+      'Passer By': { rgbColor: 'rgba(81, 153, 247, 0.5)', rgbBorderColor: 'rgb(91, 163, 257)' },
+      'Entry/Exit': { rgbColor: 'rgba(224, 43, 170, 0.5)', rgbBorderColor: 'rgb(234, 53, 180)' },
+      'Billing': { rgbColor: 'rgba(193, 214, 114, 0.5)', rgbBorderColor: 'rgb(203, 224, 124)' },
+      'Tracker-in': { rgbColor: 'rgba(123, 95, 105, 0.5)', rgbBorderColor: 'rgb(133, 105, 115)' },
+      'Tracker-out': { rgbColor: 'rgba(12, 195, 111, 0.5)', rgbBorderColor: 'rgb(22, 205, 125)' },
+    };
+
+
+    // Step 8: Final processing
+    const finalTags = uniqueTags.map( ( tag ) => ( {
+      tagName: tag.tagName,
+      productName: tag.productName,
+      groupName: tag.groupName ? tag.groupName : '',
+      count: countMap.get( tag.tagName ) || 0,
+      rgbColor: tag.rgbColor || tagColors[tag.tagName]?.rgbColor,
+      rgbBorderColor: tag.rgbBorderColor || tagColors[tag.tagName]?.rgbBorderColor,
+    } ) );
+    const groupedData = finalTags.reduce( ( acc, item ) => {
+      if ( item.groupName === '' ) {
+        item.isGroup = false;
+        // If groupName is empty, push the item as a standalone object
+        acc.push( item );
+      } else {
+        // If groupName exists, find if we already started a group for it
+        let group = acc.find( ( i ) => i.isGroup && i.groupName === item.groupName );
+
+        if ( !group ) {
+          // Create a new group container
+          group = {
+            groupName: item.groupName,
+            isGroup: true, // flag to identify this is a group
+            children: [],
+          };
+          acc.push( group );
+        }
+
+        // Push the current item into the group's children
+        group.children.push( item );
+      }
+      return acc;
+    }, [] );
+
+
+    // Step 9: Sort by count (desc)
+    groupedData.sort( ( a, b ) => b.count - a.count );
+
+    if ( req.query.selectedProduct && req.query.selectedProduct === 'tangoTrax' ) {
+      let Query = [ {
+        $match: {
+          client_id: req.query.clientId,
+          publish: true,
+          checkListType: { $ne: 'custom' },
+        },
+      }, {
+        $group: {
+          _id: '$_id',
+          sourceCheckList_id: { $last: '$_id' },
+          tagName: { $last: '$checkListName' },
+        },
+      },
+      {
+        $lookup: {
+          from: 'cameras',
+          let: { checkListName: '$tagName' },
+          pipeline: [
+            {
+              $match: {
+                $expr: {
+                  $anyElementTrue: {
+                    $map: {
+                      input: { $ifNull: [ '$taggedChecklist', [] ] }, // ✅ default to empty array
+                      as: 'tc',
+                      in: { $eq: [ '$$tc.checkListName', '$$checkListName' ] },
+                    },
+                  },
+                },
+              },
+            },
+            {
+              $project: {
+                storeId: 1,
+              },
+            },
+          ], as: 'cameraList',
+        },
+      },
+      {
+        $project: {
+          tagName: 1,
+          type: 'checklist',
+          cameraList: {
+            $filter: {
+              input: '$cameraList',
+              as: 'item',
+              cond: {
+                $eq: [ '$$item.storeId', req.query.storeId ],
+              },
+            },
+          },
+        },
+      },
+      {
+        $project: {
+          tagName: 1,
+          type: 1,
+          count: { $size: '$cameraList' },
+        },
+      },
+      {
+        $sort: {
+          count: -1,
+        },
+      },
+
+      ];
+      let getChecklistData = await checklistconfigService.aggregate( Query );
+      if ( finalTags && finalTags.length > 0 ) {
+        let merged = getChecklistData.map( ( item ) => {
+          let match = finalTags.find( ( a ) => a.tagName === item.tagName );
+          if ( match ) {
+            return { ...item, ...match, count: item.count + match.count }; // add counts
+          }
+          return item;
+        } );
+        // also include any arr1 items not in arr2
+        finalTags.forEach( ( a ) => {
+          if ( !merged.find( ( m ) => m.tagName === a.tagName ) ) {
+            merged.push( a );
+          }
+        } );
+        merged.sort( ( a, b ) => b.count - a.count );
+        return res.sendSuccess( merged );
+      } else {
+        return res.sendSuccess( getChecklistData );
+      }
+    } else {
+      return res.sendSuccess( groupedData );
+    }
+  } catch ( e ) {
+    logger.error( { error: e, function: 'customTagList' } );
+    return res.sendError( e, 500 );
+  }
+};
+export const customTagListv3 = async ( req, res ) => {
+  try {
+    // Step 1: Base tag list
+    let customTagList = [
+      { tagName: 'Front', productName: 'tangoTraffic' },
+      { tagName: 'Back', productName: 'tangoTraffic' },
+      { tagName: 'Tracker-in', productName: 'tangoTracker' },
+      { tagName: 'Tracker-out', productName: 'tangoTracker' },
+    ];
+
+    // Step 2: Fetch store & client details in parallel
+    const [ storeDetails, clientDetails, camList ] = await Promise.all( [
+      storeService.findOne(
+          { storeId: req.query.storeId },
+          { product: 1 },
+      ),
+      clientService.findOne(
+          { clientId: req.query.clientId },
+          { featureConfigs: 1 },
+      ),
+      cameraService.find(
+          { storeId: req.query.storeId, isActivated: true, isUp: true },
+          { streamName: 1 },
+      ),
+    ] );
+
+    // Step 3: Add conditional tags
+    if ( clientDetails?.featureConfigs?.isExcludedArea ) {
+      customTagList.push( { tagName: 'Excluded Area', productName: 'tangoTraffic' } );
+    }
+    if ( clientDetails?.featureConfigs?.isPasserByData ) {
+      customTagList.push( { tagName: 'Passer By', productName: 'tangoTraffic' } );
+    }
+    if ( storeDetails?.product?.includes( 'tangoZone' ) ) {
+      customTagList.push(
+          { tagName: 'Entry/Exit', productName: 'tangoZone' },
+          { tagName: 'Billing', productName: 'tangoZone' },
+      );
+    }
+    if ( req.query.selectedProduct && req.query.selectedProduct != '' ) {
+      customTagList = customTagList.filter( ( ele ) => ele.productName === req.query.selectedProduct );
+    }
+    // Step 4: Fetch existing tags
+    const tagInfo = await taggingService.find(
+        { clientId: req.query.clientId, productName: req.query.selectedProduct },
+        { tagName: 1, rgbColor: 1, rgbBorderColor: 1, productName: 1, groupName: 1 },
+    );
+
+    // Merge all tags
+    const mergedTags = [ ...customTagList, ...tagInfo ];
+    const uniqueTags = [ ...new Map( mergedTags.map( ( tag ) => [ tag.tagName, tag ] ) ).values() ];
+
+    // Step 6: Query counts per tag
+    const tagNames = uniqueTags.map( ( t ) => t.tagName );
+    let activeCam = camList.map( ( data ) => data.streamName );
+    const taggingDetails = await taggingService.aggregate( [
+      {
+        $match: {
+          productName: req.query.selectedProduct,
+          clientId: req.query.clientId,
+          storeId: req.query.storeId,
+          coordinates: { $exists: true, $ne: [] },
+          tagName: { $in: tagNames },
+          streamName: { $in: activeCam },
+        },
+      },
+      { $group: { _id: '$tagName', count: { $sum: 1 } } },
+    ] );
+
+    const countMap = new Map( taggingDetails.map( ( t ) => [ t._id, t.count ] ) );
+
+    // Step 7: Tag colors config (instead of many ifs)
+    const tagColors = {
+      'Front': { rgbColor: 'rgba(89, 80, 5, 0.5)', rgbBorderColor: 'rgb(99, 90, 15)' },
+      'Back': { rgbColor: 'rgba(94, 60, 107, 0.5)', rgbBorderColor: 'rgb(104, 70, 117)' },
+      'Excluded Area': { rgbColor: 'rgba(186, 60, 214, 0.5)', rgbBorderColor: 'rgb(196, 70, 224)' },
+      'Passer By': { rgbColor: 'rgba(81, 153, 247, 0.5)', rgbBorderColor: 'rgb(91, 163, 257)' },
+      'Entry/Exit': { rgbColor: 'rgba(224, 43, 170, 0.5)', rgbBorderColor: 'rgb(234, 53, 180)' },
+      'Billing': { rgbColor: 'rgba(193, 214, 114, 0.5)', rgbBorderColor: 'rgb(203, 224, 124)' },
+      'Tracker-in': { rgbColor: 'rgba(123, 95, 105, 0.5)', rgbBorderColor: 'rgb(133, 105, 115)' },
+      'Tracker-out': { rgbColor: 'rgba(12, 195, 111, 0.5)', rgbBorderColor: 'rgb(22, 205, 125)' },
+    };
+
+
+    // Step 8: Final processing
+    const finalTags = uniqueTags.map( ( tag ) => ( {
+      tagName: tag.tagName,
+      productName: tag.productName,
+      groupName: tag.groupName ? tag.groupName : '',
+      count: countMap.get( tag.tagName ) || 0,
+      rgbColor: tag.rgbColor || tagColors[tag.tagName]?.rgbColor,
+      rgbBorderColor: tag.rgbBorderColor || tagColors[tag.tagName]?.rgbBorderColor,
+    } ) );
+
+
+    console.log( '🚀 ~ customTagListv3 ~ mergedTags:', mergedTags );
+
+    if ( req.query.selectedProduct === 'tangoZone' ) {
+      const zonefinalTags = await customZoneTagService.aggregate( [
+        {
+          $match: {
+            clientId: req.query.clientId,
+            productName: req.query.selectedProduct,
+          },
+        },
+
+        // Count lookup
+        {
+          $lookup: {
+            from: 'taggings',
+            let: { tagName: '$tagName', clientId: '$clientId' },
+            pipeline: [
+              {
+                $match: {
+                  $expr: {
+                    $and: [
+                      { $eq: [ '$tagName', '$$tagName' ] },
+                      { $eq: [ '$clientId', '$$clientId' ] },
+                      { $in: [ '$streamName', activeCam ] },
+                      { $ne: [ '$coordinates', [] ] },
+                    ],
+                  },
+                },
+              },
+              { $count: 'count' },
+            ],
+            as: 'tagsCount',
+          },
+        },
+
+        // Add count
+        {
+          $addFields: {
+            count: {
+              $ifNull: [ { $arrayElemAt: [ '$tagsCount.count', 0 ] }, 0 ],
+            },
+          },
+        },
+
+        {
+          $project: {
+            _id: 0,
+            tagName: 1,
+            productName: 1,
+            groupName: 1,
+            rgbColor: 1,
+            rgbBorderColor: 1,
+            count: 1,
+          },
+        },
+        {
+          $sort: {
+            count: -1,
+          },
+        },
+
+        // Split grouped vs ungrouped
+        {
+          $facet: {
+            grouped: [
+              { $match: { groupName: { $nin: [ null, '' ] } } },
+              {
+                $group: {
+                  _id: '$groupName',
+                  children: { $push: '$$ROOT' },
+                },
+              },
+              {
+                $project: {
+                  _id: 0,
+                  groupName: '$_id',
+                  isGroup: { $literal: true },
+                  children: 1,
+                },
+              },
+            ],
+
+            ungrouped: [
+              { $match: { groupName: { $in: [ null, '' ] } } },
+              {
+                $addFields: { isGroup: { $literal: false } },
+              },
+            ],
+          },
+        },
+
+        // Merge results
+        {
+          $project: {
+            result: { $concatArrays: [ '$ungrouped', '$grouped' ] },
+          },
+        },
+
+        { $unwind: '$result' },
+        { $replaceRoot: { newRoot: '$result' } },
+      ] );
+
+
+      return res.sendSuccess( zonefinalTags );
+    }
+
+
+    if ( req.query.selectedProduct && req.query.selectedProduct === 'tangoTrax' ) {
+      let Query = [ {
+        $match: {
+          client_id: req.query.clientId,
+          publish: true,
+          checkListType: { $ne: 'custom' },
+        },
+      }, {
+        $group: {
+          _id: '$_id',
+          sourceCheckList_id: { $last: '$_id' },
+          tagName: { $last: '$checkListName' },
+        },
+      },
+      {
+        $lookup: {
+          from: 'cameras',
+          let: { checkListName: '$tagName' },
+          pipeline: [
+            {
+              $match: {
+                $expr: {
+                  $anyElementTrue: {
+                    $map: {
+                      input: { $ifNull: [ '$taggedChecklist', [] ] }, // ✅ default to empty array
+                      as: 'tc',
+                      in: { $eq: [ '$$tc.checkListName', '$$checkListName' ] },
+                    },
+                  },
+                },
+              },
+            },
+            {
+              $project: {
+                storeId: 1,
+              },
+            },
+          ], as: 'cameraList',
+        },
+      },
+      {
+        $project: {
+          tagName: 1,
+          type: 'checklist',
+          cameraList: {
+            $filter: {
+              input: '$cameraList',
+              as: 'item',
+              cond: {
+                $eq: [ '$$item.storeId', req.query.storeId ],
+              },
+            },
+          },
+        },
+      },
+      {
+        $project: {
+          tagName: 1,
+          type: 1,
+          count: { $size: '$cameraList' },
+        },
+      },
+      {
+        $sort: {
+          count: -1,
+        },
+      },
+
+      ];
+      let getChecklistData = await checklistconfigService.aggregate( Query );
+      if ( finalTags && finalTags.length > 0 ) {
+        let merged = getChecklistData.map( ( item ) => {
+          let match = finalTags.find( ( a ) => a.tagName === item.tagName );
+          if ( match ) {
+            return { ...item, ...match, count: item.count + match.count }; // add counts
+          }
+          return item;
+        } );
+        // also include any arr1 items not in arr2
+        finalTags.forEach( ( a ) => {
+          if ( !merged.find( ( m ) => m.tagName === a.tagName ) ) {
+            merged.push( a );
+          }
+        } );
+        merged.sort( ( a, b ) => b.count - a.count );
+        return res.sendSuccess( merged );
+      } else {
+        return res.sendSuccess( getChecklistData );
+      }
+    } else {
+      return res.sendSuccess( finalTags );
+    }
+  } catch ( e ) {
+    logger.error( { error: e, function: 'customTagList' } );
+    return res.sendError( e, 500 );
+  }
+};
 
 export const tagging = async ( req, res ) => {
   try {
@@ -182,8 +718,8 @@ export const tagging = async ( req, res ) => {
         date: new Date(),
         logType: 'zone',
         logSubType: 'addZoneTagging',
-        changes: [ `${InputData.tagName} zone added tagging` ],
-        eventType: '',
+        changes: [ `${InputData.tagName} zone tagging` ],
+        eventType: 'create',
         showTo: [ 'client', 'tango' ],
       };
       insertOpenSearchData( JSON.parse( process.env.OPENSEARCH )?.activityLog, logObj );
@@ -206,12 +742,33 @@ export const tagging = async ( req, res ) => {
         date: new Date(),
         logType: 'zone',
         logSubType: 'updateZoneTagging',
-        changes: [ `${InputData.tagName} zone Updated tagging` ],
-        eventType: '',
+        changes: [ `${InputData.tagName} zone tagging` ],
+        eventType: 'update',
+        taggingId: taggingDetails._id,
+        previous: [
+          JSON.parse( JSON.stringify( taggingDetails ) ),
+        ],
+        current: {
+          ...taggingDetails.toObject(),
+        },
+        oldData: {
+          TagName: taggingDetails.tagName,
+          StreamName: taggingDetails.streamName,
+        },
+        newData: {
+          TagName: taggingDetails.tagName,
+          StreamName: taggingDetails.streamName,
+        },
+        showTo: [ 'tango', 'client' ],
       };
+
+      delete logObj?.current?.coordinates;
+
       insertOpenSearchData( JSON.parse( process.env.OPENSEARCH )?.activityLog, logObj );
       taggingDetails.cameraId = InputData.cameraId;
       taggingDetails.streamName = InputData.streamName;
+      taggingDetails.checkListName = InputData.checkListName;
+      taggingDetails.productName = InputData.productName;
       // if ( req.body?.redoPoint ) {
       //   taggingDetails.coordinates = InputData.coordinates[0];
       //   taggingDetails.save();
@@ -244,7 +801,7 @@ export const tagging = async ( req, res ) => {
     let externalDetails = await externalService.findOne( { storeId: InputData.storeId, zoneName: InputData.tagName, clientId: InputData.clientId } );
 
     if ( !externalDetails ) {
-      let data ={
+      let data = {
         'storeId': InputData.storeId,
         'clientId': InputData.clientId,
         'productName': 'tangoZone',
@@ -278,7 +835,7 @@ export const tagging = async ( req, res ) => {
         'reidParameterType': 'default',
         'reidParameterValue': [ 0.6, 1, 0.6 ],
         'reidSuggesteParameter': false,
-        'reidSuggestedReduction': false,
+        'reidSuggestedReduction': true,
         'reidThresholdHoliday': 0,
         'reidThresholdWeekDay': 0,
         'stage': '',
@@ -290,11 +847,25 @@ export const tagging = async ( req, res ) => {
         'walkInTimeSpent': 3,
         'isWalkInOneImg': false,
         'isAudit': true,
-        'isForceCombine': false,
+        'isForceCombine': true,
       };
 
       await externalService.create( data );
     }
+
+    let cameraDetails = await cameraService.findOne( { _id: InputData.cameraId, streamName: InputData.streamName }, { productModule: 1 } );
+    if ( cameraDetails ) {
+      if ( !cameraDetails?.productModule.includes( 'tangoZone' ) ) {
+        cameraDetails.productModule.push( { productName: 'tangoZone', checked: true } );
+        cameraDetails.save();
+      } else {
+        let camIndex = cameraDetails.productModule.findIndex( ( ele ) => ele.productName == 'tangoZone' );
+        if ( !cameraDetails?.productModule?.[camIndex]?.checked ) {
+          cameraDetails.productModule[camIndex].checked = true;
+          cameraDetails.save();
+        }
+      }
+    }
     await updatezoneTagging( req, res );
   } catch ( e ) {
     logger.error( { error: e, function: 'tagging' } );
@@ -308,11 +879,13 @@ export const getCameraList = async ( req, res ) => {
     if ( !cameraDetails.length ) {
       return res.sendError( 'no data found', 204 );
     }
-    const folderPath = { file_path: `${req.query.storeId}/zone_base_images/`,
+    const folderPath = {
+      file_path: `${req.query.storeId}/zone_base_images/`,
       Bucket: JSON.parse( process.env.BUCKET ).zoneBaseImage, MaxKeys: 1000,
     };
     let fileList = await listFileByPath( folderPath );
-    const TaggedfolderPath = { file_path: `${req.query.storeId}/zone_tagged_image/`,
+    const TaggedfolderPath = {
+      file_path: `${req.query.storeId}/zone_tagged_image/`,
       Bucket: JSON.parse( process.env.BUCKET ).zoneTaggingImage, MaxKeys: 1000,
     };
     let tagFileList = await listFileByPath( TaggedfolderPath );
@@ -338,7 +911,7 @@ export const getCameraList = async ( req, res ) => {
         tagFileList.data.forEach( ( item ) => {
           if ( item.Key.length > 1 ) {
             let splitStream = item.Key.split( '/' );
-            let getStream = splitStream[splitStream.length -1].split( '.' );
+            let getStream = splitStream[splitStream.length - 1].split( '.' );
 
             if ( getStream && getStream[0] == `${req.query.storeId}_${camera.streamName}` ) {
               tagPath = item.Key;
@@ -349,21 +922,23 @@ export const getCameraList = async ( req, res ) => {
       if ( fileList?.data.length ) {
         fileList.data.forEach( ( ele ) => {
           let splitStream = ele.Key.split( '/' );
-          let getStream = splitStream[splitStream.length -1].split( '.' );
+          let getStream = splitStream[splitStream.length - 1].split( '.' );
           if ( getStream && getStream[0] == `${req.query.storeId}_${camera.streamName}` ) {
             imgPath = ele.Key;
           }
         } );
       }
       if ( tagPath ) {
-        const params = { file_path: tagPath,
+        const params = {
+          file_path: tagPath,
           Bucket: JSON.parse( process.env.BUCKET ).zoneTaggingImage,
         };
         const cameraTagImage = await signedUrl( params );
         camera.tagImg = cameraTagImage;
       }
       if ( imgPath ) {
-        const baseParams = { file_path: imgPath,
+        const baseParams = {
+          file_path: imgPath,
           Bucket: JSON.parse( process.env.BUCKET ).zoneBaseImage,
         };
         const cameraBaseImage = await signedUrl( baseParams );
@@ -379,6 +954,87 @@ export const getCameraList = async ( req, res ) => {
     return res.sendError( e, 500 );
   }
 };
+export const getCameraListv2 = async ( req, res ) => {
+  try {
+    let cameraDetails = await cameraService.find( { clientId: req.body.clientId, storeId: req.body.storeId, isActivated: true, isUp: true }, { cameraNumber: 1, streamName: 1, isActivated: 1, isUp: 1, cameraName: 1, taggedChecklist: 1 } );
+    if ( !cameraDetails.length ) {
+      return res.sendError( 'no data found', 204 );
+    }
+    const folderPath = {
+      file_path: `${req.body.storeId}/zone_base_images/`,
+      Bucket: JSON.parse( process.env.BUCKET ).zoneBaseImage, MaxKeys: 1000,
+    };
+    let fileList = await listFileByPath( folderPath );
+    const TaggedfolderPath = {
+      file_path: `${req.body.storeId}/zone_tagged_image/`,
+      Bucket: JSON.parse( process.env.BUCKET ).zoneTaggingImage, MaxKeys: 1000,
+    };
+    let tagFileList = await listFileByPath( TaggedfolderPath );
+    for ( let [ index, camera ] of cameraDetails.entries() ) {
+      let tagList = [];
+      let tagPath;
+      let imgPath;
+      camera = {
+        ...camera._doc,
+        baseImg: '',
+        tagImg: '',
+      };
+      let taggingDetails = await taggingService.find( { cameraId: camera._id, streamName: camera.streamName, clientId: req.body.clientId, isDeleted: false }, { tagName: 1, coordinates: 1 } );
+      if ( taggingDetails.length ) {
+        tagList = taggingDetails.filter( ( item ) => item.coordinates.length ).map( ( item ) => {
+          if ( item.coordinates.length ) {
+            return { tagName: item.tagName, color: item.coordinates[0].color };
+          }
+        } );
+      }
+      if ( tagFileList.data.length ) {
+        tagFileList.data.forEach( ( item ) => {
+          if ( item.Key.length > 1 ) {
+            let splitStream = item.Key.split( '/' );
+            let getStream = splitStream[splitStream.length - 1].split( '.' );
+
+            if ( getStream && getStream[0] == `${req.body.storeId}_${camera.streamName}` ) {
+              tagPath = item.Key;
+            }
+          }
+        } );
+      }
+      if ( fileList?.data.length ) {
+        fileList.data.forEach( ( ele ) => {
+          let splitStream = ele.Key.split( '/' );
+          let getStream = splitStream[splitStream.length - 1].split( '.' );
+          if ( getStream && getStream[0] == `${req.body.storeId}_${camera.streamName}` ) {
+            imgPath = ele.Key;
+          }
+        } );
+      }
+      if ( tagPath ) {
+        const params = {
+          file_path: tagPath,
+          Bucket: JSON.parse( process.env.BUCKET ).zoneTaggingImage,
+        };
+        const cameraTagImage = await signedUrl( params );
+        camera.tagImg = cameraTagImage;
+      }
+      if ( imgPath ) {
+        const baseParams = {
+          file_path: imgPath,
+          Bucket: JSON.parse( process.env.BUCKET ).zoneBaseImage,
+        };
+        const cameraBaseImage = await signedUrl( baseParams );
+        camera.baseImg = cameraBaseImage;
+      }
+      camera.tagging = tagList;
+      camera.taggedCount = tagList.filter( ( ele ) => ele.tagName === req.body.tagName );
+      cameraDetails[index] = camera;
+    }
+    cameraDetails.sort( ( a, b ) => a.tagging?.length > b.tagging?.length ? -1 : 1 );
+    return res.sendSuccess( cameraDetails );
+  } catch ( e ) {
+    logger.error( { error: e, function: 'getCameraListv2' } );
+    return res.sendError( e, 500 );
+  }
+};
 
 export const updateTag = async ( req, res ) => {
   try {
@@ -416,9 +1072,21 @@ export const updateTag = async ( req, res ) => {
       date: new Date(),
       logType: 'zone',
       logSubType: 'updateCustomTag',
-      changes: [ `${req.body.tagName} tagName Updated` ],
-      eventType: '',
-      showTo: [ 'client', 'tango' ],
+      changes: [ `${req.body.tagName} tagName` ],
+      eventType: 'update',
+      previous: {
+        tagName: req.body.existTag,
+      },
+      current: {
+        tagName: req.body.tagName,
+      },
+      oldData: {
+        TagName: req.body.existTag,
+      },
+      newData: {
+        TagName: req.body.tagName,
+      },
+      showTo: [ 'tango', 'client' ],
     };
     insertOpenSearchData( JSON.parse( process.env.OPENSEARCH )?.activityLog, logObj );
     if ( tagUpdate.modifiedCount || tagUpdate.matchedCount ) {
@@ -442,19 +1110,24 @@ export const deleteTag = async ( req, res ) => {
     if ( !taggingDetails.length ) {
       return res.sendError( 'no data found', 204 );
     }
-    let enableDelete = false;
-    if ( req.user.permission ) {
-      let permissions = req.user.permission;
-      permissions.forEach( ( permission ) => {
-        if ( permission.featureName == 'analytics' ) {
-          let product = permission.product.find( ( item ) => item.name == 'tangoZone' );
-          if ( product ) {
-            enableDelete = product.isDelete;
-          }
-        }
-      } );
+
+    let tagNameDetails = await taggingService.findOne( { clientId: req.body.clientId, tagName: req.body.tagName, $expr: { $ne: [ { $size: '$coordinates' }, 0 ] } } );
+    if ( tagNameDetails ) {
+      return res.sendError( 'This zone tag is already mapped to other stores.', 400 );
     }
-    if ( req.user?.role == 'superadmin' || ( req.user?.role == 'admin' && enableDelete ) ) {
+    // let enableDelete = false;
+    // if ( req.user.permission ) {
+    //   let permissions = req.user.permission;
+    //   permissions.forEach( ( permission ) => {
+    //     if ( permission.featureName == 'analytics' ) {
+    //       let product = permission.product.find( ( item ) => item.name == 'tangoZone' );
+    //       if ( product ) {
+    //         enableDelete = product.isDelete;
+    //       }
+    //     }
+    //   } );
+    // }
+    if ( req.user?.role == 'superadmin' || ( req.user?.role == 'admin' ) ) {
       await taggingService.deleteMany( { clientId: req.body.clientId, tagName: req.body.tagName } );
       await externalService.deleteMany( { zoneName: req.body.tagName, clientId: req.body.clientId } );
     } else {
@@ -484,9 +1157,9 @@ export const deleteTag = async ( req, res ) => {
       email: req.user?.email,
       date: new Date(),
       logType: 'zone',
-      logSubType: 'deleteTag',
-      changes: [ `${req.body.tagName} tag Deleted` ],
-      eventType: '',
+      logSubType: 'deleteCustomTag',
+      changes: [ `${req.body.tagName} tag` ],
+      eventType: 'delete',
       showTo: [ 'client', 'tango' ],
     };
     insertOpenSearchData( JSON.parse( process.env.OPENSEARCH )?.activityLog, logObj );
@@ -642,36 +1315,65 @@ export const updatezoneTagging = async ( req, res ) => {
 
 export const updateOldData = async ( req, res ) => {
   try {
-    let tagDetails = await taggingService.find( {}, { storeId: 1 } );
+    let tagDetails = await taggingService.find( { clientId: req.body.clientId, tagName: req.body.tagName }, { storeId: 1 } );
+
+
     if ( tagDetails.length ) {
       for ( let [ index, item ] of tagDetails.entries() ) {
         req.body.storeId = item.storeId;
         let camDetails = await getCamTaggingDetails( req, res );
-        if ( !camDetails ) {
-          logger.error( { message: 'no data', store: item.storeId } );
-        }
-        const response = await axios.post( JSON.parse( process.env.URL ).zoneTaggingLamdaUrl, camDetails );
-        if ( response?.data?.status && response?.data?.status == 'success' ) {
-          let fileData = {
-            Key: `${req.body.storeId}/zonetagging/`,
-            fileName: `${req.body.storeId}_zonetagging.json`,
-            Bucket: JSON.parse( process.env.BUCKET ).zoneTaggingImage,
-            body: JSON.stringify( camDetails ),
-            ContentType: 'application/json',
-          };
-          let upload = await fileUpload( fileData );
-          if ( !upload.Key ) {
-            logger.error( { message: `JSON Upload Error`, store: item.storeId } );
-          }
-          if ( index == 0 ) {
-            res.sendSuccess( 'Zone Updated Successfully' );
+        console.log( '🚀 ~ updateOldData ~ camDetails:', camDetails );
+        if ( camDetails ) {
+          const response = await axios.post( JSON.parse( process.env.URL ).zoneTaggingLamdaUrl, camDetails );
+
+          if ( response?.data?.status && response?.data?.status == 'success' ) {
+            let fileData = {
+              Key: `${req.body.storeId}/zonetagging/`,
+              fileName: `${req.body.storeId}_zonetagging.json`,
+              Bucket: JSON.parse( process.env.BUCKET ).zoneTaggingImage,
+              body: JSON.stringify( camDetails ),
+              ContentType: 'application/json',
+            };
+
+            let upload = await fileUpload( fileData );
+            if ( !upload.Key ) {
+              logger.error( { message: `JSON Upload Error`, store: item.storeId } );
+            }
+          } else {
+            logger.error( { message: 'no data', store: item.storeId } );
+            return res.sendError( 'something went wrong', 500 );
           }
-        } else {
-          logger.error( { message: 'no data', store: item.storeId } );
-          // return res.sendError( 'something went wrong', 500 );
+        }
+        if ( index == tagDetails.length-1 ) {
+          res.sendSuccess( 'Zone Updated Successfully' );
         }
       }
+    } else {
+      res.sendSuccess( 'Zone Updated Successfully' );
+    }
+  } catch ( e ) {
+    console.log( '🚀 ~ updateOldData ~ e:', e );
+    logger.error( { error: e, function: 'updateOldData' } );
+    return res.sendError( e, 500 );
+  }
+};
+export async function updateCamera( req, res ) {
+  try {
+    let findoneCheckList = await checklistconfigService.findOne( {
+      client_id: req.body.clientId, checkListName: req.body.selectedZone,
+    } );
+
+    let updateData = {
+      checkListName: req.body.selectedZone,
+      sourceCheckList_id: findoneCheckList?.sourceCheckList_id,
+    };
+    if ( req.body.type === 'tagCamera' ) {
+      await cameraService.updateOne( { _id: req.body._id }, { $push: { taggedChecklist: updateData } } );
+    } else {
+      await cameraService.updateOne( { _id: req.body._id }, { $pull: { taggedChecklist: updateData } } );
     }
+
+    res.sendSuccess( 'updated Sucessfully' );
   } catch ( e ) {
     logger.error( { error: e, function: 'updateOldData' } );
     return res.sendError( e, 500 );
@@ -715,3 +1417,1344 @@ async function updateJsonFile( req, res ) {
     }
   }
 };
+
+export const getCameraStreamList = async ( req, res ) => {
+  try {
+    let cameraDetails = await cameraService.find( { clientId: req.body.clientId, storeId: req.body.storeId, streamName: req.body.streamName }, { cameraNumber: 1, streamName: 1, isActivated: 1, isUp: 1, cameraName: 1 } );
+    if ( !cameraDetails.length ) {
+      return res.sendError( 'no data found', 204 );
+    }
+    const folderPath = {
+      file_path: `${req.body.storeId}/zone_base_images/`,
+      Bucket: JSON.parse( process.env.BUCKET ).zoneBaseImage, MaxKeys: 1000,
+    };
+    let fileList = await listFileByPath( folderPath );
+    const TaggedfolderPath = {
+      file_path: `${req.body.storeId}/zone_tagged_image/`,
+      Bucket: JSON.parse( process.env.BUCKET ).zoneTaggingImage, MaxKeys: 1000,
+    };
+    let tagFileList = await listFileByPath( TaggedfolderPath );
+    for ( let [ index, camera ] of cameraDetails.entries() ) {
+      let tagList = [];
+      let tagPath;
+      let imgPath;
+      camera = {
+        ...camera._doc,
+        baseImg: '',
+        tagImg: '',
+      };
+      let taggingDetails = await taggingService.find( { cameraId: camera._id, streamName: camera.streamName, clientId: req.body.clientId, isDeleted: false }, { tagName: 1, coordinates: 1 } );
+      if ( taggingDetails.length ) {
+        tagList = taggingDetails.filter( ( item ) => item.coordinates.length ).map( ( item ) => {
+          if ( item.coordinates.length ) {
+            return { tagName: item.tagName, color: item.coordinates[0].color };
+          }
+        } );
+      }
+
+      if ( tagFileList.data.length ) {
+        tagFileList.data.forEach( ( item ) => {
+          if ( item.Key.length > 1 ) {
+            let splitStream = item.Key.split( '/' );
+            let getStream = splitStream[splitStream.length - 1].split( '.' );
+
+            if ( getStream && getStream[0] == `${req.body.storeId}_${camera.streamName}` ) {
+              tagPath = item.Key;
+            }
+          }
+        } );
+      }
+      if ( fileList?.data.length ) {
+        fileList.data.forEach( ( ele ) => {
+          let splitStream = ele.Key.split( '/' );
+          let getStream = splitStream[splitStream.length - 1].split( '.' );
+          if ( getStream && getStream[0] == `${req.body.storeId}_${camera.streamName}` ) {
+            imgPath = ele.Key;
+          }
+        } );
+      }
+      if ( tagPath ) {
+        const params = {
+          file_path: tagPath,
+          Bucket: JSON.parse( process.env.BUCKET ).zoneTaggingImage,
+        };
+        const cameraTagImage = await signedUrl( params );
+        camera.tagImg = cameraTagImage;
+      }
+      if ( imgPath ) {
+        const baseParams = {
+          file_path: imgPath,
+          Bucket: JSON.parse( process.env.BUCKET ).zoneBaseImage,
+        };
+        const cameraBaseImage = await signedUrl( baseParams );
+        camera.baseImg = cameraBaseImage;
+      }
+      camera.tagging = tagList;
+      cameraDetails[index] = camera;
+    }
+    cameraDetails.sort( ( a, b ) => a.tagging?.length > b.tagging?.length ? -1 : 1 );
+    return res.sendSuccess( cameraDetails );
+  } catch ( e ) {
+    logger.error( { error: e, function: 'getCameraList' } );
+    return res.sendError( e, 500 );
+  }
+};
+
+
+// setting config - zone - get tagging details
+export const getZoneTaggingDetails = async ( req, res ) => {
+  try {
+    const {
+      clientId,
+      searchValue,
+      sortColumName,
+      sortBy,
+      limit,
+      offset = 1,
+      export: isExport,
+    } = req.body;
+
+    if ( !clientId ) {
+      return res.sendError( 'clientId is required', 400 );
+    }
+
+    const matchStage = {
+      clientId,
+    };
+    let customTags = await customZoneTagService.findOne( { clientId: clientId } );
+    const alltotalGroupCount = await customzonegrouping.count( { clientId } );
+    if ( !customTags ) {
+      return res.sendSuccess( { result: [], totalGroupCount: alltotalGroupCount } );
+    }
+    const searchStage = searchValue ?
+      {
+        $or: [
+          { tagName: { $regex: searchValue, $options: 'i' } },
+          { groupName: { $regex: searchValue, $options: 'i' } },
+        ],
+      } :
+      null;
+
+    const pipeline = [
+      { $match: matchStage },
+      {
+        $lookup: {
+          from: 'taggings',
+          let: { tagName: '$tagName' },
+          pipeline: [
+            {
+              $match: {
+                $expr: {
+                  $and: [
+                    { $eq: [ '$tagName', '$$tagName' ] },
+                    { $eq: [ '$clientId', clientId ] },
+                    { $ne: [ '$coordinates', [] ] },
+                  ],
+                },
+              },
+            },
+            {
+              $group: {
+                _id: '$storeId',
+                count: { $sum: 1 },
+              },
+            },
+          ],
+          as: 'tagsCount',
+        },
+      },
+      {
+        $project: {
+          clientId: 1,
+          tagName: 1,
+          groupName: 1,
+          storesTaggedCount: { $size: '$tagsCount' },
+        },
+      },
+      {
+        $facet: {
+          totalCount: [
+            ...( searchStage ? [ { $match: searchStage } ] : [] ),
+            { $count: 'count' },
+          ],
+
+          filteredData: [
+            ...( searchStage ? [ { $match: searchStage } ] : [] ),
+            ...( sortColumName && sortBy ?
+              [ { $sort: { [sortColumName]: sortBy } } ] :
+              [] ),
+            ...( isExport ?
+              [] :
+              limit ? [
+                { $skip: ( offset - 1 ) * limit },
+                { $limit: Number( limit ) },
+              ] : [] ),
+          ],
+        },
+      },
+    ];
+
+    const [ result ] = await customZoneTagService.aggregate( pipeline );
+
+    const totalCount = result.totalCount[0]?.count || 0;
+    if ( totalCount === 0 ) {
+      return res.sendError( 'No data', 204 );
+    }
+    const zoneList = result.filteredData;
+
+    // Get total count of groups for tabs (actual count, not filtered by search)
+    const totalGroupCount = await customzonegrouping.count( { clientId } );
+
+    if ( isExport && zoneList.length ) {
+      const exportdata = zoneList.map( ( z ) => ( {
+        'Zone Name': z.tagName || '--',
+        'Zone Groups': z.groupName || '--',
+        'Stores tagged Count': z.storesTaggedCount || 0,
+      } ) );
+      await download( exportdata, res );
+      return;
+    }
+
+    return res.sendSuccess( {
+      result: zoneList,
+      totalCount,
+      totalGroupCount,
+    } );
+  } catch ( e ) {
+    logger.error( { error: e, function: 'getZoneTaggingDetails' } );
+    return res.sendError( e, 500 );
+  }
+  // try {
+  //   const inputData = req.body;
+  //   let Query = [
+  //     {
+  //       $match: {
+  //         clientId: inputData.clientId,
+  //       },
+  //     },
+  //     {
+  //       $lookup: {
+  //         from: 'taggings',
+  //         let: { tagName: '$tagName' },
+  //         pipeline: [
+  //           {
+  //             $match: {
+  //               $expr: {
+  //                 $and: [
+  //                   {
+  //                     $eq: [ '$tagName', '$$tagName' ],
+  //                   },
+  //                   {
+  //                     $eq: [ '$clientId', inputData.clientId ],
+  //                   },
+  //                 ],
+  //               },
+  //             },
+  //           },
+  //         ], as: 'tagsCount',
+  //       },
+  //     },
+  //     {
+  //       $project: {
+  //         clientId: 1,
+  //         tagName: 1,
+  //         groupName: 1,
+  //         storesTaggedCount: { $size: '$tagsCount' },
+  //       },
+  //     },
+  //   ];
+  //   if ( req.body.searchValue && req.body.searchValue !== '' ) {
+  //     Query.push( {
+  //       $match: {
+  //         $or: [
+  //           { tagName: { $regex: req.body.searchValue, $options: 'i' } },
+  //           { groupName: { $regex: req.body.searchValue, $options: 'i' } },
+  //         ],
+  //       },
+  //     } );
+  //   }
+
+  //   if ( req.body.sortColumName && req.body.sortColumName !== '' && req.body.sortBy ) {
+  //     Query.push( {
+  //       $sort: { [req.body.sortColumName]: req.body.sortBy },
+  //     } );
+  //   }
+
+  //   const totalCount = await customZoneTagService.aggregate( Query );
+  //   if ( req.body.limit && req.body.offset && !req.body.export ) {
+  //     Query.push(
+  //         { $skip: ( req.body.offset - 1 ) * req.body.limit },
+  //         { $limit: Number( req.body.limit ) },
+  //     );
+  //   }
+  //   const zoneList = await customZoneTagService.aggregate( Query );
+
+  //   if ( req.body.export && zoneList.length > 0 ) {
+  //     const exportdata = [];
+  //     zoneList.forEach( ( element ) => {
+  //       const data = {
+  //         'Zone Name': element.tagName || '--',
+  //         'Zone Groups': element.groupName || '--',
+  //         'Stores tagged Count': element.storesTaggedCount || 0,
+  //       };
+  //       exportdata.push( data );
+  //     } );
+  //     await download( exportdata, res );
+  //     return;
+  //   }
+
+  //   return res.sendSuccess( {
+  //     result: zoneList,
+  //     count: totalCount.length,
+  //   } );
+  // } catch ( e ) {
+  //   logger.error( { error: e, function: 'getZoneTaggingDetails' } );
+  //   console.error( 'getZoneTaggingDetails error:', e );
+  //   return res.sendError( e, 500 );
+  // }
+};
+
+export const addZoneCustomTag = async ( req, res ) => {
+  try {
+    const {
+      clientId,
+      tagName,
+      groupName,
+      productName,
+      isExistingGroup,
+      rgbColor,
+      rgbBorderColor,
+      _id,
+    } = req.body;
+
+    if ( !clientId || !tagName ) {
+      return res.sendError( 'clientId and zoneName are required', 400 );
+    }
+
+    // Escape regex special characters in tagName to avoid invalid regex patterns
+    const escapedTagName = tagName.replace( /[.*+?^${}()|[\]\\]/g, '\\$&' );
+
+    // Case-insensitive check for existing tag
+    const existingTag = await customZoneTagService.findOne(
+        { clientId, tagName: { $regex: `^${escapedTagName}$`, $options: 'i' }, _id: { $ne: _id } },
+    );
+
+    if ( existingTag ) {
+      return res.sendError( `zoneName "${tagName}" already exists for this client`, 409 );
+    }
+
+    let groupDoc = null;
+    if ( groupName ) {
+      // Escape regex special characters in groupName to avoid invalid regex patterns
+      const escapedGroupName = groupName.replace( /[.*+?^${}()|[\]\\]/g, '\\$&' );
+      // Case-insensitive check for existing group
+      groupDoc = await customzonegrouping.findOne( { clientId, groupName: { $regex: `^${escapedGroupName}$`, $options: 'i' } } );
+    }
+
+    if ( !isExistingGroup && groupDoc ) {
+      return res.sendError( `groupName "${groupName}" already exists for this client`, 409 );
+    }
+
+    /** Create Zone Tag */
+    await customZoneTagService.create(
+        [ {
+          clientId,
+          tagName,
+          rgbColor,
+          rgbBorderColor,
+          groupName: groupName || null,
+          productName,
+        } ],
+    );
+
+    /** Create or Update Zone Group */
+    if ( groupName ) {
+      if ( !groupDoc && !isExistingGroup ) {
+        await customzonegrouping.create(
+            [ {
+              clientId,
+              groupName,
+              productName,
+              zonesTagged: [ tagName ],
+            } ],
+        );
+      } else if ( groupDoc && isExistingGroup ) {
+        await customzonegrouping.updateOne(
+            { _id: groupDoc._id },
+            { $addToSet: { zonesTagged: tagName } },
+        );
+      }
+    }
+
+    await taggingService.updateMany( { clientId, tagName }, { $set: { groupName } } );
+
+    logger.info( 'Zone Tag Created Successfully' );
+    const logObj = {
+      clientId: clientId,
+      userName: req.user?.userName,
+      email: req.user?.email,
+      date: new Date(),
+      logType: 'zone',
+      logSubType: 'addZoneCustomTag',
+      changes: [ `${tagName} custom zone tag` ],
+      eventType: 'create',
+      showTo: [ 'client', 'tango' ],
+    };
+    insertOpenSearchData( JSON.parse( process.env.OPENSEARCH )?.activityLog, logObj );
+
+    return res.sendSuccess( 'Zone Tag Created Successfully' );
+  } catch ( e ) {
+    logger.error( { error: e, function: 'addZoneCustomTag' } );
+    return res.sendError( e.message || e, 500 );
+  }
+};
+
+export const uploadBulkZoneTag = async ( req, res ) => {
+  try {
+    const zonesArray = req.body;
+    const clientId = req.bulkZoneClientId;
+
+    if ( !zonesArray || !Array.isArray( zonesArray ) || zonesArray.length === 0 ) {
+      return res.sendError( 'zone-config file must not be empty', 400 );
+    }
+
+    if ( !clientId ) {
+      return res.sendError( 'clientId is required', 400 );
+    }
+
+    const zoneTagDataList = [];
+    const zoneGroupDataMap = new Map();
+    const createdTagNames = [];
+    // Map to store user-provided groupName (any case) -> actual groupName from DB (preserving existing case)
+    const groupNameMapping = new Map();
+
+    // First pass: Check for existing groups and create mapping
+    const uniqueGroupNames = [ ...new Set( zonesArray.map( ( zone ) => zone.groupName ).filter( ( name ) => name && name !== '' && name !== null ) ) ];
+
+    for ( const userGroupName of uniqueGroupNames ) {
+      // Escape regex special characters in group name to avoid invalid regex patterns
+      const escapedUserGroupName = userGroupName.replace( /[.*+?^${}()|[\]\\]/g, '\\$&' );
+
+      // Case-insensitive check for existing group
+      const existingGroupDoc = await customzonegrouping.findOne( {
+        clientId,
+        groupName: { $regex: `^${escapedUserGroupName}$`, $options: 'i' },
+      } );
+
+      if ( existingGroupDoc ) {
+        // Group exists - use the existing group's case
+        groupNameMapping.set( userGroupName.toLowerCase(), existingGroupDoc.groupName );
+      } else {
+        // New group - use user-provided case
+        groupNameMapping.set( userGroupName.toLowerCase(), userGroupName );
+      }
+    }
+
+    // Process each zone in the array
+    for ( const zone of zonesArray ) {
+      // Determine the correct groupName to use (existing case if group exists, user case if new)
+      let normalizedGroupName = null;
+      if ( zone.groupName && zone.groupName !== '' && zone.groupName !== null ) {
+        normalizedGroupName = groupNameMapping.get( zone.groupName.toLowerCase() ) || zone.groupName;
+      }
+
+      const zoneTagData = {
+        clientId: clientId,
+        tagName: zone.tagName,
+        rgbColor: zone.rgbColor,
+        rgbBorderColor: zone.rgbBorderColor,
+        groupName: normalizedGroupName,
+        productName: zone.productName,
+      };
+      zoneTagDataList.push( zoneTagData );
+      createdTagNames.push( zone.tagName );
+
+      // Prepare zone group data if groupName is provided
+      if ( normalizedGroupName ) {
+        // Use normalized groupName (existing case or user case)
+        if ( !zoneGroupDataMap.has( normalizedGroupName ) ) {
+          zoneGroupDataMap.set( normalizedGroupName, {
+            clientId: clientId,
+            groupName: normalizedGroupName,
+            productName: zone.productName,
+            zonesTagged: new Set(),
+          } );
+        }
+
+        // Collect all tagNames for this group so that we can append them
+        const groupEntry = zoneGroupDataMap.get( normalizedGroupName );
+        groupEntry.zonesTagged.add( zone.tagName );
+      }
+    }
+
+    // Create all zone tags
+    await customZoneTagService.create( zoneTagDataList );
+
+    // Create zone groups (convert Map values to array)
+    // const zoneGroupDataList = Array.from( zoneGroupDataMap.values() );
+    // console.log( 'zoneGroupDataList', zoneGroupDataList );
+    // if ( zoneGroupDataList.length > 0 ) {
+    //   for ( const groupData of zoneGroupDataList ) {
+    //     await customzonegrouping.create( groupData );
+    //   }
+    // }
+
+    // Create or Update Zone Groups (following addZoneCustomTag pattern)
+    const zoneGroupDataList = Array.from( zoneGroupDataMap.values() ).map( ( groupData ) => ( {
+      clientId: groupData.clientId,
+      groupName: groupData.groupName,
+      productName: groupData.productName,
+      zonesTagged: Array.from( groupData.zonesTagged || [] ),
+    } ) );
+
+    if ( zoneGroupDataList.length > 0 ) {
+      for ( const groupData of zoneGroupDataList ) {
+        // Case-insensitive check for existing group (same as addZoneCustomTag)
+        const escapedGroupName = groupData.groupName.replace( /[.*+?^${}()|[\]\\]/g, '\\$&' );
+        const groupDoc = await customzonegrouping.findOne( {
+          clientId,
+          groupName: { $regex: `^${escapedGroupName}$`, $options: 'i' },
+        } );
+
+        if ( !groupDoc ) {
+          // Create new group with all zones from the bulk file
+          await customzonegrouping.create( [ {
+            clientId: groupData.clientId,
+            groupName: groupData.groupName,
+            productName: groupData.productName,
+            zonesTagged: groupData.zonesTagged,
+          } ] );
+        } else {
+          // Group exists - add new zones to existing zonesTagged array (preserving existing mappings)
+          await customzonegrouping.updateOne(
+              { _id: groupDoc._id },
+              { $addToSet: { zonesTagged: { $each: groupData.zonesTagged } } },
+          );
+        }
+      }
+    }
+
+    // Ensure tagging documents are also mapped to the correct groupName for newly uploaded zones
+    // Use normalized groupName (existing case if group exists, user case if new)
+    for ( const zone of zonesArray ) {
+      if ( zone.groupName && zone.groupName !== '' && zone.groupName !== null ) {
+        const normalizedGroupName = groupNameMapping.get( zone.groupName.toLowerCase() ) || zone.groupName;
+        await taggingService.updateMany(
+            { clientId, tagName: zone.tagName },
+            { $set: { groupName: normalizedGroupName } },
+        );
+      }
+    }
+
+
+    logger.info( `Bulk Zone Tags Created Successfully: ${createdTagNames.length} tags` );
+    const logObj = {
+      clientId: clientId,
+      userName: req.user?.userName,
+      email: req.user?.email,
+      date: new Date(),
+      logType: 'zone',
+      logSubType: 'addBulkZoneCustomTag',
+      changes: createdTagNames.map( ( tagName ) => `${tagName} custom tag` ),
+      eventType: 'create',
+      showTo: [ 'client', 'tango' ],
+    };
+    insertOpenSearchData( JSON.parse( process.env.OPENSEARCH )?.activityLog, logObj );
+    return res.sendSuccess( {
+      message: `Zone Tags Created Successfully`,
+      count: createdTagNames.length,
+    } );
+  } catch ( e ) {
+    console.log( 'uploadBulkZoneTags error :', e );
+    logger.error( { error: e, function: 'addBulkZoneCustomTag' } );
+    return res.sendError( 'Failed to upload zone-config file', 500 );
+  }
+};
+
+export const updateZoneCustomTag = async ( req, res ) => {
+  try {
+    const { clientId, tagName, oldTag, isExistingGroup, oldGroupName, groupName } = req.body;
+
+    if ( !clientId || !tagName ) {
+      return res.sendError( 'clientId, zoneName are required', 400 );
+    }
+
+    let findQuery = {};
+
+    // Escape regex special characters in tag names to avoid invalid regex patterns
+    const escapedTagName = tagName.replace( /[.*+?^${}()|[\]\\]/g, '\\$&' );
+    const escapedOldTag = oldTag ? oldTag.replace( /[.*+?^${}()|[\]\\]/g, '\\$&' ) : null;
+    if ( oldTag !== undefined && oldTag !== null && tagName !== oldTag ) {
+      findQuery = {
+        clientId,
+        tagName: { $regex: `^${escapedOldTag}$`, $options: 'i' },
+      };
+    } else {
+      findQuery = {
+        clientId,
+        tagName: { $regex: `^${escapedTagName}$`, $options: 'i' },
+      };
+    }
+    await externalService.updateMany( { zoneName: oldTag, clientId: req.body.clientId }, { zoneName: req.body.tagName } );
+    updateOldData( req, res );
+    let customZoneTagDetails = await customZoneTagService.findOne( findQuery );
+
+    if ( !customZoneTagDetails ) {
+      return res.sendError( 'No data found', 400 );
+    }
+
+    // Get the actual oldGroupName from the database record
+    const actualOldGroupName = customZoneTagDetails.groupName || null;
+    // Get the actual tag name currently in the database
+    const actualTagNameInDb = customZoneTagDetails.tagName;
+
+    // Validate that the new tagName does not already exist for this client (case-insensitive)
+    // Check if tagName is being changed (either via oldTag or if it's different from DB value)
+    const isTagNameChanging = ( oldTag && tagName.toLowerCase() !== oldTag.toLowerCase() ) || ( actualTagNameInDb && tagName.toLowerCase() !== actualTagNameInDb.toLowerCase() );
+
+    if ( isTagNameChanging ) {
+      const existingTagWithNewName = await customZoneTagService.findOne( {
+        clientId,
+        tagName: { $regex: `^${escapedTagName}$`, $options: 'i' },
+      } );
+
+      // If a tag with the new name exists and it's not the same record we're updating, return error
+      if ( existingTagWithNewName && existingTagWithNewName._id.toString() !== customZoneTagDetails._id.toString() ) {
+        return res.sendError( `zoneName "${tagName}" already exists for this client`, 409 );
+      }
+    }
+
+    let query = {
+      clientId,
+    };
+    let payload = { tagName };
+    if ( oldTag && tagName !== oldTag ) {
+      query.tagName = oldTag;
+    } else {
+      query.tagName = tagName;
+    }
+    if ( groupName ) {
+      payload.groupName = groupName || null;
+    } else {
+      payload.groupName = null;
+    }
+
+    // Determine the tag name to use for group operations
+    // Use the actual tag name from database for removing from old group
+    const tagNameForRemoval = actualTagNameInDb;
+    const newTagNameForGroup = tagName;
+
+    // Handle group changes: remove from old group and add to new group
+    // Compare actual old group name from DB with new group name (case-insensitive)
+    const oldGroupNameStr = actualOldGroupName ? String( actualOldGroupName ).trim().toLowerCase() : null;
+    const newGroupNameStr = groupName ? String( groupName ).trim().toLowerCase() : null;
+
+    if ( oldGroupNameStr !== newGroupNameStr ) {
+      // Remove tag from old group if oldGroupName exists
+      if ( actualOldGroupName ) {
+        // Escape regex special characters in actualOldGroupName
+        const escapedActualOldGroupName = actualOldGroupName.replace( /[.*+?^${}()|[\]\\]/g, '\\$&' );
+        const oldGroupDoc = await customzonegrouping.findOne(
+            { clientId, groupName: { $regex: `^${escapedActualOldGroupName}$`, $options: 'i' } },
+        );
+        if ( oldGroupDoc ) {
+          await customzonegrouping.updateOne(
+              { _id: oldGroupDoc._id },
+              { $pull: { zonesTagged: tagNameForRemoval } },
+          );
+        } else {
+        }
+      }
+
+      // Add tag to new group if groupName exists
+      if ( groupName ) {
+        // Escape regex special characters in groupName
+        const escapedGroupName = groupName.replace( /[.*+?^${}()|[\]\\]/g, '\\$&' );
+        let newGroupDoc = await customzonegrouping.findOne(
+            { clientId, groupName: { $regex: `^${escapedGroupName}$`, $options: 'i' } },
+        );
+
+        if ( !newGroupDoc && !isExistingGroup ) {
+          await customzonegrouping.create(
+              [ {
+                clientId,
+                groupName,
+                productName: req.body.productName,
+                zonesTagged: [ newTagNameForGroup ],
+              } ],
+          );
+        } else if ( newGroupDoc ) {
+          // Add to existing group
+          await customzonegrouping.updateOne(
+              { _id: newGroupDoc._id },
+              { $addToSet: { zonesTagged: newTagNameForGroup } },
+          );
+        }
+      }
+    } else if ( groupName && oldGroupNameStr === newGroupNameStr && oldTag && tagName !== oldTag ) {
+      // If groupName is same (and not null) but tagName changed, update the tagName in the group's zonesTagged
+      console.log( 'Group name same but tagName changed, updating group zonesTagged' );
+      // Escape regex special characters in groupName
+      const escapedGroupName = groupName.replace( /[.*+?^${}()|[\]\\]/g, '\\$&' );
+      const groupDoc = await customzonegrouping.findOne( { clientId, groupName: { $regex: `^${escapedGroupName}$`, $options: 'i' } } );
+      if ( groupDoc ) {
+        await customzonegrouping.updateOne(
+            { _id: groupDoc._id },
+            [
+              {
+                $set: {
+                  zonesTagged: {
+                    $setUnion: [
+                      {
+                        $filter: {
+                          input: '$zonesTagged',
+                          cond: { $ne: [ '$$this', actualTagNameInDb ] },
+                        },
+                      },
+                      [ tagName ],
+                    ],
+                  },
+                },
+              },
+            ],
+        );
+      }
+    }
+    // Update tagging collection if groupName changed or tagName changed (similar to addZoneCustomTag)
+    if ( oldTag && tagName !== oldTag ) {
+      // If tagName changed, update tagging collection records with oldTag to have new tagName and groupName
+      await taggingService.updateMany(
+          { clientId, tagName: oldTag },
+          { $set: { tagName, 'groupName': groupName || null, 'coordinates.$[].zoneName': tagName } },
+      );
+    } else if ( groupName !== oldGroupName ) {
+      // If only groupName changed, update tagging collection with new groupName
+      await taggingService.updateMany(
+          { clientId, tagName },
+          { $set: { 'groupName': groupName || null } },
+      );
+    }
+
+    let zonetag = await customZoneTagService.updateOne( query, { $set: payload } );
+    const logObj = {
+      clientId: req.body.clientId,
+      userName: req.user?.userName,
+      email: req.user?.email,
+      date: new Date(),
+      logType: 'zone',
+      logSubType: 'updateZoneCustomTag',
+      changes: [ `zoneName changed from ${oldTag} to ${tagName}` ],
+      eventType: 'update',
+      previous: {
+        tagName: oldTag,
+      },
+      current: {
+        tagName: tagName,
+      },
+      oldData: {
+        TagName: oldTag,
+      },
+      newData: {
+        TagName: tagName,
+      },
+      showTo: [ 'tango', 'client' ],
+    };
+    insertOpenSearchData( JSON.parse( process.env.OPENSEARCH )?.activityLog, logObj );
+    if ( zonetag.modifiedCount || zonetag.matchedCount ) {
+      logger.info( 'ZoneName Updated Successfully' );
+      res.sendSuccess( 'ZoneName Updated Successfully' );
+    } else {
+      logger.error( { error: 'something went wrong', function: 'updateZoneCustomTag' } );
+      return res.sendError( 'something went wrong', 500 );
+    }
+  } catch ( error ) {
+    logger.error( { error: error, function: 'updateZoneCustomTag' } );
+    return res.sendError( error, 500 );
+  }
+};
+
+export const deleteZoneCustomTag = async ( req, res ) => {
+  try {
+    const { clientId, tagName } = req.body;
+    if ( !clientId || !tagName ) {
+      return res.sendError( 'clientId and zoneName are required', 400 );
+    }
+
+    let zoneTagDetails = await customZoneTagService.findOne( { clientId, tagName } );
+    if ( !zoneTagDetails || zoneTagDetails?.length == 0 ) {
+      return res.sendError( 'No data found', 400 );
+    }
+    updateOldData( req, res );
+    await customZoneTagService.deleteOne( { clientId, tagName } );
+    await taggingService.deleteMany(
+        {
+          clientId,
+          tagName: { $in: tagName },
+        },
+    );
+    const logObj = {
+      clientId: req.body?.clientId,
+      userName: req.user?.userName,
+      email: req.user?.email,
+      date: new Date(),
+      logType: 'zone',
+      logSubType: 'deleteZoneCustomTag',
+      changes: [ `${tagName} zone tag` ],
+      eventType: 'delete',
+      showTo: [ 'client', 'tango' ],
+    };
+    insertOpenSearchData( JSON.parse( process.env.OPENSEARCH )?.activityLog, logObj );
+    // return res.sendSuccess( 'ZoneName Deleted Successfully' );
+  } catch ( e ) {
+    logger.error( { error: e, function: 'deleteZoneCustomTag' } );
+    return res.sendError( e, 500 );
+  }
+};
+
+
+// setting config - get zone grouping details
+export const getZoneGroupDetails = async ( req, res ) => {
+  try {
+    const {
+      clientId,
+      searchValue,
+      sortColumName,
+      sortBy,
+      limit,
+      offset = 1,
+      export: isExport,
+    } = req.body;
+
+    if ( !clientId ) {
+      return res.sendError( 'clientId is required', 400 );
+    }
+
+
+    let groupData = await customzonegrouping.findOne( { clientId: clientId } );
+    if ( !groupData ) {
+      return res.sendSuccess( { result: [] } );
+    }
+
+    const searchMatch = searchValue ?
+      { groupName: { $regex: searchValue, $options: 'i' } } :
+      null;
+
+    const pipeline = [
+      { $match: { clientId } },
+
+      {
+        $lookup: {
+          from: 'taggings',
+          let: { groupName: '$groupName' },
+          pipeline: [
+            {
+              $match: {
+                $expr: {
+                  $and: [
+                    { $eq: [ '$groupName', '$$groupName' ] },
+                    { $eq: [ '$clientId', clientId ] },
+                  ],
+                },
+              },
+            },
+          ],
+          as: 'tagsCount',
+        },
+      },
+
+      {
+        $lookup: {
+          from: 'customzonetags',
+          let: { groupName: '$groupName' },
+          pipeline: [
+            {
+              $match: {
+                $expr: {
+                  $and: [
+                    { $eq: [ '$groupName', '$$groupName' ] },
+                    { $eq: [ '$clientId', clientId ] },
+                  ],
+                },
+              },
+            },
+          ],
+          as: 'zonesTagged',
+        },
+      },
+
+      {
+        $project: {
+          clientId: 1,
+          groupName: 1,
+          zonesTagged: 1,
+          zonesCount: { $size: '$tagsCount' },
+          createdAt: 1,
+        },
+      },
+
+      {
+        $facet: {
+          totalCount: [
+            ...( searchMatch ? [ { $match: searchMatch } ] : [] ),
+            { $count: 'count' },
+          ],
+
+          data: [
+            ...( searchMatch ? [ { $match: searchMatch } ] : [] ),
+
+            ...( sortColumName && sortBy ?
+              [ { $sort: { [sortColumName]: sortBy } } ] :
+              [ { $sort: { createdAt: -1 } } ] ),
+
+            ...( isExport ?
+              [] :
+              limit ? [
+                { $skip: ( offset - 1 ) * limit },
+                { $limit: Number( limit ) },
+              ] : [] ),
+          ],
+        },
+      },
+    ];
+
+    const [ result ] = await customzonegrouping.aggregate( pipeline );
+
+    const zoneGroupList = result.data || [];
+
+    const totalCount = result.totalCount[0]?.count || 0;
+    if ( totalCount === 0 ) {
+      return res.sendError( 'No data', 204 );
+    }
+    // Get total count of zones for tabs (actual count, not filtered by search)
+    const totalZoneCount = await customZoneTagService.count( { clientId } );
+
+    if ( isExport && zoneGroupList.length ) {
+      const exportdata = zoneGroupList.map( ( element ) => ( {
+        'Zone Group Name': element.groupName || '--',
+        'Zones tagged': Array.isArray( element.zonesTagged ) ?
+          element.zonesTagged.map( ( zone ) => zone.tagName ).filter( Boolean ).
+              join( ', ' ) : '--',
+        'Zones tagged Count': element.zonesTagged.length || 0,
+      } ) );
+      await download( exportdata, res );
+      return;
+    }
+
+    return res.sendSuccess( {
+      result: zoneGroupList,
+      totalCount,
+      totalZoneCount,
+    } );
+  } catch ( e ) {
+    logger.error( { error: e, function: 'getZoneGroupDetails' } );
+    return res.sendError( e, 500 );
+  }
+  // try {
+  //   const inputData = req.body;
+  //   if ( !inputData.clientId ) {
+  //     return res.sendError( 'clientId is required', 400 );
+  //   }
+
+  //   let Query = [
+  //     {
+  //       $match: {
+  //         clientId: inputData.clientId,
+  //       },
+  //     },
+  //     {
+  //       $lookup: {
+  //         from: 'taggings',
+  //         let: { groupName: '$groupName' },
+  //         pipeline: [
+  //           {
+  //             $match: {
+  //               $expr: {
+  //                 $and: [
+  //                   {
+  //                     $eq: [ '$groupName', '$$groupName' ],
+  //                   },
+  //                   {
+  //                     $eq: [ '$clientId', inputData.clientId ],
+  //                   },
+  //                 ],
+  //               },
+  //             },
+  //           },
+  //         ], as: 'tagsCount',
+  //       },
+  //     },
+  //     {
+  //       $lookup: {
+  //         from: 'customzonetags',
+  //         let: { groupName: '$groupName' },
+  //         pipeline: [
+  //           {
+  //             $match: {
+  //               $expr: {
+  //                 $and: [
+  //                   {
+  //                     $eq: [ '$groupName', '$$groupName' ],
+  //                   },
+  //                   {
+  //                     $eq: [ '$clientId', inputData.clientId ],
+  //                   },
+  //                 ],
+  //               },
+  //             },
+  //           },
+  //         ], as: 'zonesTagged',
+  //       },
+  //     },
+  //     {
+  //       $project: {
+  //         clientId: 1,
+  //         groupName: 1,
+  //         zonesTagged: 1,
+  //         zonesCount: { $size: '$tagsCount' },
+  //       },
+  //     },
+  //   ];
+
+  //   if ( req.body.searchValue && req.body.searchValue !== '' ) {
+  //     Query.push( {
+  //       $match: {
+  //         $or: [
+  //           { groupName: { $regex: req.body.searchValue, $options: 'i' } },
+  //         ],
+  //       },
+  //     } );
+  //   }
+
+  //   if ( req.body.sortColumName && req.body.sortColumName !== '' && req.body.sortBy ) {
+  //     Query.push( {
+  //       $sort: { [req.body.sortColumName]: req.body.sortBy },
+  //     } );
+  //   } else {
+  //     // Default sort by createdAt descending if no sort specified
+  //     Query.push( {
+  //       $sort: { createdAt: -1 },
+  //     } );
+  //   }
+
+  //   // Get total count before pagination
+  //   const countQuery = [ ...Query ];
+  //   const totalCountResult = await customzonegrouping.aggregate( [
+  //     ...countQuery,
+  //     { $count: 'total' },
+  //   ] );
+  //   console.log( '🚀 ~ getZoneGroupDetails ~ totalCountResult:', totalCountResult );
+  //   const totalCount = totalCountResult.length > 0 ? totalCountResult[0].total : 0;
+
+  //   if ( req.body.limit && req.body.offset && !req.body.export ) {
+  //     Query.push(
+  //         { $skip: ( req.body.offset - 1 ) * req.body.limit },
+  //         { $limit: Number( req.body.limit ) },
+  //     );
+  //   }
+
+  //   const zoneGroupList = await customzonegrouping.aggregate( Query );
+
+  //   if ( req.body.export && zoneGroupList.length > 0 ) {
+  //     const exportdata = [];
+  //     zoneGroupList.forEach( ( element ) => {
+  //       const data = {
+  //         'Zone Group Name': element.groupName || '--',
+  //         'Zones tagged': Array.isArray( element.zonesTagged ) ? element.zonesTagged.join( ', ' ) : '--',
+  //         'Zones tagged Count': element.zonesCount || 0,
+  //         // 'Stores Tagged Count': element.storesTaggedCount || 0,
+  //       };
+  //       exportdata.push( data );
+  //     } );
+  //     await download( exportdata, res );
+  //     return;
+  //   }
+
+  //   return res.sendSuccess( {
+  //     result: zoneGroupList,
+  //     count: totalCount,
+  //   } );
+  // } catch ( e ) {
+  //   logger.error( { error: e, function: 'getZoneGroupDetails' } );
+  //   console.error( 'getZoneGroupDetails error:', e );
+  //   return res.sendError( e, 500 );
+  // }
+};
+
+export const addZoneGroup = async ( req, res ) => {
+  try {
+    const { clientId, groupName, zonesTagged = [], productName = '' } = req.body;
+
+    if ( !clientId || !groupName ) {
+      return res.sendError( 'clientId and groupName are required', 400 );
+    }
+
+    // Escape regex special characters in groupName to avoid invalid regex patterns
+    const escapedGroupName = groupName.replace( /[.*+?^${}()|[\]\\]/g, '\\$&' );
+
+    // Case-insensitive check for existing group
+    const existingGroup = await customzonegrouping.findOne( {
+      clientId,
+      groupName: { $regex: `^${escapedGroupName}$`, $options: 'i' },
+    } );
+
+    if ( existingGroup ) {
+      return res.sendError( `groupName "${groupName}" already exists for this client`, 409 );
+    }
+
+    const payload = {
+      clientId,
+      groupName,
+      zonesTagged: Array.isArray( zonesTagged ) ? zonesTagged : [],
+      productName,
+    };
+
+    await customzonegrouping.create( payload );
+
+    // Update groupName for all zone tags in zonesTagged array
+    if ( Array.isArray( zonesTagged ) && zonesTagged.length > 0 ) {
+      // Update all tags that are in the zonesTagged array to have this groupName
+      await customZoneTagService.updateMany(
+          {
+            clientId,
+            tagName: { $in: zonesTagged },
+          },
+          { $set: { groupName } },
+      );
+      await taggingService.updateMany(
+          {
+            clientId,
+            tagName: { $in: zonesTagged },
+          },
+          { $set: { groupName } },
+      );
+    }
+
+    logger.info( 'Zone Group Created Successfully' );
+
+    const logObj = {
+      clientId,
+      userName: req.user?.userName,
+      email: req.user?.email,
+      date: new Date(),
+      logType: 'zone',
+      logSubType: 'addZoneGroup',
+      changes: [ `${groupName} zone group` ],
+      eventType: 'create',
+      showTo: [ 'client', 'tango' ],
+    };
+
+    insertOpenSearchData( JSON.parse( process.env.OPENSEARCH )?.activityLog, logObj );
+    return res.sendSuccess( 'Zone Group Created Successfully' );
+  } catch ( e ) {
+    // Duplicate key error from unique index
+    if ( e.code === 11000 ) {
+      return res.sendError( `groupName "${req.body.groupName}" already exists for this client`, 409 );
+    }
+
+    logger.error( { error: e, function: 'addZoneGroup' } );
+    return res.sendError( e.message || 'Internal Server Error', 500 );
+  }
+};
+
+export const updateZoneGroup = async ( req, res ) => {
+  try {
+    const { _id, clientId, groupName, productName, zonesTagged = [] } = req.body;
+
+    if ( !clientId || !groupName ) {
+      return res.sendError( 'clientId and groupName are required', 400 );
+    }
+
+    let findGroup = await customzonegrouping.findOne( { _id: _id } );
+
+    // Escape regex special characters in groupName to avoid invalid regex patterns
+    const escapedGroupName = groupName.replace( /[.*+?^${}()|[\]\\]/g, '\\$&' );
+
+    // Case-insensitive check for existing group (excluding current group)
+    const existingGroup = await customzonegrouping.findOne( {
+      clientId: clientId,
+      groupName: { $regex: `^${escapedGroupName}$`, $options: 'i' },
+      _id: { $ne: _id },
+    } );
+    if ( existingGroup && existingGroup.groupName ) {
+      return res.sendError( `groupName "${groupName}" already exists for this client`, 409 );
+    }
+
+    if ( findGroup ) {
+      let removedTags = findGroup.zonesTagged.filter( ( zone ) => !zonesTagged.includes( zone ) ); ;
+      if ( removedTags && removedTags.length > 0 ) {
+        let updateQuery = { clientId, tagName: { $in: removedTags } };
+        await customZoneTagService.updateMany( updateQuery, { $set: { groupName: null } } );
+        await taggingService.updateMany( updateQuery, { $set: { groupName: null } } );
+      }
+    }
+
+
+    await customzonegrouping.updateOne( { _id: _id }, { groupName: groupName, zonesTagged: zonesTagged } );
+    let updateQuery = { clientId, tagName: { $in: zonesTagged } };
+    await customZoneTagService.updateMany( updateQuery, { $set: { groupName } } );
+    await taggingService.updateMany( updateQuery, { $set: { groupName } } );
+
+
+    const logObj = {
+      clientId: clientId,
+      userName: req.user?.userName,
+      email: req.user?.email,
+      date: new Date(),
+      logType: 'zone',
+      logSubType: 'updateZoneGroup',
+      changes: [ `zone group updated from "${findGroup.groupName || groupName}" to "${groupName}"` ],
+      eventType: 'update',
+      previous: {
+        groupName: findGroup.groupName || groupName,
+        productName: findGroup.productName,
+        zonesTagged: findGroup.zonesTagged,
+      },
+      current: {
+        groupName: groupName,
+        productName: productName,
+        zonesTagged: zonesTagged,
+      },
+      oldData: {
+        GroupName: findGroup.groupName || groupName,
+      },
+      newData: {
+        GroupName: groupName,
+      },
+      showTo: [ 'client', 'tango' ],
+    };
+
+    insertOpenSearchData( JSON.parse( process.env.OPENSEARCH )?.activityLog, logObj );
+
+    return res.sendSuccess( 'Zone Group Updated Successfully' );
+  } catch ( e ) {
+    // Duplicate key error from unique index
+    if ( e.code === 11000 ) {
+      return res.sendError( `groupName "${req.body.groupName}" already exists for this client`, 409 );
+    }
+
+    logger.error( { error: e, function: 'updateZoneGroup' } );
+    return res.sendError( e.message || 'Internal Server Error', 500 );
+  }
+};
+
+export const uploadBulkZoneGroup = async ( req, res ) => {
+  try {
+    const groupsArray = req.body;
+    const clientId = req.bulkZoneClientId;
+
+    if ( !groupsArray || !Array.isArray( groupsArray ) || groupsArray.length === 0 ) {
+      return res.sendError( 'group-config file must not be empty', 400 );
+    }
+
+    if ( !clientId ) {
+      return res.sendError( 'clientId is required', 400 );
+    }
+
+    const zoneGroupDataList = [];
+    const createdGroupNames = [];
+
+    // Process each group in the array
+    for ( const group of groupsArray ) {
+      if ( !group.groupName || group.groupName === '' ) {
+        continue; // Skip groups without groupName
+      }
+
+      const zoneGroupData = {
+        clientId: clientId,
+        groupName: group.groupName,
+        productName: group.productName,
+      };
+      zoneGroupDataList.push( zoneGroupData );
+      createdGroupNames.push( group.groupName );
+    }
+
+    // Create all zone groups
+    if ( zoneGroupDataList.length > 0 ) {
+      await customzonegrouping.create( zoneGroupDataList );
+    }
+
+    logger.info( `Bulk Zone Groups Created Successfully: ${createdGroupNames.length} groups` );
+    const logObj = {
+      clientId: clientId,
+      userName: req.user?.userName,
+      email: req.user?.email,
+      date: new Date(),
+      logType: 'zone',
+      logSubType: 'addBulkZoneGroup',
+      changes: createdGroupNames.map( ( groupName ) => `${groupName} zone group` ),
+      eventType: 'create',
+      showTo: [ 'client', 'tango' ],
+    };
+    insertOpenSearchData( JSON.parse( process.env.OPENSEARCH )?.activityLog, logObj );
+    return res.sendSuccess( {
+      message: `Zone Groups Created Successfully`,
+      count: createdGroupNames.length,
+    } );
+  } catch ( e ) {
+    logger.error( { error: e, function: 'uploadBulkZoneGroup' } );
+    return res.sendError( 'Failed to upload group-config file', 500 );
+  }
+};
+
+export const deleteZoneGroup = async ( req, res ) => {
+  try {
+    let zoneGroupDetails = await customzonegrouping.findOne( { _id: req.body._id, clientId: req.body.clientId, groupName: req.body.groupName } );
+    if ( !zoneGroupDetails || zoneGroupDetails?.length == 0 ) {
+      return res.sendError( 'no data found', 204 );
+    }
+
+    // Remove this group mapping from all custom zone tags (zones) that are linked to it
+    await customZoneTagService.updateMany(
+        {
+          clientId: req.body.clientId,
+          groupName: req.body.groupName,
+        },
+        { $set: { groupName: null } },
+    );
+    await taggingService.updateMany(
+        {
+          clientId: req.body.clientId,
+          groupName: req.body.groupName,
+        },
+        { $set: { groupName: null } },
+    );
+    await customzonegrouping.deleteOne( { _id: req.body._id, clientId: req.body.clientId, groupName: req.body.groupName } );
+
+    const logObj = {
+      clientId: req.body?.clientId,
+      userName: req.user?.userName,
+      email: req.user?.email,
+      date: new Date(),
+      logType: 'zone',
+      logSubType: 'deleteZoneGroup',
+      changes: [ `${req.body.groupName} zone group` ],
+      eventType: 'delete',
+      showTo: [ 'client', 'tango' ],
+    };
+    insertOpenSearchData( JSON.parse( process.env.OPENSEARCH )?.activityLog, logObj );
+    // await updatezoneTagging( req, res );
+    return res.sendSuccess( 'Zone Group Deleted Successfully' );
+  } catch ( e ) {
+    logger.error( { error: e, function: 'deleteZoneGroup' } );
+    return res.sendError( e, 500 );
+  }
+};
+
+export async function oldTagsMigration() {
+  let uniqueTags = await taggingService.find( { productName: 'tangoZone', clientId: '440' } );
+  const result = _.uniqBy( uniqueTags, 'tagName' );
+
+
+  for ( let zone of result ) {
+    let obj = {
+      clientId: zone.clientId,
+      tagName: zone.tagName,
+      productName: zone.productName,
+      rgbColor: zone.rgbColor,
+      rgbBorderColor: zone.rgbBorderColor,
+      groupName: null,
+    };
+    await customZoneTagService.create( [ obj ] );
+  }
+}
+