tango-app-api-store-zone 3.3.1-beta.24 → 3.3.1-beta.26

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-store-zone",
-    "version": "3.3.1-beta.24",
+    "version": "3.3.1-beta.26",
     "description": "zone",
     "main": "index.js",
     "type": "module",

package/src/controllers/zoneTagging.controller.js

@@ -1307,6 +1307,7 @@ export const updateOldData = async ( req, res ) => {
       for ( let [ index, item ] of tagDetails.entries() ) {
         req.body.storeId = item.storeId;
         let camDetails = await getCamTaggingDetails( req, res );
+        console.log( '🚀 ~ updateOldData ~ camDetails:', camDetails );
         if ( camDetails ) {
           const response = await axios.post( JSON.parse( process.env.URL ).zoneTaggingLamdaUrl, camDetails );
 
@@ -1332,6 +1333,8 @@ export const updateOldData = async ( req, res ) => {
           }
         }
       }
+    } else {
+      res.sendSuccess( 'Zone Updated Successfully' );
     }
   } catch ( e ) {
     console.log( '🚀 ~ updateOldData ~ e:', e );
@@ -1802,33 +1805,61 @@ export const uploadBulkZoneTag = async ( req, res ) => {
     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 ) {
+      // Case-insensitive check for existing group
+      const existingGroupDoc = await customzonegrouping.findOne( {
+        clientId,
+        groupName: { $regex: `^${userGroupName}$`, $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: zone.groupName && zone.groupName !== '' ? zone.groupName : null,
+        groupName: normalizedGroupName,
         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, {
+      if ( normalizedGroupName ) {
+        // Use normalized groupName (existing case or user case)
+        if ( !zoneGroupDataMap.has( normalizedGroupName ) ) {
+          zoneGroupDataMap.set( normalizedGroupName, {
             clientId: clientId,
-            groupName: zone.groupName,
+            groupName: normalizedGroupName,
             productName: zone.productName,
             zonesTagged: new Set(),
           } );
         }
 
         // Collect all tagNames for this group so that we can append them
-        const groupEntry = zoneGroupDataMap.get( zone.groupName );
+        const groupEntry = zoneGroupDataMap.get( normalizedGroupName );
         groupEntry.zonesTagged.add( zone.tagName );
       }
     }
@@ -1880,11 +1911,13 @@ export const uploadBulkZoneTag = async ( req, res ) => {
     }
 
     // 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: zone.groupName } },
+            { $set: { groupName: normalizedGroupName } },
         );
       }
     }
@@ -2265,7 +2298,7 @@ export const getZoneGroupDetails = async ( req, res ) => {
         'Zones tagged': Array.isArray( element.zonesTagged ) ?
           element.zonesTagged.map( ( zone ) => zone.tagName ).filter( Boolean ).
               join( ', ' ) : '--',
-        'Zones tagged Count': element.zonesCount || 0,
+        'Zones tagged Count': element.zonesTagged.length || 0,
       } ) );
       await download( exportdata, res );
       return;

package/src/validations/zone.validations.js

@@ -24,7 +24,7 @@ export async function bulkZoneExists( req, res, next ) {
     }
     const clientId = uniqueClientIds[0];
 
-    // Check for duplicate tagNames within the request (case-insensitive)
+    // Check for duplicate tagNames within the request
     const tagNameList = zonesArray.map( ( zone ) => zone.tagName );
     const tagNameListLower = tagNameList.map( ( name ) => name.toLowerCase() );
     const uniqueTagNamesLower = [ ...new Set( tagNameListLower ) ];
@@ -32,8 +32,7 @@ export async function bulkZoneExists( req, res, next ) {
       return res.sendError( `Duplicate zone name found in request.`, 400 );
     }
 
-    // Check if any tagNames already exist in the database for this client (case-insensitive)
-    // Fetch all existing tags for this client and compare case-insensitively
+    // Fetch all existing tags for this client and compare
     const existingZones = await customZoneTagService.find( {
       clientId: clientId,
     } );
@@ -46,66 +45,6 @@ export async function bulkZoneExists( req, res, next ) {
       }
     }
 
-    // Check for duplicate groupNames within the request (case-insensitive, if provided)
-    // const groupNameList = zonesArray
-    //     .filter( ( zone ) => zone.groupName && zone.groupName !== '' && zone.groupName !== null )
-    //     .map( ( zone ) => zone.groupName );
-
-    // if ( groupNameList.length > 0 ) {
-    //   const groupNameListLower = groupNameList.map( ( name ) => name.toLowerCase() );
-    //   const uniqueGroupNamesLower = [ ...new Set( groupNameListLower ) ];
-    //   if ( uniqueGroupNamesLower.length !== groupNameListLower.length ) {
-    //     return res.sendError( `Duplicate group names found in request.`, 400 );
-    //   }
-
-    //   // Check if any groupNames already exist in the database for this client (case-insensitive)
-    //   // Fetch all existing groups for this client and compare case-insensitively
-    //   const existingGroups = await customzonegrouping.find( {
-    //     clientId: clientId,
-    //   } );
-
-    //   if ( existingGroups && existingGroups.length > 0 ) {
-    //     const existingGroupNamesLower = existingGroups.map( ( group ) => group.groupName?.toLowerCase() ).filter( Boolean );
-    //     const hasDuplicate = groupNameListLower.some( ( groupNameLower ) => existingGroupNamesLower.includes( groupNameLower ) );
-    //     if ( hasDuplicate ) {
-    //       return res.sendError( `Group names already exist for this client.`, 409 );
-    //     }
-    //   }
-    // }
-
-    // Validate groupNames for case-insensitive duplicates
-    const groupNameList = zonesArray
-        .filter( ( zone ) => zone.groupName && zone.groupName !== '' && zone.groupName !== null )
-        .map( ( zone ) => zone.groupName );
-
-    if ( groupNameList.length > 0 ) {
-      // Group groupNames by their lowercase version
-      const groupNameMap = new Map();
-      groupNameList.forEach( ( name ) => {
-        const lowerName = name.toLowerCase();
-        if ( !groupNameMap.has( lowerName ) ) {
-          groupNameMap.set( lowerName, new Set() );
-        }
-        groupNameMap.get( lowerName ).add( name );
-      } );
-
-      // Check if any lowercase name has multiple different cases
-      const caseMismatches = [];
-      groupNameMap.forEach( ( originalNames, lowerName ) => {
-        if ( originalNames.size > 1 ) {
-          // Same lowercase name appears with different cases
-          caseMismatches.push( {
-            lowerName: lowerName,
-            cases: Array.from( originalNames ),
-          } );
-        }
-      } );
-
-      if ( caseMismatches.length > 0 ) {
-        return res.sendError( 'Duplicate group names with different cases are not allowed.', 400 );
-      }
-    }
-
     // Attach clientId to req for use in controller
     req.bulkZoneClientId = clientId;
     next();