tango-app-api-store-zone 3.3.1-beta.0 → 3.3.1-beta.10

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/app.js

@@ -0,0 +1,43 @@
+
+import express from 'express';
+import { zoneTaggingRouter } from './index.js';
+
+import dotenv from 'dotenv';
+import { logger } from 'tango-app-api-middleware';
+import { connectdb } from './config/database/database.js';
+import responseMiddleware from './config/response/response.js';
+import errorMiddleware from './config/response/error.js';
+import pkg from 'body-parser';
+import cors from 'cors';
+// import swagger from 'swagger-ui-express';
+// import { swaggerConfig } from './config/swagger/swagger.js';
+
+const { json, urlencoded } = pkg;
+
+const env=dotenv.config();
+
+const app = express();
+const PORT = process.env.PORT || 3000;
+
+
+if ( env.error ) {
+  logger.error( '.env not found' );
+  process.exit( 1 );
+}
+app.use( cors() );
+app.use( responseMiddleware );
+app.use( errorMiddleware );
+app.use( json( { limit: '500mb' } ) );
+app.use(
+    urlencoded( {
+      extended: true,
+    } ),
+);
+app.use( '/zoneTagging', zoneTaggingRouter );
+// app.use( '/api-docs', swagger.serve, swagger.setup( swaggerConfig ) );
+
+app.listen( PORT, () => {
+  connectdb();
+} );
+
+

package/package.json

@@ -1,11 +1,11 @@
 {
     "name": "tango-app-api-store-zone",
-    "version": "3.3.1-beta.0",
+    "version": "3.3.1-beta.10",
     "description": "zone",
-    "main": "index.js",
+    "main": "app.js",
     "type": "module",
     "scripts": {
-        "start": "nodemon --exec \"eslint --fix . && node index.js\""
+        "start": "nodemon --exec \"eslint --fix . && node app.js\""
     },
     "engines": {
         "node": ">=18.10.0"
@@ -17,12 +17,12 @@
         "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.0.115",
-        "tango-app-api-middleware": "^3.1.19",
+        "tango-api-schema": "^2.3.26",
+        "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 {
@@ -15,6 +17,9 @@ export const addCustomTag = async ( req, res ) => {
         clientId: inputData.clientId,
         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 } );
       await taggingService.create( data );
@@ -28,8 +33,8 @@ export const addCustomTag = async ( req, res ) => {
       date: new Date(),
       logType: 'zone',
       logSubType: 'addCustomTag',
-      changes: [ `${inputData.tagName} customtag Created.` ],
-      eventType: '',
+      changes: [ `${inputData.tagName} custom tag` ],
+      eventType: 'create',
       showTo: [ 'client', 'tango' ],
     };
     insertOpenSearchData( JSON.parse( process.env.OPENSEARCH )?.activityLog, logObj );
@@ -42,7 +47,7 @@ export const addCustomTag = async ( req, res ) => {
 
 export const customTagList = async ( req, res ) => {
   try {
-    let customTagList = [ 'Front', 'Back' ];
+    let customTagList = [ 'Front', 'Back', 'Tracker-in', 'Tracker-out' ];
     let storeDetails = await storeService.findOne( { storeId: req.query.storeId }, { product: 1 } );
     let clientDetails = await clientService.findOne( { clientId: req.query.clientId }, { featureConfigs: 1 } );
     if ( clientDetails && clientDetails?.featureConfigs?.isExcludedArea ) {
@@ -54,7 +59,10 @@ export const customTagList = async ( req, res ) => {
     if ( storeDetails && storeDetails?.product.includes( 'tangoZone' ) ) {
       customTagList = customTagList.concat( [ 'Entry/Exit', 'Billing' ] );
     }
-    let tagInfo = await taggingService.find( { clientId: req.query.clientId }, { tagName: 1 } );
+    let tagInfo = await taggingService.find( { clientId: req.query.clientId }, { tagName: 1, rgbColor: 1, rgbBorderColor: 1 } );
+
+    const allTags = tagInfo;
+
     let deletedTag = await taggingService.find( { clientId: req.query.clientId, isDeleted: true }, { storeId: 1, tagName: 1 } );
     tagInfo = [ ...new Set( tagInfo.map( ( item ) => item.tagName ) ) ];
     deletedTag.forEach( ( item ) => {
@@ -90,10 +98,13 @@ export const customTagList = async ( req, res ) => {
           tagName: '$_id',
           count: 1,
 
+
         },
       },
     ];
     let taggingDetails = await taggingService.aggregate( query );
+
+
     customTagList = customTagList.map( ( item ) => {
       let count = '';
       if ( taggingDetails.length ) {
@@ -107,12 +118,231 @@ export const customTagList = async ( req, res ) => {
       return { tagName: item, count: count };
     } );
     customTagList.sort( ( a, b ) => a.count > b.count ? -1 : 1 );
+
+    const allTagsMap = new Map( allTags.map( ( tag ) => [ tag.tagName, tag ] ) );
+
+    customTagList.forEach( ( i ) => {
+      const matchingTag = allTagsMap.get( i.tagName );
+      if ( matchingTag ) {
+        i.rgbColor = matchingTag.rgbColor;
+        i.rgbBorderColor = matchingTag.rgbBorderColor;
+      }
+
+      if ( i.tagName === 'Front' ) {
+        i.rgbColor = 'rgba(89, 80, 5, 0.5)';
+        i.rgbBorderColor = 'rgb(99, 90, 15)';
+      }
+      if ( i.tagName === 'Back' ) {
+        i.rgbColor = 'rgba(94, 60, 107, 0.5)';
+        i.rgbBorderColor = 'rgb(104, 70, 117)';
+      }
+      if ( i.tagName === 'Excluded Area' ) {
+        i.rgbColor = 'rgba(186, 60, 214, 0.5)';
+        i.rgbBorderColor = 'rgb(196, 70, 224)';
+      }
+      if ( i.tagName === 'Passer By' ) {
+        i.rgbColor = 'rgba(81, 153, 247, 0.5)';
+        i.rgbBorderColor = 'rgb(91, 163, 257)';
+      }
+      if ( i.tagName === 'Entry/Exit' ) {
+        i.rgbColor = 'rgba(224, 43, 170, 0.5)';
+        i.rgbBorderColor = 'rgb(234, 53, 180)';
+      }
+      if ( i.tagName === 'Billing' ) {
+        i.rgbColor = 'rgba(193, 214, 114, 0.5)';
+        i.rgbBorderColor = 'rgb(203, 224, 124)';
+      }
+      if ( i.tagName === 'Tracker-in' ) {
+        i.rgbColor = 'rgba(123, 95, 105, 0.5)';
+        i.rgbBorderColor = 'rgb(133, 105, 115)';
+      }
+      if ( i.tagName === 'Tracker-out' ) {
+        i.rgbColor = 'rgba(12, 195, 111, 0.5)';
+        i.rgbBorderColor = 'rgb(22, 205, 125)';
+      }
+    } );
+
     return res.sendSuccess( customTagList );
   } catch ( e ) {
     logger.error( { error: e, function: 'customTagList' } );
     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: 'tangoTracker' },
+      { tagName: 'Tracker-out', productName: 'tangoTracker' },
+    ];
+
+    // 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 {
@@ -128,6 +358,7 @@ export const tagging = async ( req, res ) => {
       }
     } );
     let taggingDetails = await taggingService.findOne( { clientId: InputData.clientId, storeId: InputData.storeId, cameraId: InputData.cameraId, tagName: InputData.tagName, isDeleted: false } );
+
     if ( !taggingDetails ) {
       const logObj = {
         clientId: InputData.clientId,
@@ -137,11 +368,18 @@ export const tagging = async ( req, res ) => {
         date: new Date(),
         logType: 'zone',
         logSubType: 'addZoneTagging',
-        changes: [ `${InputData.tagName} zone added tagging` ],
-        eventType: '',
+        changes: [ `${InputData.tagName} zone tagging` ],
+        eventType: 'create',
         showTo: [ 'client', 'tango' ],
       };
       insertOpenSearchData( JSON.parse( process.env.OPENSEARCH )?.activityLog, logObj );
+      if ( InputData.coordinates[0].color ) {
+        InputData = { ...InputData, rgbColor: InputData.coordinates[0].color };
+      }
+
+      if ( InputData.coordinates[0].rgbBorderColor ) {
+        InputData = { ...InputData, rgbBorderColor: InputData.coordinates[0].rgbBorderColor };
+      }
       let response = await taggingService.create( InputData );
       await taggingService.deleteOne( { clientId: InputData.clientId, storeId: InputData.storeId, cameraId: { $exists: false }, tagName: InputData.tagName } );
       axios.post( `${JSON.parse( process.env.URL ).oldapidomain}/tagging/oldTaggingAdd`, [ response ], { headers: { Authorization: 'Bearer d47433f8-9a33-47c7-ba43-1a0fbac28f66' } } ).then( ( res ) => logger.info( res?.data ) ).catch( ( error ) => logger.error( { error: error } ) );
@@ -154,12 +392,33 @@ export const tagging = async ( req, res ) => {
         date: new Date(),
         logType: 'zone',
         logSubType: 'updateZoneTagging',
-        changes: [ `${InputData.tagName} zone Updated tagging` ],
-        eventType: '',
+        changes: [ `${InputData.tagName} zone tagging` ],
+        eventType: 'update',
+        taggingId: taggingDetails._id,
+        previous: [
+          JSON.parse( JSON.stringify( taggingDetails ) ),
+        ],
+        current: {
+          ...taggingDetails.toObject(),
+        },
+        oldData: {
+          tagName: taggingDetails.tagName,
+          streamName: taggingDetails.streamName,
+        },
+        newData: {
+          tagName: taggingDetails.tagName,
+          streamName: taggingDetails.streamName,
+        },
+        showTo: [ 'tango', 'client' ],
       };
+
+      delete logObj?.current?.coordinates;
+
       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();
@@ -192,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',
@@ -256,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 );
@@ -286,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;
@@ -297,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 );
@@ -327,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 {
@@ -364,17 +708,32 @@ export const updateTag = async ( req, res ) => {
       date: new Date(),
       logType: 'zone',
       logSubType: 'updateCustomTag',
-      changes: [ `${req.body.tagName} tagName Updated` ],
-      eventType: '',
-      showTo: [ 'client', 'tango' ],
+      changes: [ `${req.body.tagName} tagName` ],
+      eventType: 'update',
+      previous: {
+        tagName: req.body.existTag,
+      },
+      current: {
+        tagName: req.body.tagName,
+      },
+      oldData: {
+        tagName: req.body.existTag,
+      },
+      newData: {
+        tagName: req.body.tagName,
+      },
+      showTo: [ 'tango', 'client' ],
     };
     insertOpenSearchData( JSON.parse( process.env.OPENSEARCH )?.activityLog, logObj );
     if ( tagUpdate.modifiedCount || tagUpdate.matchedCount ) {
+      await externalService.updateMany( { zoneName: req.body.existTag, clientId: req.body.clientId }, { zoneName: req.body.tagName } );
       logger.info( 'Custom Tag Updated Successfully' );
-      return res.sendSuccess( 'Custom Tag Updated Successfully' );
+      updateJsonFile( req, res );
+      res.sendSuccess( 'Custom Tag Updated Successfully' );
+    } else {
+      logger.error( { error: 'something went wrong', function: 'updateTag' } );
+      return res.sendError( 'something went wrong', 500 );
     }
-    logger.error( { error: 'something went wrong', function: 'updateTag' } );
-    return res.sendError( 'something went wrong', 500 );
   } catch ( e ) {
     logger.error( { error: e, function: 'updateTag' } );
     return res.sendError( e, 500 );
@@ -429,9 +788,9 @@ export const deleteTag = async ( req, res ) => {
       email: req.user?.email,
       date: new Date(),
       logType: 'zone',
-      logSubType: 'deleteTag',
-      changes: [ `${req.body.tagName} tag Deleted` ],
-      eventType: '',
+      logSubType: 'deleteCustomTag',
+      changes: [ `${req.body.tagName} tag` ],
+      eventType: 'delete',
       showTo: [ 'client', 'tango' ],
     };
     insertOpenSearchData( JSON.parse( process.env.OPENSEARCH )?.activityLog, logObj );
@@ -622,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;
@@ -634,3 +1015,29 @@ export const deletezoneTagging = async ( req, res ) => {
     await updatezoneTagging( req, res );
   } );
 };
+
+async function updateJsonFile( req, res ) {
+  if ( req.body.clientId ) {
+    let tagDetails = await taggingService.find( { clientId: req.body.clientId, tagName: req.body.tagName }, { storeId: 1 } );
+    if ( tagDetails.length ) {
+      for ( let item of tagDetails ) {
+        req.body.storeId = item.storeId;
+        let camDetails = await getCamTaggingDetails( req, res );
+        if ( !camDetails ) {
+          logger.error( { message: 'no data', store: item.storeId } );
+        }
+        let fileData = {
+          Key: `${req.body.storeId}/zonetagging/`,
+          fileName: `${req.body.storeId}_zonetagging.json`,
+          Bucket: JSON.parse( process.env.BUCKET ).zoneTaggingImage,
+          body: JSON.stringify( camDetails ),
+          ContentType: 'application/json',
+        };
+        let upload = await fileUpload( fileData );
+        if ( !upload.Key ) {
+          logger.error( { message: `JSON Upload Error`, store: item.storeId } );
+        }
+      }
+    }
+  }
+};

package/src/dtos/validation.dtos.js

@@ -4,6 +4,9 @@ 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(),
 } );
 
 export const validateAddTagParams = {
@@ -50,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 = {

package/src/routes/zoneTagging.routes.js

@@ -1,22 +1,25 @@
 
 
 import express from 'express';
-import { isAllowedSessionHandler, validate, authorize } from 'tango-app-api-middleware';
+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';
 
 export const zoneTaggingRouter = express.Router();
 
-zoneTaggingRouter.post( '/addCustomTag', isAllowedSessionHandler, authorize( { userType: [ 'tango', 'client' ], access: [ { featureName: 'analytics', name: 'tangoZone', permissions: [ 'isEdit' ] } ] } ), validate( validation.validateAddTagParams ), tagController.addCustomTag );
-zoneTaggingRouter.get( '/customTagList', isAllowedSessionHandler, authorize( { userType: [ 'tango', 'client' ], access: [ { featureName: 'analytics', name: 'tangoZone', permissions: [ 'isView' ] } ] } ), validate( validation.validateTagParams ), tagController.customTagList );
-zoneTaggingRouter.post( '/tagging', isAllowedSessionHandler, authorize( { userType: [ 'tango', 'client' ], access: [ { featureName: 'analytics', name: 'tangoZone', permissions: [ 'isEdit' ] } ] } ), validate( validation.validateTaggingParams ), tagController.tagging );
-zoneTaggingRouter.get( '/cameraList', isAllowedSessionHandler, authorize( { userType: [ 'tango', 'client' ], access: [ { featureName: 'analytics', name: 'tangoZone', permissions: [ 'isView' ] } ] } ), validate( validation.validateTagParams ), tagController.getCameraList );
-zoneTaggingRouter.post( '/updateCustomTag', isAllowedSessionHandler, authorize( { userType: [ 'tango', 'client' ], access: [ { featureName: 'analytics', name: 'tangoZone', permissions: [ 'isEdit' ] } ] } ), validate( validation.validateUpdateTagParams ), tagController.updateTag );
-zoneTaggingRouter.post( '/deleteCustomTag', isAllowedSessionHandler, authorize( { userType: [ 'tango', 'client' ], access: [ { featureName: 'analytics', name: 'tangoZone', permissions: [ 'isDelete' ] } ] } ), validate( validation.validateDeleteTagParams ), tagController.deleteTag );
-zoneTaggingRouter.get( '/getCameraTagging', isAllowedSessionHandler, authorize( { userType: [ 'tango', 'client' ], access: [ { featureName: 'analytics', name: 'tangoZone', permissions: [ 'isView' ] } ] } ), validate( validation.validateCameraTagParams ), tagController.getCameraTagging );
-zoneTaggingRouter.get( '/getZoneTagging', isAllowedSessionHandler, authorize( { userType: [ 'tango', 'client' ], access: [ { featureName: 'analytics', name: 'tangoZone', permissions: [ 'isView' ] } ] } ), validate( validation.validateZonetagParams ), tagController.getZoneList );
-zoneTaggingRouter.post( '/updatezoneTagging', isAllowedSessionHandler, authorize( { userType: [ 'tango', 'client' ], access: [ { featureName: 'analytics', name: 'tangoZone', permissions: [ 'isEdit' ] } ] } ), validate( validation.validateCamZonetagParams ), tagController.updatezoneTagging );
-zoneTaggingRouter.post( '/deleteZoneTag', isAllowedSessionHandler, authorize( { userType: [ 'tango', 'client' ], access: [ { featureName: 'analytics', name: 'tangoZone', permissions: [ 'isEdit' ] } ] } ), validate( validation.updateCoordinatesParams ), tagController.deletezoneTagging );
+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( '/updateCamera', isAllowedSessionHandler, accessVerification( { userType: [ 'tango', 'client' ], access: [ { featureName: 'TangoEye', name: 'ZoneTag', permissions: [ 'isEdit' ] } ] } ), tagController.updateCamera );
 
 zoneTaggingRouter.get( '/updateOldZone', tagController.updateOldData );
 

package/src/services/external.service.js

@@ -17,4 +17,8 @@ export const deleteMany = async ( query = {} ) => {
   return await model.externalParameterModel.deleteMany( query );
 };
 
+export const updateMany = async ( query = {}, record={} ) => {
+  return await model.externalParameterModel.updateMany( query, { $set: record } );
+};
+
 

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 );
+};
+
+