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

package/src/dtos/validation.dtos.js

@@ -13,6 +13,34 @@ export const validateAddTagParams = {
   body: addTagSchema,
 };
 
+// zone tagging
+export const zoneAddTagSchema = joi.object( {
+  clientId: joi.string().required(),
+  tagName: joi.string().required(),
+  productName: joi.string().required(),
+  rgbColor: joi.string().required(),
+  rgbBorderColor: joi.string().required(),
+  groupName: joi.string().allow( '', null ).optional(),
+  isExistingGroup: joi.boolean().optional(),
+} );
+
+export const validateZoneAddTagParams = {
+  body: zoneAddTagSchema,
+};
+
+// zone grouping
+export const zoneGroupAddTagSchema = joi.object( {
+  clientId: joi.string().required(),
+  groupName: joi.string().required(),
+  productName: joi.string().required(),
+  tagName: joi.string().optional(),
+  zonesTagged: joi.array().items( joi.string() ).optional(),
+} );
+
+export const validateZoneGroupAddTagParams = {
+  body: zoneGroupAddTagSchema,
+};
+
 export const tagSchema = joi.object( {
   clientId: joi.string().required(),
   storeId: joi.string().required(),
@@ -34,6 +62,20 @@ export const validateUpdateTagParams = {
   body: validateUpdateTagSchema,
 };
 
+export const validateZoneUpdateTagSchema = joi.object( {
+  clientId: joi.string().required(),
+  tagName: joi.string().required(),
+  productName: joi.string().required(),
+  _id: joi.string().optional(),
+  groupName: joi.string().allow( '', null ).optional(),
+  isExistingGroup: joi.boolean().optional(),
+  oldTag: joi.string().optional(),
+} );
+
+export const validateZoneUpdateTagParams = {
+  body: validateZoneUpdateTagSchema,
+};
+
 
 export const validateDeleteTagSchema = joi.object( {
   tagName: joi.string().required(),
@@ -45,6 +87,25 @@ export const validateDeleteTagParams = {
   body: validateDeleteTagSchema,
 };
 
+export const validateZoneDeleteTagSchema = joi.object( {
+  tagName: joi.string().required(),
+  clientId: joi.string().required(),
+} );
+
+export const validateZoneDeleteTagParams = {
+  body: validateZoneDeleteTagSchema,
+};
+
+export const validateZoneGroupDeleteTagSchema = joi.object( {
+  groupName: joi.string().required(),
+  clientId: joi.string().required(),
+  _id: joi.string().required(),
+} );
+
+export const validateZoneGroupDeleteTagParams = {
+  body: validateZoneGroupDeleteTagSchema,
+};
+
 export const validateTaggingSchema = joi.object( {
   clientId: joi.string().required(),
   storeId: joi.string().required(),
@@ -111,3 +172,73 @@ export const getStreamSchema= joi.object( {
 export const getStreamParams = {
   body: getStreamSchema,
 };
+
+export const validateZoneConfigTaggingSchema = joi.object( {
+  clientId: joi.string().required(),
+  limit: joi.number().integer().min( 1 ).optional(),
+  offset: joi.number().integer().min( 0 ).optional(),
+  searchValue: joi.string().allow( '' ).optional(),
+  export: joi.boolean().optional(),
+  sortBy: joi.number().optional(),
+  sortColumName: joi.string().allow( '' ).optional(),
+} );
+
+export const validateZoneConfigTaggingParams = {
+  body: validateZoneConfigTaggingSchema,
+};
+
+export const validateZoneGroupSchema = joi.object( {
+  clientId: joi.string().required(),
+  limit: joi.number().integer().min( 1 ).optional(),
+  offset: joi.number().integer().min( 0 ).optional(),
+  searchValue: joi.string().allow( '' ).optional(),
+  export: joi.boolean().optional(),
+  sortBy: joi.number().optional(),
+  sortColumName: joi.string().allow( '' ).optional(),
+} );
+
+export const validateZoneGroupingParams = {
+  body: validateZoneGroupSchema,
+};
+
+// bulk zone tagging - array of zones (request body is array directly)
+export const bulkZoneAddTagSchema = joi.array().items(
+    joi.object( {
+      clientId: joi.string().required(),
+      tagName: joi.string().required(),
+      productName: joi.string().required(),
+      rgbColor: joi.string().required(),
+      rgbBorderColor: joi.string().required(),
+      groupName: joi.string().allow( '', null ).optional(),
+    } ),
+).min( 1 ).required();
+
+export const validateBulkZoneAddTagParams = {
+  body: bulkZoneAddTagSchema,
+};
+
+// bulk zone-group (request body)
+export const bulkZoneGroupAddTagSchema = joi.array().items(
+    joi.object( {
+      clientId: joi.string().required(),
+      groupName: joi.string().required(),
+      productName: joi.string().required(),
+    } ),
+).min( 1 ).required();
+
+export const validateBulkZoneGroupAddTagParams = {
+  body: bulkZoneGroupAddTagSchema,
+};
+
+export const validateZoneGroupUpdateSchema = joi.object( {
+  _id: joi.string().optional(),
+  clientId: joi.string().required(),
+  groupName: joi.string().required(),
+  oldGroupName: joi.string().optional(),
+  productName: joi.string().required(),
+  zonesTagged: joi.array().items( joi.string() ).optional(),
+} );
+
+export const validateZoneGroupUpdateParams = {
+  body: validateZoneGroupUpdateSchema,
+};

package/src/routes/zoneTagging.routes.js

@@ -4,12 +4,14 @@ import express from 'express';
 import { isAllowedSessionHandler, validate, accessVerification } from 'tango-app-api-middleware';
 import * as validation from '../dtos/validation.dtos.js';
 import * as tagController from '../controllers/zoneTagging.controller.js';
+import { bulkZoneExists, bulkZoneGroupExists } from '../validations/zone.validations.js';
 
 export const zoneTaggingRouter = express.Router();
 
 zoneTaggingRouter.post( '/addCustomTag', isAllowedSessionHandler, accessVerification( { userType: [ 'tango', 'client' ], access: [ { featureName: 'TangoEye', name: 'ZoneTag', permissions: [ 'isAdd' ] } ] } ), validate( validation.validateAddTagParams ), tagController.addCustomTag );
 zoneTaggingRouter.get( '/customTagList', isAllowedSessionHandler, accessVerification( { userType: [ 'tango', 'client' ], access: [ { featureName: 'TangoEye', name: 'ZoneTag', permissions: [ ] } ] } ), validate( validation.validateTagParams ), tagController.customTagList );
 zoneTaggingRouter.get( '/customTagListv2', isAllowedSessionHandler, accessVerification( { userType: [ 'tango', 'client' ], access: [ { featureName: 'TangoEye', name: 'ZoneTag', permissions: [ ] } ] } ), tagController.customTagListv2 );
+zoneTaggingRouter.get( '/customTagListv3', isAllowedSessionHandler, accessVerification( { userType: [ 'tango', 'client' ], access: [ { featureName: 'TangoEye', name: 'ZoneTag', permissions: [ ] } ] } ), tagController.customTagListv3 );
 zoneTaggingRouter.post( '/tagging', isAllowedSessionHandler, accessVerification( { userType: [ 'tango', 'client' ], access: [ { featureName: 'TangoEye', name: 'ZoneTag', permissions: [ 'isEdit' ] } ] } ), validate( validation.validateTaggingParams ), tagController.tagging );
 zoneTaggingRouter.get( '/cameraList', isAllowedSessionHandler, accessVerification( { userType: [ 'tango', 'client' ], access: [ { featureName: 'TangoEye', name: 'ZoneTag', permissions: [ ] } ] } ), validate( validation.validateTagParams ), tagController.getCameraList );
 zoneTaggingRouter.post( '/cameraListv2', isAllowedSessionHandler, accessVerification( { userType: [ 'tango', 'client' ], access: [ { featureName: 'TangoEye', name: 'ZoneTag', permissions: [ ] } ] } ), validate( validation.validateTagParams ), tagController.getCameraListv2 );
@@ -24,4 +26,17 @@ zoneTaggingRouter.post( '/updateCamera', isAllowedSessionHandler, accessVerifica
 
 zoneTaggingRouter.get( '/updateOldZone', tagController.updateOldData );
 
+// settings config - zone routes
+zoneTaggingRouter.post( '/getZoneTaggingDetails', isAllowedSessionHandler, accessVerification( { userType: [ 'tango', 'client' ], access: [ { featureName: 'TangoEye', name: 'ZoneTag', permissions: [ ] } ] } ), validate( validation.validateZoneConfigTaggingParams ), tagController.getZoneTaggingDetails );
+zoneTaggingRouter.post( '/addZoneCustomTag', isAllowedSessionHandler, accessVerification( { userType: [ 'tango', 'client' ], access: [ { featureName: 'TangoEye', name: 'ZoneTag', permissions: [ 'isAdd' ] } ] } ), validate( validation.validateZoneAddTagParams ), tagController.addZoneCustomTag );
+// bulk zone upload
+zoneTaggingRouter.post( '/bulkZoneUpload', isAllowedSessionHandler, accessVerification( { userType: [ 'tango', 'client' ], access: [ { featureName: 'TangoEye', name: 'ZoneTag', permissions: [ 'isAdd' ] } ] } ), validate( validation.validateBulkZoneAddTagParams ), bulkZoneExists, tagController.uploadBulkZoneTag );
+zoneTaggingRouter.post( '/updateZoneCustomTag', isAllowedSessionHandler, accessVerification( { userType: [ 'tango', 'client' ], access: [ { featureName: 'TangoEye', name: 'ZoneTag', permissions: [ 'isEdit' ] } ] } ), validate( validation.validateZoneUpdateTagParams ), tagController.updateZoneCustomTag );
+zoneTaggingRouter.post( '/deleteZoneCustomTag', isAllowedSessionHandler, accessVerification( { userType: [ 'tango', 'client' ], access: [ { featureName: 'TangoEye', name: 'ZoneTag', permissions: [ 'isEdit' ] } ] } ), validate( validation.validateZoneDeleteTagSchema ), tagController.deleteZoneCustomTag );
 
+// settings config - zoneGrouping routes
+zoneTaggingRouter.post( '/getZoneGroupDetails', isAllowedSessionHandler, accessVerification( { userType: [ 'tango', 'client' ], access: [ { featureName: 'TangoEye', name: 'ZoneTag', permissions: [ ] } ] } ), validate( validation.validateZoneGroupingParams ), tagController.getZoneGroupDetails );
+zoneTaggingRouter.post( '/addZoneGroup', isAllowedSessionHandler, accessVerification( { userType: [ 'tango', 'client' ], access: [ { featureName: 'TangoEye', name: 'ZoneTag', permissions: [ 'isAdd' ] } ] } ), validate( validation.validateZoneGroupAddTagParams ), tagController.addZoneGroup );
+zoneTaggingRouter.post( '/bulkZoneGroupUpload', isAllowedSessionHandler, accessVerification( { userType: [ 'tango', 'client' ], access: [ { featureName: 'TangoEye', name: 'ZoneTag', permissions: [ 'isAdd' ] } ] } ), validate( validation.validateBulkZoneGroupAddTagParams ), bulkZoneGroupExists, tagController.uploadBulkZoneGroup );
+zoneTaggingRouter.post( '/updateZoneGroup', isAllowedSessionHandler, accessVerification( { userType: [ 'tango', 'client' ], access: [ { featureName: 'TangoEye', name: 'ZoneTag', permissions: [ 'isEdit' ] } ] } ), validate( validation.validateZoneGroupUpdateParams ), tagController.updateZoneGroup );
+zoneTaggingRouter.post( '/deleteZoneGroup', isAllowedSessionHandler, accessVerification( { userType: [ 'tango', 'client' ], access: [ { featureName: 'TangoEye', name: 'ZoneTag', permissions: [ 'isEdit' ] } ] } ), validate( validation.validateZoneGroupDeleteTagParams ), tagController.deleteZoneGroup );

package/src/services/customzonegrouping.service.js

@@ -0,0 +1,55 @@
+import model from 'tango-api-schema';
+
+export const findOne = async ( query ={}, record = {} ) => {
+  return await model.zonegroupsModel.findOne( query, record );
+};
+
+export const find = async ( query = {}, record = {}, options = {} ) => {
+  let queryBuilder = model.zonegroupsModel.find( query, record );
+
+  // Apply pagination if provided
+  if ( options.skip !== undefined ) {
+    queryBuilder = queryBuilder.skip( options.skip );
+  }
+  if ( options.limit !== undefined ) {
+    queryBuilder = queryBuilder.limit( options.limit );
+  }
+  if ( options.sort !== undefined ) {
+    queryBuilder = queryBuilder.sort( options.sort );
+  }
+
+  return await queryBuilder;
+};
+
+export const aggregate = async ( query ={} ) => {
+  return await model.zonegroupsModel.aggregate( query );
+};
+
+// export const deleteMany = async ( query = {} ) => {
+//   return await model.zonegroupsModel.deleteMany( query );
+// };
+
+export const deleteOne = async ( query = {} ) => {
+  return await model.zonegroupsModel.deleteOne( query );
+};
+
+// export const insertMany = async ( data = [] ) => {
+//   return await model.zonegroupsModel.insertMany( data );
+// };
+
+// export const updateMany = async ( query = {}, record ={} ) => {
+//   return await model.zonegroupsModel.updateMany( query, record );
+// };
+
+export const updateOne = async ( query = {}, record ={} ) => {
+  return await model.zonegroupsModel.updateOne( query, record );
+};
+
+export const create = async ( data = [] ) => {
+  return await model.zonegroupsModel.create( data );
+};
+
+export const count = async ( query = {} ) => {
+  return await model.zonegroupsModel.countDocuments( query );
+};
+

package/src/services/customzonetag.service.js

@@ -0,0 +1,56 @@
+import model from 'tango-api-schema';
+
+export const findOne = async ( query ={}, record = {} ) => {
+  console.log( 'customZoneTagService findOne query :', query );
+  return await model.customZonetagsModel.findOne( query, record );
+};
+
+export const find = async ( query = {}, record = {}, options = {} ) => {
+  let queryBuilder = model.customZonetagsModel.find( query, record );
+
+  // Apply pagination if provided
+  if ( options.skip !== undefined ) {
+    queryBuilder = queryBuilder.skip( options.skip );
+  }
+  if ( options.limit !== undefined ) {
+    queryBuilder = queryBuilder.limit( options.limit );
+  }
+  if ( options.sort !== undefined ) {
+    queryBuilder = queryBuilder.sort( options.sort );
+  }
+
+  return await queryBuilder;
+};
+
+export const aggregate = async ( query ={}, record = {} ) => {
+  return await model.customZonetagsModel.aggregate( query );
+};
+
+// export const deleteMany = async ( query = {} ) => {
+//   return await model.customZonetagsModel.deleteMany( query );
+// };
+
+export const deleteOne = async ( query = {} ) => {
+  return await model.customZonetagsModel.deleteOne( query );
+};
+
+// export const insertMany = async ( data = [] ) => {
+//   return await model.customZonetagsModel.insertMany( data );
+// };
+
+export const updateMany = async ( query = {}, record ={} ) => {
+  return await model.customZonetagsModel.updateMany( query, record );
+};
+
+export const updateOne = async ( query = {}, record ={} ) => {
+  return await model.customZonetagsModel.updateOne( query, record );
+};
+
+export const create = async ( data = [] ) => {
+  return await model.customZonetagsModel.create( data );
+};
+
+export const count = async ( query = {} ) => {
+  return await model.customZonetagsModel.countDocuments( query );
+};
+

package/src/services/tagging.service.js

@@ -36,3 +36,6 @@ export const create = async ( data = [] ) => {
   return await model.taggingModel.create( data );
 };
 
+export const getDistinct = async ( fieldName, filter = {} ) => {
+  return await model.taggingModel.distinct( fieldName, filter );
+};

package/src/validations/zone.validations.js

@@ -0,0 +1,127 @@
+import { logger } from 'tango-app-api-middleware';
+import * as customZoneTagService from '../services/customzonetag.service.js';
+import * as customzonegrouping from '../services/customzonegrouping.service.js';
+
+
+export async function bulkZoneExists( req, res, next ) {
+  try {
+    const zonesArray = req.body;
+
+    // Validate zones array exists and is not empty
+    if ( !zonesArray || !Array.isArray( zonesArray ) || zonesArray.length === 0 ) {
+      return res.sendError( 'zone file should not be empty', 400 );
+    }
+
+    // Validate all zones have the same clientId
+    const clientIds = zonesArray.map( ( zone ) => zone.clientId );
+    const uniqueClientIds = [ ...new Set( clientIds ) ];
+    if ( uniqueClientIds.length > 1 ) {
+      return res.sendError( 'All zones must have the same clientId', 400 );
+    }
+    console.log( 'uniqueClientIds :', uniqueClientIds );
+    if ( !uniqueClientIds[0] ) {
+      return res.sendError( 'clientId is required for all zones', 400 );
+    }
+    const clientId = uniqueClientIds[0];
+
+    // Check for duplicate tagNames within the request
+    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 );
+      return res.sendError( `Duplicate zone name found in request.`, 400 );
+    }
+
+    // Check if any tagNames already exist in the database for this client
+    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 );
+      }
+    }
+
+    // Attach clientId to req for use in controller
+    req.bulkZoneClientId = clientId;
+    next();
+  } catch ( error ) {
+    const err = error.message || 'Internal Server Error';
+    logger.error( { error: error, message: req.body, function: 'bulkZoneExists' } );
+    return res.sendError( err, 500 );
+  }
+}
+
+
+export async function bulkZoneGroupExists( req, res, next ) {
+  try {
+    const groupsArray = req.body;
+
+    // Validate groups array exists and is not empty
+    if ( !groupsArray || !Array.isArray( groupsArray ) || groupsArray.length === 0 ) {
+      return res.sendError( 'group file should not be empty', 400 );
+    }
+
+    // Validate all groups have the same clientId
+    const clientIds = groupsArray.map( ( group ) => group.clientId );
+    const uniqueClientIds = [ ...new Set( clientIds ) ];
+    if ( uniqueClientIds.length > 1 ) {
+      return res.sendError( 'All groups must have the same clientId', 400 );
+    }
+    console.log( 'uniqueClientIds :', uniqueClientIds );
+    if ( !uniqueClientIds[0] ) {
+      return res.sendError( 'clientId is required for all groups', 400 );
+    }
+    const clientId = uniqueClientIds[0];
+
+    // Check for duplicate groupNames within the request
+    const groupNameList = groupsArray.map( ( group ) => group.groupName );
+    const uniqueGroupNames = [ ...new Set( groupNameList ) ];
+    if ( uniqueGroupNames.length !== groupNameList.length ) {
+      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 ) {
+      return res.sendError( `Group names already exist for this client.`, 409 );
+    }
+
+    // Attach clientId to req for use in controller
+    req.bulkZoneClientId = clientId;
+    next();
+  } catch ( error ) {
+    const err = error.message || 'Internal Server Error';
+    logger.error( { error: error, message: req.body, function: 'bulkZoneGroupExists' } );
+    return res.sendError( err, 500 );
+  }
+}