tango-app-api-store-zone 3.3.1-beta.19 → 3.3.1-beta.20

package/src/controllers/zoneTagging.controller.js

@@ -1,17 +1,21 @@
 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,
@@ -20,6 +24,7 @@ export const addCustomTag = async ( req, res ) => {
         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 );
@@ -193,7 +198,6 @@ export const customTagListv2 = async ( req, res ) => {
           { streamName: 1 },
       ),
     ] );
-    console.log( req.query.clientId, camList.length );
 
     // Step 3: Add conditional tags
     if ( clientDetails?.featureConfigs?.isExcludedArea ) {
@@ -214,7 +218,7 @@ export const customTagListv2 = async ( req, res ) => {
     // 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 },
+        { tagName: 1, rgbColor: 1, rgbBorderColor: 1, productName: 1, groupName: 1 },
     );
 
     // Merge all tags
@@ -226,7 +230,6 @@ export const customTagListv2 = async ( req, res ) => {
     // Step 6: Query counts per tag
     const tagNames = uniqueTags.map( ( t ) => t.tagName );
     let activeCam = camList.map( ( data ) => data.streamName );
-    console.log( '🚀 ~ customTagListv2 ~ activeCam:', activeCam );
     const taggingDetails = await taggingService.aggregate( [
       {
         $match: {
@@ -255,18 +258,340 @@ export const customTagListv2 = async ( req, res ) => {
       '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)
-    finalTags.sort( ( a, b ) => b.count - a.count );
+    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,
+          },
+        },
+
+        // 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' } },
+      ] );
+
+
+      console.log( '🚀 ~ customTagListv3 ~ taggingDetails:', zonefinalTags );
+      return res.sendSuccess( zonefinalTags );
+    }
+
+
     if ( req.query.selectedProduct && req.query.selectedProduct === 'tangoTrax' ) {
       let Query = [ {
         $match: {
@@ -337,7 +662,6 @@ export const customTagListv2 = async ( req, res ) => {
 
       ];
       let getChecklistData = await checklistconfigService.aggregate( Query );
-      console.log( getChecklistData, finalTags );
       if ( finalTags && finalTags.length > 0 ) {
         let merged = getChecklistData.map( ( item ) => {
           let match = finalTags.find( ( a ) => a.tagName === item.tagName );
@@ -346,7 +670,6 @@ export const customTagListv2 = async ( req, res ) => {
           }
           return item;
         } );
-        console.log( merged );
         // also include any arr1 items not in arr2
         finalTags.forEach( ( a ) => {
           if ( !merged.find( ( m ) => m.tagName === a.tagName ) ) {
@@ -525,20 +848,6 @@ export const tagging = async ( req, res ) => {
 
       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' } );
@@ -1090,11 +1399,13 @@ export const getCameraStreamList = async ( req, res ) => {
     if ( !cameraDetails.length ) {
       return res.sendError( 'no data found', 204 );
     }
-    const folderPath = { file_path: `${req.body.storeId}/zone_base_images/`,
+    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/`,
+    const TaggedfolderPath = {
+      file_path: `${req.body.storeId}/zone_tagged_image/`,
       Bucket: JSON.parse( process.env.BUCKET ).zoneTaggingImage, MaxKeys: 1000,
     };
     let tagFileList = await listFileByPath( TaggedfolderPath );
@@ -1120,7 +1431,7 @@ export const getCameraStreamList = 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.body.storeId}_${camera.streamName}` ) {
               tagPath = item.Key;
@@ -1131,21 +1442,23 @@ export const getCameraStreamList = 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.body.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 );
@@ -1161,3 +1474,1114 @@ export const getCameraStreamList = async ( req, res ) => {
     return res.sendError( e, 500 );
   }
 };
+
+
+// setting config - zone - get tagging details
+export const getZoneTaggingDetails = async ( req, res ) => {
+  try {
+    const {
+      clientId,
+      searchValue,
+      sortColumName,
+      sortBy,
+      limit = 10,
+      offset = 1,
+      export: isExport,
+    } = req.body;
+
+    if ( !clientId ) {
+      return res.sendError( 'clientId is required', 400 );
+    }
+
+    const matchStage = {
+      clientId,
+    };
+
+    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 ] },
+                  ],
+                },
+              },
+            },
+          ],
+          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 ?
+              [] :
+              [
+                { $skip: ( offset - 1 ) * limit },
+                { $limit: Number( limit ) },
+              ] ),
+          ],
+        },
+      },
+    ];
+
+    const [ result ] = await customZoneTagService.aggregate( pipeline );
+
+    const totalCount = result.totalCount[0]?.count || 0;
+    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 tagName are required', 400 );
+    }
+
+    const existingTag = await customZoneTagService.findOne(
+        { clientId, tagName, _id: { $ne: _id } },
+    );
+
+    if ( existingTag ) {
+      return res.sendError( `tagName "${tagName}" already exists for this client`, 409 );
+    }
+
+    let groupDoc = null;
+    if ( groupName ) {
+      groupDoc = await customzonegrouping.findOne( { clientId, groupName } );
+    }
+
+    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 = [];
+
+    // Process each zone in the array
+    for ( const zone of zonesArray ) {
+      const zoneTagData = {
+        clientId: clientId,
+        tagName: zone.tagName,
+        rgbColor: zone.rgbColor,
+        rgbBorderColor: zone.rgbBorderColor,
+        groupName: zone.groupName && zone.groupName !== '' ? zone.groupName : null,
+        productName: zone.productName,
+      };
+      zoneTagDataList.push( zoneTagData );
+      createdTagNames.push( zone.tagName );
+
+      // Prepare zone group data if groupName is provided
+      if ( zone.groupName && zone.groupName !== '' && zone.groupName !== null ) {
+        if ( !zoneGroupDataMap.has( zone.groupName ) ) {
+          zoneGroupDataMap.set( zone.groupName, {
+            clientId: clientId,
+            groupName: zone.groupName,
+            productName: zone.productName,
+          } );
+        }
+      }
+    }
+
+    // Create all zone tags
+    await customZoneTagService.create( zoneTagDataList );
+
+    // Create zone groups (convert Map values to array)
+    const zoneGroupDataList = Array.from( zoneGroupDataMap.values() );
+    if ( zoneGroupDataList.length > 0 ) {
+      for ( const groupData of zoneGroupDataList ) {
+        await customzonegrouping.create( groupData );
+      }
+    }
+
+    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 ) {
+    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, tagName are required', 400 );
+    }
+
+    let findQuery = {};
+    if ( oldTag !== undefined && oldTag !== null && tagName !== oldTag ) {
+      findQuery = {
+        clientId,
+        tagName: oldTag,
+      };
+    } else {
+      findQuery = {
+        clientId,
+        tagName,
+      };
+    }
+
+    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
+    // Check if tagName is being changed (either via oldTag or if it's different from DB value)
+    const isTagNameChanging = ( oldTag && tagName !== oldTag ) || ( actualTagNameInDb && tagName !== actualTagNameInDb );
+
+    if ( isTagNameChanging ) {
+      const existingTagWithNewName = await customZoneTagService.findOne( {
+        clientId,
+        tagName,
+      } );
+
+      // 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( `tagName "${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
+    const oldGroupNameStr = actualOldGroupName ? String( actualOldGroupName ).trim() : null;
+    const newGroupNameStr = groupName ? String( groupName ).trim() : null;
+
+    if ( oldGroupNameStr !== newGroupNameStr ) {
+      // Remove tag from old group if oldGroupName exists
+      if ( actualOldGroupName ) {
+        const oldGroupDoc = await customzonegrouping.findOne(
+            { clientId, groupName: actualOldGroupName },
+        );
+        if ( oldGroupDoc ) {
+          await customzonegrouping.updateOne(
+              { _id: oldGroupDoc._id },
+              { $pull: { zonesTagged: tagNameForRemoval } },
+          );
+        } else {
+        }
+      }
+
+      // Add tag to new group if groupName exists
+      if ( groupName ) {
+        let newGroupDoc = await customzonegrouping.findOne(
+            { clientId, groupName },
+        );
+
+        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
+      const groupDoc = await customzonegrouping.findOne( { clientId, groupName } );
+      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 } },
+      );
+    } 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: [ `tagName 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( 'Zone Tag Updated Successfully' );
+      res.sendSuccess( 'Zone Tag 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 tagName are required', 400 );
+    }
+
+    let zoneTagDetails = await customZoneTagService.findOne( { clientId, tagName } );
+    if ( !zoneTagDetails || zoneTagDetails?.length == 0 ) {
+      return res.sendError( 'No data found', 400 );
+    }
+
+    await customZoneTagService.deleteOne( { clientId, 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( 'Zone Tag 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 = 10,
+      offset = 1,
+      export: isExport,
+    } = req.body;
+
+    if ( !clientId ) {
+      return res.sendError( 'clientId is required', 400 );
+    }
+
+    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 ?
+              [] :
+              [
+                { $skip: ( offset - 1 ) * limit },
+                { $limit: Number( limit ) },
+              ] ),
+          ],
+        },
+      },
+    ];
+
+    const [ result ] = await customzonegrouping.aggregate( pipeline );
+
+    const zoneGroupList = result.data || [];
+
+    const totalCount = result.totalCount[0]?.count || 0;
+
+    // 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.zonesCount || 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 );
+    }
+
+    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 } );
+    const existingGroup = await customzonegrouping.findOne( {
+      clientId: clientId,
+      groupName: groupName,
+      _id: { $ne: _id },
+    } );
+    if ( existingGroup && existingGroup.groupName ) {
+      return res.sendError( `groupName "${existingGroup.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' } );
+  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 ] );
+  }
+}
+