tango-app-api-store-zone 3.3.1-beta.9 → 3.3.2

package/src/dtos/validation.dtos.js

@@ -13,13 +13,42 @@ 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(),
+  tagName: joi.string().optional(),
 } );
 
 export const validateTagParams = {
-  query: tagSchema,
+  body: tagSchema,
 };
 
 export const validateUpdateTagSchema = joi.object( {
@@ -33,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(),
@@ -44,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(),
@@ -100,3 +162,83 @@ export const updateCoordinatesSchema= joi.object( {
 export const updateCoordinatesParams = {
   body: updateCoordinatesSchema,
 };
+
+export const getStreamSchema= joi.object( {
+  storeId: joi.string().required(),
+  clientId: joi.string().required(),
+  streamName: joi.string().required(),
+} );
+
+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,23 +4,39 @@ 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.get( '/cameraListv2', isAllowedSessionHandler, accessVerification( { userType: [ 'tango', 'client' ], access: [ { featureName: 'TangoEye', name: 'ZoneTag', permissions: [ ] } ] } ), validate( validation.validateTagParams ), tagController.getCameraListv2 );
+zoneTaggingRouter.post( '/cameraListv2', isAllowedSessionHandler, accessVerification( { userType: [ 'tango', 'client' ], access: [ { featureName: 'TangoEye', name: 'ZoneTag', permissions: [ ] } ] } ), validate( validation.validateTagParams ), tagController.getCameraListv2 );
 zoneTaggingRouter.post( '/updateCustomTag', isAllowedSessionHandler, accessVerification( { userType: [ 'tango', 'client' ], access: [ { featureName: 'TangoEye', name: 'ZoneTag', permissions: [ 'isEdit' ] } ] } ), validate( validation.validateUpdateTagParams ), tagController.updateTag );
 zoneTaggingRouter.post( '/deleteCustomTag', isAllowedSessionHandler, accessVerification( { userType: [ 'tango', 'client' ], access: [ { featureName: 'TangoEye', name: 'ZoneTag', permissions: [ 'isEdit' ] } ] } ), validate( validation.validateDeleteTagParams ), tagController.deleteTag );
 zoneTaggingRouter.get( '/getCameraTagging', isAllowedSessionHandler, accessVerification( { userType: [ 'tango', 'client' ], access: [ { featureName: 'TangoEye', name: 'ZoneTag', permissions: [ ] } ] } ), validate( validation.validateCameraTagParams ), tagController.getCameraTagging );
 zoneTaggingRouter.get( '/getZoneTagging', isAllowedSessionHandler, accessVerification( { userType: [ 'tango', 'client' ], access: [ { featureName: 'TangoEye', name: 'ZoneTag', permissions: [ ] } ] } ), validate( validation.validateZonetagParams ), tagController.getZoneList );
 zoneTaggingRouter.post( '/updatezoneTagging', isAllowedSessionHandler, accessVerification( { userType: [ 'tango', 'client' ], access: [ { featureName: 'TangoEye', name: 'ZoneTag', permissions: [ 'isEdit' ] } ] } ), validate( validation.validateCamZonetagParams ), tagController.updatezoneTagging );
 zoneTaggingRouter.post( '/deleteZoneTag', isAllowedSessionHandler, accessVerification( { userType: [ 'tango', 'client' ], access: [ { featureName: 'TangoEye', name: 'ZoneTag', permissions: [ 'isEdit' ] } ] } ), validate( validation.updateCoordinatesParams ), tagController.deletezoneTagging );
+zoneTaggingRouter.post( '/getStreamDetails', isAllowedSessionHandler, validate( validation.getStreamParams ), tagController.getCameraStreamList );
 zoneTaggingRouter.post( '/updateCamera', isAllowedSessionHandler, accessVerification( { userType: [ 'tango', 'client' ], access: [ { featureName: 'TangoEye', name: 'ZoneTag', permissions: [ 'isEdit' ] } ] } ), tagController.updateCamera );
 
 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/checklistconfig.services.js

@@ -0,0 +1,31 @@
+import model from 'tango-api-schema';
+
+export const findOne = async ( query={}, field={} ) => {
+  return model.checklistconfigModel.findOne( query, field );
+};
+
+export const find = async ( query={}, field={} ) => {
+  return model.checklistconfigModel.find( query, field );
+};
+
+export const create = async ( document = {} ) => {
+  return model.checklistconfigModel.create( document );
+};
+
+export const deleteOne = async ( query = {} ) => {
+  return model.checklistconfigModel.deleteOne( query );
+};
+
+export const updateOne = async ( query = {}, record={} ) => {
+  return model.checklistconfigModel.updateOne( query, { $set: record }, { upsert: true } );
+};
+
+export const updateMany = async ( query = {}, record={} ) => {
+  return model.checklistconfigModel.updateMany( query, { $set: record } );
+};
+
+export const aggregate = async ( query = {} ) => {
+  return model.checklistconfigModel.aggregate( query );
+};
+
+

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,110 @@
+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 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 );
+    }
+
+    // Fetch all existing tags for this client and compare
+    const existingZones = await customZoneTagService.find( {
+      clientId: clientId,
+    } );
+
+    if ( existingZones && existingZones.length > 0 ) {
+      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 );
+      }
+    }
+
+    // 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 (case-insensitive)
+    const groupNameList = groupsArray.map( ( group ) => group.groupName );
+    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();
+  } catch ( error ) {
+    const err = error.message || 'Internal Server Error';
+    logger.error( { error: error, message: req.body, function: 'bulkZoneGroupExists' } );
+    return res.sendError( err, 500 );
+  }
+}

package/src/services/processedchecklistconfig.services.js

@@ -1,35 +0,0 @@
-import model from 'tango-api-schema';
-
-export const find = ( query = {}, record = {} ) => {
-  return model.processedchecklistconfigModel.find( query, record );
-};
-
-export const findOne = ( query = {}, record = {} ) => {
-  return model.processedchecklistconfigModel.findOne( query, record ).sort( { updatedAt: -1 } );
-};
-
-export const updateOne = ( query = {}, record = {} ) => {
-  return model.processedchecklistconfigModel.updateOne( query, { $set: record }, { upsert: true } );
-};
-
-export const updateMany = ( query = {}, record = {} ) => {
-  return model.processedchecklistconfigModel.updateMany( query, { $set: record } );
-};
-
-export const deleteMany = ( query = {} ) => {
-  return model.processedchecklistconfigModel.deleteMany( query );
-};
-
-export const aggregate = ( query = [] ) => {
-  return model.processedchecklistconfigModel.aggregate( query );
-};
-
-export const getClientCount = ( query = {} ) => {
-  return model.processedchecklistconfigModel.count( query );
-};
-
-export const insert = ( document={} ) => {
-  return model.processedchecklistconfigModel.create( document );
-};
-
-