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

package/.eslintrc.cjs

@@ -36,7 +36,7 @@ module.exports = {
     'no-unused-vars': 'error',
     'new-cap': [ 'error', { 'newIsCap': true, 'capIsNew': false } ],
     'prefer-const': 'off',
-    'no-console': 'error',
+    // 'no-console': 'error',
   },
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-store-zone",
-    "version": "3.3.1-beta.7",
+    "version": "3.3.1-beta.9",
     "description": "zone",
     "main": "index.js",
     "type": "module",
@@ -17,11 +17,11 @@
         "dotenv": "^16.4.5",
         "express": "^4.19.2",
         "handlebars": "^4.7.8",
-        "joi-to-swagger": "^6.2.0",
+        "joi": "^17.12.1",
         "mongodb": "^6.5.0",
         "nodemon": "^3.1.0",
         "swagger-ui-express": "^5.0.0",
-        "tango-api-schema": "^2.1.58",
+        "tango-api-schema": "^2.3.23",
         "tango-app-api-middleware": "^3.1.43-alpha.6",
         "winston": "^3.13.0",
         "winston-daily-rotate-file": "^5.0.0"

package/src/controllers/zoneTagging.controller.js

@@ -5,6 +5,8 @@ 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 * as processedchecklistconfigService from '../services/processedchecklistconfig.services.js';
+
 import axios from 'axios';
 export const addCustomTag = async ( req, res ) => {
   try {
@@ -16,6 +18,7 @@ export const addCustomTag = async ( req, res ) => {
         storeId: inputData.storeId,
         tagName: inputData.tagName,
         rgbColor: inputData.rgbColor,
+        productName: inputData.productName,
         rgbBorderColor: inputData.rgbBorderColor,
       };
       await taggingService.deleteMany( { clientId: inputData.clientId, storeId: inputData.storeId, tagName: inputData.tagName, isDeleted: true } );
@@ -165,6 +168,181 @@ export const customTagList = async ( req, res ) => {
     return res.sendError( e, 500 );
   }
 };
+export const customTagListv2 = async ( req, res ) => {
+  try {
+    // Step 1: Base tag list
+    let customTagList = [
+      { tagName: 'Front', productName: 'tangoTraffic' },
+      { tagName: 'Back', productName: 'tangoTraffic' },
+      { tagName: 'Tracker-in', productName: 'tangoTraker' },
+      { tagName: 'Tracker-out', productName: 'tangoTraker' },
+    ];
+
+    // Step 2: Fetch store & client details in parallel
+    const [ storeDetails, clientDetails ] = await Promise.all( [
+      storeService.findOne(
+          { storeId: req.query.storeId },
+          { product: 1 },
+      ),
+      clientService.findOne(
+          { clientId: req.query.clientId },
+          { featureConfigs: 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 },
+    );
+
+    // Merge all tags
+    const mergedTags = [ ...customTagList, ...tagInfo ];
+
+    // Step 5: Build unique tag list
+    const uniqueTags = [ ...new Map( mergedTags.map( ( tag ) => [ tag.tagName, tag ] ) ).values() ];
+
+    // Step 6: Query counts per tag
+    const tagNames = uniqueTags.map( ( t ) => t.tagName );
+
+    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 },
+        },
+      },
+      { $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,
+      count: countMap.get( tag.tagName ) || 0,
+      rgbColor: tag.rgbColor || tagColors[tag.tagName]?.rgbColor,
+      rgbBorderColor: tag.rgbBorderColor || tagColors[tag.tagName]?.rgbBorderColor,
+    } ) );
+
+
+    // Step 9: Sort by count (desc)
+    finalTags.sort( ( a, b ) => b.count - a.count );
+    if ( req.query.selectedProduct && req.query.selectedProduct === 'tangoTrax' ) {
+      let Query = [ {
+        $match: {
+          client_id: req.query.clientId,
+          checkListType: { $ne: 'custom' },
+        },
+      }, {
+        $group: {
+          _id: '$sourceCheckList_id',
+          sourceCheckList_id: { $last: '$sourceCheckList_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',
+          count: { $size: '$cameraList' },
+        },
+      },
+      {
+        $sort: {
+          count: -1,
+        },
+      },
+
+      ];
+      let getChecklistData = await processedchecklistconfigService.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( finalTags );
+    }
+  } catch ( e ) {
+    logger.error( { error: e, function: 'customTagList' } );
+    return res.sendError( e, 500 );
+  }
+};
 
 export const tagging = async ( req, res ) => {
   try {
@@ -224,12 +402,12 @@ export const tagging = async ( req, res ) => {
           ...taggingDetails.toObject(),
         },
         oldData: {
-          TagName: taggingDetails.tagName,
-          StreamName: taggingDetails.streamName,
+          tagName: taggingDetails.tagName,
+          streamName: taggingDetails.streamName,
         },
         newData: {
-          TagName: taggingDetails.tagName,
-          StreamName: taggingDetails.streamName,
+          tagName: taggingDetails.tagName,
+          streamName: taggingDetails.streamName,
         },
         showTo: [ 'tango', 'client' ],
       };
@@ -239,6 +417,8 @@ export const tagging = async ( req, res ) => {
       insertOpenSearchData( JSON.parse( process.env.OPENSEARCH )?.activityLog, logObj );
       taggingDetails.cameraId = InputData.cameraId;
       taggingDetails.streamName = InputData.streamName;
+      taggingDetails.checkListName = InputData.checkListName;
+      taggingDetails.productName = InputData.productName;
       // if ( req.body?.redoPoint ) {
       //   taggingDetails.coordinates = InputData.coordinates[0];
       //   taggingDetails.save();
@@ -271,7 +451,7 @@ export const tagging = async ( req, res ) => {
     let externalDetails = await externalService.findOne( { storeId: InputData.storeId, zoneName: InputData.tagName, clientId: InputData.clientId } );
 
     if ( !externalDetails ) {
-      let data ={
+      let data = {
         'storeId': InputData.storeId,
         'clientId': InputData.clientId,
         'productName': 'tangoZone',
@@ -335,11 +515,13 @@ export const getCameraList = async ( req, res ) => {
     if ( !cameraDetails.length ) {
       return res.sendError( 'no data found', 204 );
     }
-    const folderPath = { file_path: `${req.query.storeId}/zone_base_images/`,
+    const folderPath = {
+      file_path: `${req.query.storeId}/zone_base_images/`,
       Bucket: JSON.parse( process.env.BUCKET ).zoneBaseImage, MaxKeys: 1000,
     };
     let fileList = await listFileByPath( folderPath );
-    const TaggedfolderPath = { file_path: `${req.query.storeId}/zone_tagged_image/`,
+    const TaggedfolderPath = {
+      file_path: `${req.query.storeId}/zone_tagged_image/`,
       Bucket: JSON.parse( process.env.BUCKET ).zoneTaggingImage, MaxKeys: 1000,
     };
     let tagFileList = await listFileByPath( TaggedfolderPath );
@@ -365,7 +547,7 @@ export const getCameraList = 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.query.storeId}_${camera.streamName}` ) {
               tagPath = item.Key;
@@ -376,21 +558,23 @@ export const getCameraList = 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.query.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 );
@@ -406,6 +590,87 @@ export const getCameraList = async ( req, res ) => {
     return res.sendError( e, 500 );
   }
 };
+export const getCameraListv2 = async ( req, res ) => {
+  try {
+    let cameraDetails = await cameraService.find( { clientId: req.query.clientId, storeId: req.query.storeId, isActivated: true, isUp: true }, { cameraNumber: 1, streamName: 1, isActivated: 1, isUp: 1, cameraName: 1, taggedChecklist: 1 } );
+    if ( !cameraDetails.length ) {
+      return res.sendError( 'no data found', 204 );
+    }
+    const folderPath = {
+      file_path: `${req.query.storeId}/zone_base_images/`,
+      Bucket: JSON.parse( process.env.BUCKET ).zoneBaseImage, MaxKeys: 1000,
+    };
+    let fileList = await listFileByPath( folderPath );
+    const TaggedfolderPath = {
+      file_path: `${req.query.storeId}/zone_tagged_image/`,
+      Bucket: JSON.parse( process.env.BUCKET ).zoneTaggingImage, MaxKeys: 1000,
+    };
+    let tagFileList = await listFileByPath( TaggedfolderPath );
+    for ( let [ index, camera ] of cameraDetails.entries() ) {
+      let tagList = [];
+      let tagPath;
+      let imgPath;
+      camera = {
+        ...camera._doc,
+        baseImg: '',
+        tagImg: '',
+      };
+      let taggingDetails = await taggingService.find( { cameraId: camera._id, streamName: camera.streamName, clientId: req.query.clientId, isDeleted: false }, { tagName: 1, coordinates: 1 } );
+      if ( taggingDetails.length ) {
+        tagList = taggingDetails.filter( ( item ) => item.coordinates.length ).map( ( item ) => {
+          if ( item.coordinates.length ) {
+            return { tagName: item.tagName, color: item.coordinates[0].color };
+          }
+        } );
+      }
+
+      if ( tagFileList.data.length ) {
+        tagFileList.data.forEach( ( item ) => {
+          if ( item.Key.length > 1 ) {
+            let splitStream = item.Key.split( '/' );
+            let getStream = splitStream[splitStream.length - 1].split( '.' );
+
+            if ( getStream && getStream[0] == `${req.query.storeId}_${camera.streamName}` ) {
+              tagPath = item.Key;
+            }
+          }
+        } );
+      }
+      if ( fileList?.data.length ) {
+        fileList.data.forEach( ( ele ) => {
+          let splitStream = ele.Key.split( '/' );
+          let getStream = splitStream[splitStream.length - 1].split( '.' );
+          if ( getStream && getStream[0] == `${req.query.storeId}_${camera.streamName}` ) {
+            imgPath = ele.Key;
+          }
+        } );
+      }
+      if ( 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,
+          Bucket: JSON.parse( process.env.BUCKET ).zoneBaseImage,
+        };
+        const cameraBaseImage = await signedUrl( baseParams );
+        camera.baseImg = cameraBaseImage;
+      }
+      camera.tagging = tagList;
+      cameraDetails[index] = camera;
+    }
+    cameraDetails.sort( ( a, b ) => a.tagging?.length > b.tagging?.length ? -1 : 1 );
+    return res.sendSuccess( cameraDetails );
+  } catch ( e ) {
+    logger.error( { error: e, function: 'getCameraListv2' } );
+    return res.sendError( e, 500 );
+  }
+};
 
 export const updateTag = async ( req, res ) => {
   try {
@@ -452,10 +717,10 @@ export const updateTag = async ( req, res ) => {
         tagName: req.body.tagName,
       },
       oldData: {
-        TagName: req.body.existTag,
+        tagName: req.body.existTag,
       },
       newData: {
-        TagName: req.body.tagName,
+        tagName: req.body.tagName,
       },
       showTo: [ 'tango', 'client' ],
     };
@@ -716,6 +981,28 @@ export const updateOldData = async ( req, res ) => {
     return res.sendError( e, 500 );
   }
 };
+export async function updateCamera( req, res ) {
+  try {
+    let findoneCheckList = await processedchecklistconfigService.findOne( {
+      client_id: req.body.clientId, checkListName: req.body.selectedZone,
+    } );
+
+    let updateData = {
+      checkListName: req.body.selectedZone,
+      sourceCheckList_id: findoneCheckList?.sourceCheckList_id,
+    };
+    if ( req.body.type === 'tagCamera' ) {
+      await cameraService.updateOne( { _id: req.body._id }, { $push: { taggedChecklist: updateData } } );
+    } else {
+      await cameraService.updateOne( { _id: req.body._id }, { $pull: { taggedChecklist: updateData } } );
+    }
+
+    res.sendSuccess( 'updated Sucessfully' );
+  } catch ( e ) {
+    logger.error( { error: e, function: 'updateOldData' } );
+    return res.sendError( e, 500 );
+  }
+};
 
 export const deletezoneTagging = async ( req, res ) => {
   let data = req.body;
@@ -754,81 +1041,3 @@ async function updateJsonFile( req, res ) {
     }
   }
 };
-
-export const getCameraStreamList = async ( req, res ) => {
-  try {
-    let cameraDetails = await cameraService.find( { clientId: req.body.clientId, storeId: req.body.storeId, streamName: req.body.streamName }, { cameraNumber: 1, streamName: 1, isActivated: 1, isUp: 1, cameraName: 1 } );
-    if ( !cameraDetails.length ) {
-      return res.sendError( 'no data found', 204 );
-    }
-    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/`,
-      Bucket: JSON.parse( process.env.BUCKET ).zoneTaggingImage, MaxKeys: 1000,
-    };
-    let tagFileList = await listFileByPath( TaggedfolderPath );
-    for ( let [ index, camera ] of cameraDetails.entries() ) {
-      let tagList = [];
-      let tagPath;
-      let imgPath;
-      camera = {
-        ...camera._doc,
-        baseImg: '',
-        tagImg: '',
-      };
-      let taggingDetails = await taggingService.find( { cameraId: camera._id, streamName: camera.streamName, clientId: req.body.clientId, isDeleted: false }, { tagName: 1, coordinates: 1 } );
-      if ( taggingDetails.length ) {
-        tagList = taggingDetails.filter( ( item ) => item.coordinates.length ).map( ( item ) => {
-          if ( item.coordinates.length ) {
-            return { tagName: item.tagName, color: item.coordinates[0].color };
-          }
-        } );
-      }
-
-      if ( tagFileList.data.length ) {
-        tagFileList.data.forEach( ( item ) => {
-          if ( item.Key.length > 1 ) {
-            let splitStream = item.Key.split( '/' );
-            let getStream = splitStream[splitStream.length -1].split( '.' );
-
-            if ( getStream && getStream[0] == `${req.body.storeId}_${camera.streamName}` ) {
-              tagPath = item.Key;
-            }
-          }
-        } );
-      }
-      if ( fileList?.data.length ) {
-        fileList.data.forEach( ( ele ) => {
-          let splitStream = ele.Key.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,
-          Bucket: JSON.parse( process.env.BUCKET ).zoneTaggingImage,
-        };
-        const cameraTagImage = await signedUrl( params );
-        camera.tagImg = cameraTagImage;
-      }
-      if ( imgPath ) {
-        const baseParams = { file_path: imgPath,
-          Bucket: JSON.parse( process.env.BUCKET ).zoneBaseImage,
-        };
-        const cameraBaseImage = await signedUrl( baseParams );
-        camera.baseImg = cameraBaseImage;
-      }
-      camera.tagging = tagList;
-      cameraDetails[index] = camera;
-    }
-    cameraDetails.sort( ( a, b ) => a.tagging?.length > b.tagging?.length ? -1 : 1 );
-    return res.sendSuccess( cameraDetails );
-  } catch ( e ) {
-    logger.error( { error: e, function: 'getCameraList' } );
-    return res.sendError( e, 500 );
-  }
-};

package/src/dtos/validation.dtos.js

@@ -4,6 +4,7 @@ export const addTagSchema = joi.object( {
   clientId: joi.string().required(),
   tagName: joi.string().required(),
   storeId: joi.string().required(),
+  productName: joi.string().required(),
   rgbColor: joi.string().required(),
   rgbBorderColor: joi.string().required(),
 } );
@@ -52,6 +53,8 @@ export const validateTaggingSchema = joi.object( {
   streamName: joi.string().required(),
   redoPoint: joi.boolean().optional(),
   redraw: joi.boolean().optional(),
+  productName: joi.string().required(),
+  checkListName: joi.string().optional(),
 } );
 
 export const validateTaggingParams = {
@@ -97,13 +100,3 @@ 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,
-};

package/src/routes/zoneTagging.routes.js

@@ -9,15 +9,17 @@ 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.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( '/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 );
 

package/src/services/processedchecklistconfig.services.js

@@ -0,0 +1,35 @@
+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 );
+};
+
+