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

package/package.json

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

package/src/controllers/zoneTagging.controller.js

@@ -544,6 +544,11 @@ export const customTagListv3 = async ( req, res ) => {
             count: 1,
           },
         },
+        {
+          $sort: {
+            count: -1,
+          },
+        },
 
         // Split grouped vs ungrouped
         {
@@ -1508,7 +1513,6 @@ export const getZoneTaggingDetails = async ( req, res ) => {
 
     const pipeline = [
       { $match: matchStage },
-
       {
         $lookup: {
           from: 'taggings',
@@ -1520,15 +1524,21 @@ export const getZoneTaggingDetails = async ( req, res ) => {
                   $and: [
                     { $eq: [ '$tagName', '$$tagName' ] },
                     { $eq: [ '$clientId', clientId ] },
+                    { $ne: [ '$coordinates', [] ] },
                   ],
                 },
               },
             },
+            {
+              $group: {
+                _id: '$storeId',
+                count: { $sum: 1 },
+              },
+            },
           ],
           as: 'tagsCount',
         },
       },
-
       {
         $project: {
           clientId: 1,
@@ -1537,7 +1547,6 @@ export const getZoneTaggingDetails = async ( req, res ) => {
           storesTaggedCount: { $size: '$tagsCount' },
         },
       },
-
       {
         $facet: {
           totalCount: [
@@ -1692,20 +1701,22 @@ export const addZoneCustomTag = async ( req, res ) => {
     } = req.body;
 
     if ( !clientId || !tagName ) {
-      return res.sendError( 'clientId and tagName are required', 400 );
+      return res.sendError( 'clientId and zoneName are required', 400 );
     }
 
+    // Case-insensitive check for existing tag
     const existingTag = await customZoneTagService.findOne(
-        { clientId, tagName, _id: { $ne: _id } },
+        { clientId, tagName: { $regex: `^${tagName}$`, $options: 'i' }, _id: { $ne: _id } },
     );
 
     if ( existingTag ) {
-      return res.sendError( `tagName "${tagName}" already exists for this client`, 409 );
+      return res.sendError( `zoneName "${tagName}" already exists for this client`, 409 );
     }
 
     let groupDoc = null;
     if ( groupName ) {
-      groupDoc = await customzonegrouping.findOne( { clientId, groupName } );
+      // Case-insensitive check for existing group
+      groupDoc = await customzonegrouping.findOne( { clientId, groupName: { $regex: `^${groupName}$`, $options: 'i' } } );
     }
 
     if ( !isExistingGroup && groupDoc ) {
@@ -1803,8 +1814,13 @@ export const uploadBulkZoneTag = async ( req, res ) => {
             clientId: clientId,
             groupName: zone.groupName,
             productName: zone.productName,
+            zonesTagged: new Set(),
           } );
         }
+
+        // Collect all tagNames for this group so that we can append them
+        const groupEntry = zoneGroupDataMap.get( zone.groupName );
+        groupEntry.zonesTagged.add( zone.tagName );
       }
     }
 
@@ -1812,13 +1828,59 @@ export const uploadBulkZoneTag = async ( req, res ) => {
     await customZoneTagService.create( zoneTagDataList );
 
     // Create zone groups (convert Map values to array)
-    const zoneGroupDataList = Array.from( zoneGroupDataMap.values() );
+    // 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 ) {
-        await customzonegrouping.create( groupData );
+        // Case-insensitive check for existing group (same as addZoneCustomTag)
+        const groupDoc = await customzonegrouping.findOne( {
+          clientId,
+          groupName: { $regex: `^${groupData.groupName}$`, $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
+    for ( const zone of zonesArray ) {
+      if ( zone.groupName && zone.groupName !== '' && zone.groupName !== null ) {
+        await taggingService.updateMany(
+            { clientId, tagName: zone.tagName },
+            { $set: { groupName: zone.groupName } },
+        );
+      }
+    }
+
+
     logger.info( `Bulk Zone Tags Created Successfully: ${createdTagNames.length} tags` );
     const logObj = {
       clientId: clientId,
@@ -1847,19 +1909,19 @@ export const updateZoneCustomTag = async ( req, res ) => {
     const { clientId, tagName, oldTag, isExistingGroup, oldGroupName, groupName } = req.body;
 
     if ( !clientId || !tagName ) {
-      return res.sendError( 'clientId, tagName are required', 400 );
+      return res.sendError( 'clientId, zoneName are required', 400 );
     }
 
     let findQuery = {};
     if ( oldTag !== undefined && oldTag !== null && tagName !== oldTag ) {
       findQuery = {
         clientId,
-        tagName: oldTag,
+        tagName: { $regex: `^${oldTag}$`, $options: 'i' },
       };
     } else {
       findQuery = {
         clientId,
-        tagName,
+        tagName: { $regex: `^${tagName}$`, $options: 'i' },
       };
     }
 
@@ -1874,19 +1936,19 @@ export const updateZoneCustomTag = async ( req, res ) => {
     // 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
+    // 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 !== oldTag ) || ( actualTagNameInDb && tagName !== actualTagNameInDb );
+    const isTagNameChanging = ( oldTag && tagName.toLowerCase() !== oldTag.toLowerCase() ) || ( actualTagNameInDb && tagName.toLowerCase() !== actualTagNameInDb.toLowerCase() );
 
     if ( isTagNameChanging ) {
       const existingTagWithNewName = await customZoneTagService.findOne( {
         clientId,
-        tagName,
+        tagName: { $regex: `^${tagName}$`, $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( `tagName "${tagName}" already exists for this client`, 409 );
+        return res.sendError( `zoneName "${tagName}" already exists for this client`, 409 );
       }
     }
 
@@ -1911,15 +1973,15 @@ export const updateZoneCustomTag = async ( req, res ) => {
     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;
+    // 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 ) {
         const oldGroupDoc = await customzonegrouping.findOne(
-            { clientId, groupName: actualOldGroupName },
+            { clientId, groupName: { $regex: `^${actualOldGroupName}$`, $options: 'i' } },
         );
         if ( oldGroupDoc ) {
           await customzonegrouping.updateOne(
@@ -1933,7 +1995,7 @@ export const updateZoneCustomTag = async ( req, res ) => {
       // Add tag to new group if groupName exists
       if ( groupName ) {
         let newGroupDoc = await customzonegrouping.findOne(
-            { clientId, groupName },
+            { clientId, groupName: { $regex: `^${groupName}$`, $options: 'i' } },
         );
 
         if ( !newGroupDoc && !isExistingGroup ) {
@@ -1955,7 +2017,8 @@ export const updateZoneCustomTag = async ( req, res ) => {
       }
     } 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 } );
+      console.log( 'Group name same but tagName changed, updating group zonesTagged' );
+      const groupDoc = await customzonegrouping.findOne( { clientId, groupName: { $regex: `^${groupName}$`, $options: 'i' } } );
       if ( groupDoc ) {
         await customzonegrouping.updateOne(
             { _id: groupDoc._id },
@@ -2002,7 +2065,7 @@ export const updateZoneCustomTag = async ( req, res ) => {
       date: new Date(),
       logType: 'zone',
       logSubType: 'updateZoneCustomTag',
-      changes: [ `tagName changed from ${oldTag} to ${tagName}` ],
+      changes: [ `zoneName changed from ${oldTag} to ${tagName}` ],
       eventType: 'update',
       previous: {
         tagName: oldTag,
@@ -2020,8 +2083,8 @@ export const updateZoneCustomTag = async ( req, res ) => {
     };
     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' );
+      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 );
@@ -2036,7 +2099,7 @@ export const deleteZoneCustomTag = async ( req, res ) => {
   try {
     const { clientId, tagName } = req.body;
     if ( !clientId || !tagName ) {
-      return res.sendError( 'clientId and tagName are required', 400 );
+      return res.sendError( 'clientId and zoneName are required', 400 );
     }
 
     let zoneTagDetails = await customZoneTagService.findOne( { clientId, tagName } );
@@ -2057,7 +2120,7 @@ export const deleteZoneCustomTag = async ( req, res ) => {
       showTo: [ 'client', 'tango' ],
     };
     insertOpenSearchData( JSON.parse( process.env.OPENSEARCH )?.activityLog, logObj );
-    return res.sendSuccess( 'Zone Tag Deleted Successfully' );
+    return res.sendSuccess( 'ZoneName Deleted Successfully' );
   } catch ( e ) {
     logger.error( { error: e, function: 'deleteZoneCustomTag' } );
     return res.sendError( e, 500 );
@@ -2333,6 +2396,16 @@ export const addZoneGroup = async ( req, res ) => {
       return res.sendError( 'clientId and groupName are required', 400 );
     }
 
+    // Case-insensitive check for existing group
+    const existingGroup = await customzonegrouping.findOne( {
+      clientId,
+      groupName: { $regex: `^${groupName}$`, $options: 'i' },
+    } );
+
+    if ( existingGroup ) {
+      return res.sendError( `groupName "${groupName}" already exists for this client`, 409 );
+    }
+
     const payload = {
       clientId,
       groupName,
@@ -2397,13 +2470,14 @@ export const updateZoneGroup = async ( req, res ) => {
     }
 
     let findGroup = await customzonegrouping.findOne( { _id: _id } );
+    // Case-insensitive check for existing group (excluding current group)
     const existingGroup = await customzonegrouping.findOne( {
       clientId: clientId,
-      groupName: groupName,
+      groupName: { $regex: `^${groupName}$`, $options: 'i' },
       _id: { $ne: _id },
     } );
     if ( existingGroup && existingGroup.groupName ) {
-      return res.sendError( `groupName "${existingGroup.groupName}" already exists for this client`, 409 );
+      return res.sendError( `groupName "${groupName}" already exists for this client`, 409 );
     }
 
     if ( findGroup ) {

package/src/validations/zone.validations.js

@@ -24,49 +24,55 @@ export async function bulkZoneExists( req, res, next ) {
     }
     const clientId = uniqueClientIds[0];
 
-    // Check for duplicate tagNames within the request
+    // Check for duplicate tagNames within the request (case-insensitive)
     const tagNameList = zonesArray.map( ( zone ) => zone.tagName );
-    const uniqueTagNames = [ ...new Set( tagNameList ) ];
-    if ( uniqueTagNames.length !== tagNameList.length ) {
-    //   const duplicates = tagNameList.filter( ( tagName, index ) => tagNameList.indexOf( tagName ) !== index );
+    const tagNameListLower = tagNameList.map( ( name ) => name.toLowerCase() );
+    const uniqueTagNamesLower = [ ...new Set( tagNameListLower ) ];
+    if ( uniqueTagNamesLower.length !== tagNameListLower.length ) {
       return res.sendError( `Duplicate zone name found in request.`, 400 );
     }
 
-    // Check if any tagNames already exist in the database for this client
+    // 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
     const existingZones = await customZoneTagService.find( {
       clientId: clientId,
-      tagName: { $in: tagNameList },
     } );
 
     if ( existingZones && existingZones.length > 0 ) {
-    //   const existingTagNames = existingZones.map( ( zone ) => zone.tagName );
-      return res.sendError( `Zone names already exist for this client.`, 409 );
-    }
-
-    // Check for duplicate groupNames within the request (if provided)
-    const groupNameList = zonesArray
-        .filter( ( zone ) => zone.groupName && zone.groupName !== '' && zone.groupName !== null )
-        .map( ( zone ) => zone.groupName );
-
-    if ( groupNameList.length > 0 ) {
-      const uniqueGroupNames = [ ...new Set( groupNameList ) ];
-      if ( uniqueGroupNames.length !== groupNameList.length ) {
-        // const duplicateGroups = groupNameList.filter( ( groupName, index ) => groupNameList.indexOf( groupName ) !== index );
-        return res.sendError( `Duplicate group names found in request.`, 400 );
-      }
-
-      // Check if any groupNames already exist in the database for this client
-      const existingGroups = await customzonegrouping.find( {
-        clientId: clientId,
-        groupName: { $in: uniqueGroupNames },
-      } );
-
-      if ( existingGroups && existingGroups.length > 0 ) {
-        // const existingGroupNames = existingGroups.map( ( group ) => group.groupName );
-        return res.sendError( `Group names already exist for this client.`, 409 );
+      const existingTagNamesLower = existingZones.map( ( zone ) => zone.tagName?.toLowerCase() ).filter( Boolean );
+      const hasDuplicate = tagNameListLower.some( ( tagNameLower ) => existingTagNamesLower.includes( tagNameLower ) );
+      if ( hasDuplicate ) {
+        return res.sendError( `Zone names already exist for this client.`, 409 );
       }
     }
 
+    // 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 );
+    //     }
+    //   }
+    // }
+
     // Attach clientId to req for use in controller
     req.bulkZoneClientId = clientId;
     next();
@@ -99,21 +105,26 @@ export async function bulkZoneGroupExists( req, res, next ) {
     }
     const clientId = uniqueClientIds[0];
 
-    // Check for duplicate groupNames within the request
+    // Check for duplicate groupNames within the request (case-insensitive)
     const groupNameList = groupsArray.map( ( group ) => group.groupName );
-    const uniqueGroupNames = [ ...new Set( groupNameList ) ];
-    if ( uniqueGroupNames.length !== groupNameList.length ) {
+    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
+    // 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,
-      groupName: { $in: uniqueGroupNames },
     } );
 
     if ( existingGroups && existingGroups.length > 0 ) {
-      return res.sendError( `Group names already exist for this client.`, 409 );
+      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 );
+      }
     }
 
     // Attach clientId to req for use in controller