tango-app-api-store-zone 3.1.0 → 3.1.2

package/.eslintrc.cjs

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

package/index.js

@@ -1,7 +1,7 @@
 
 
-import { zoneTaggingRouter } from './src/routes/zoneTagging.routes.js';
-// import { zoneDocs } from './src/docs/zone.docs.js';
+import { zoneRouter } from './src/routes/zone.routes.js';
+
+export { zoneRouter };
 
-export { zoneTaggingRouter };
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-store-zone",
-    "version": "3.1.0",
+    "version": "3.1.2",
     "description": "zone",
     "main": "index.js",
     "type": "module",
@@ -13,16 +13,14 @@
     "author": "praveenraj",
     "license": "ISC",
     "dependencies": {
-        "aws-sdk": "^2.1607.0",
+        "aws-sdk": "^2.1617.0",
         "dotenv": "^16.4.5",
         "express": "^4.19.2",
-        "handlebars": "^4.7.8",
-        "joi-to-swagger": "^6.2.0",
-        "mongodb": "^6.5.0",
+        "mongodb": "^6.6.1",
         "nodemon": "^3.1.0",
         "swagger-ui-express": "^5.0.0",
-        "tango-api-schema": "^2.0.102",
-        "tango-app-api-middleware": "^3.1.10",
+        "tango-api-schema": "^2.0.104",
+        "tango-app-api-middleware": "^3.1.11",
         "winston": "^3.13.0",
         "winston-daily-rotate-file": "^5.0.0"
     },

package/script-new.js

@@ -0,0 +1,388 @@
+const fs = require( 'fs' );
+const path = require( 'path' );
+const { execSync } = require( 'child_process' );
+// Define folder structure
+const createProjectStructure = async ( folderName ) => {
+  const folders = [
+    `src`,
+    `src/controllers`,
+    `src/routes`,
+    `config`,
+    `config/database`,
+    `config/response`,
+    `config/env`,
+  ];
+
+  // Create folders
+  folders.forEach( ( folder ) => {
+    const folderPath = path.join( __dirname, folder );
+    fs.mkdirSync( folderPath, { recursive: true } );
+  } );
+
+  // Create index.js file
+  const indexjsContent = `
+ 
+    import { ${folderName}Router } from './src/routes/${folderName}.routes.js';
+    
+   export {  ${folderName}Router };
+    
+  `;
+  fs.writeFileSync(
+      path.join( __dirname, `/`, 'index.js' ),
+      indexjsContent,
+  );
+
+  // Create app.js file
+  const appContent = `
+  import express from 'express';
+  import { ${folderName}Router } 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';
+  
+  const { json, urlencoded } = pkg;
+  const env=dotenv.config();
+ 
+  const app = express();
+  const PORT = process.env.PORT || 3000;
+  
+ 
+  app.use( json( { limit: '500mb' } ) );
+  app.use(
+      urlencoded( {
+        extended: true,
+      } ),
+  );
+  app.use( responseMiddleware );
+  app.use( errorMiddleware );
+  
+  if ( env.error ) {
+    logger.error( '.env not found' );
+    process.exit( 1 );
+  }
+ 
+ 
+  app.use(\`/\${folderName}\', ${folderName}Router);
+  
+  app.listen(PORT, () => {
+    logger.info(\`server is running on port= \${PORT} \`);
+    connectdb();
+  });
+  
+`;
+  fs.writeFileSync(
+      path.join( __dirname, `/`, 'app.js' ),
+      appContent,
+  );
+
+  // Create route.js file
+  const appJsContent = `
+    import express from 'express';
+    
+    export const ${folderName}Router = express.Router();
+    
+    ${folderName}Router.get('/', (req, res) => {
+      res.send('Hello, world!');
+    });
+    
+    
+  `;
+  fs.writeFileSync(
+      path.join( __dirname, `/src/routes`, `${folderName}.routes.js` ),
+      appJsContent,
+  );
+
+  // Create package.json file
+  const packageJsonContent = `
+{
+    "name": "${folderName}",
+    "version": "1.0.0",
+    "description": "${folderName}",
+    "main": "app.js",
+    "type": "module",
+    "scripts": {
+      "start": "nodemon --exec \\"eslint --fix . && node app.js\\""
+    },
+    "engines": {
+      "node": ">=18.10.0"
+    },
+    "author": "praveenraj",
+    "license": "ISC"
+ 
+}
+`;
+  fs.writeFileSync(
+      path.join( __dirname, 'package.json' ),
+      packageJsonContent,
+  );
+
+  // Create .eslintrc.js file
+  const eslintrcContent = `
+  module.exports = {
+    'env': {
+      'es2021': true,
+      'node': true,
+    },
+    'extends': 'google',
+    'overrides': [
+      {
+        'env': {
+          'node': true,
+        },
+        'files': [
+          '.eslintrc.{js,cjs}',
+        ],
+        'parserOptions': {
+          'sourceType': 'script',
+        },
+      },
+    ],
+    'parserOptions': {
+      'ecmaVersion': 'latest',
+      'sourceType': 'module',
+    },
+    'rules': {
+      'linebreak-style': [ 'error', 'windows' ],
+      'require-jsdoc': 'off',
+      'arrow-spacing': 'error',
+      'key-spacing': [ 'error', { 'beforeColon': false, 'afterColon': true } ],
+      'object-curly-spacing': [ 'error', 'always' ],
+      'space-in-parens': [ 'error', 'always' ],
+      'keyword-spacing': 'error',
+      'array-bracket-spacing': [ 'error', 'always' ],
+      'spaced-comment': [ 'error', 'always' ],
+      'max-len': [ 'error', { 'code': 700 } ],
+      'no-unused-vars': 'error',
+      'new-cap': [ 'error', { 'newIsCap': true, 'capIsNew': false } ],
+      'prefer-const': 'off',
+    },
+  };
+  
+`;
+  fs.writeFileSync(
+      path.join( __dirname, '.eslintrc.cjs' ),
+      eslintrcContent,
+  );
+
+  // Create .env file
+  const envContent = `
+    PORT=3001
+    AWS_ACCESS_KEY_ID=AKIAQSSPN5BZSDAZHWB2
+    AWS_SECRET_ACCESS_KEY=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
+    
+    mongo_username= tangoeye
+    mongo_password= SUTONQosEUijJKWC
+    
+    ELASTIC_CLOUD_ID=
+    ELASTIC_USERNAME=
+    ELASTIC_PASSWORD=
+    ELASTIC_NODE=
+    
+  `;
+  fs.writeFileSync( path.join( __dirname, '.env' ), envContent );
+
+  // Create database.js file
+  const databaseContent = `
+  import appConfig from '../../config/env/env.js';
+  import mongoose from 'mongoose';
+  import { logger } from 'tango-app-api-middleware';
+  
+  export function getConnection() {
+    appConfig.database.mongo.username = process.env.mongo_username;
+    appConfig.database.mongo.password = process.env.mongo_password;
+  
+    const options = {
+      useNewUrlParser: true,
+      useUnifiedTopology: true,
+    };
+    let connectionString;
+  
+    if (appConfig.database.mongo.authSource) {
+      connectionString = \`\${appConfig.database.mongo.hostname}/\${appConfig.database.mongo.name}?\${appConfig.database.mongo.authSource}\`;
+    }
+  
+    if (appConfig.database.mongo.username && appConfig.database.mongo.password) {
+      connectionString = \`\${appConfig.database.mongo.username}:\${appConfig.database.mongo.password}@\${appConfig.database.mongo.hostname}/\${appConfig.database.mongo.name}\`;
+    } else {
+      connectionString = \`\${appConfig.database.mongo.hostname}/\${appConfig.database.mongo.name}\`;
+    }
+    if (appConfig.database.mongo.authSource) {
+      connectionString = \`mongodb+srv://\${connectionString}\`;
+    } else {
+      connectionString = \`mongodb://\${connectionString}\`;
+    }
+    return { uri: \`\${connectionString}\`, options };
+  }
+  
+  export function connectdb() {
+    const db = getConnection();
+    // Establish Connection
+    mongoose.connect(db.uri, db.options);
+  
+    // Mongoose Events
+    mongoose.connection.on('connected', () => {
+      logger.info('Mongoose connected with MongoDB: ' + new Date().toISOString());
+    });
+  
+    // Event: Disconnected
+    mongoose.connection.on('disconnected', () => {
+      logger.log('MongoDB Connection Closed: ' + new Date().toISOString());
+    });
+  
+    // Event: Error
+    mongoose.connection.on('error', (error) => {
+      logger.error(error);
+    });
+  }
+  `;
+
+  fs.writeFileSync(
+      path.join( __dirname, `/config/database`, `database.js` ),
+
+      databaseContent,
+  );
+
+  // Create logger.js file
+  // const loggerContent = `
+  //   import winston from 'winston';
+  //   import DailyRotateFile from 'winston-daily-rotate-file';
+
+  //   export const logger = winston.createLogger( {
+  //     level: 'info',
+  //     format: winston.format.combine(
+  //         winston.format.errors( { stack: true } ),
+  //         winston.format.timestamp(),
+  //         winston.format.prettyPrint(),
+  //         winston.format.colorize(),
+  //     ),
+  //     transports: [
+  //       new DailyRotateFile( {
+  //         filename: \`error-%DATE%.log\`,
+  //         dirname: \`storage/logs/\`,
+  //         datePattern: 'YYYY-MM-DD',
+  //         zippedArchive: true,
+  //         maxFiles: '2d',
+  //         maxSize: '2g',
+  //         level: 'error',
+  //       } ),
+  //       new DailyRotateFile( {
+  //         filename: \`application-%DATE%.log\`,
+  //         dirname: \`storage/logs/\`,
+  //         datePattern: 'YYYY-MM-DD',
+  //         zippedArchive: true,
+  //         maxFiles: '2d',
+  //         maxSize: '2g',
+  //       } ),
+  //     ],
+  //   } );
+
+
+  //   `;
+  // fs.writeFileSync(
+  //     path.join( __dirname, `/config/logger`, `logger.js` ),
+
+  //     loggerContent,
+  // );
+  // console.log( `Folder structure for ${folderName} created successfully.` );
+
+
+  // Create database.js file
+  const envjsContent = `
+  const appConfig = {
+    app: {
+      environment: 'development',
+    },
+    api: {
+      version: [ 'v3' ],
+    },
+    url: {
+      admin: '',
+      audit: '',
+    },
+    database: {
+      mongo: {
+        hostname: 'serverlessinstance-1.o0iqto1.mongodb.net',
+        name: 'tango-api-uat',
+      },
+      postgre: {},
+    },
+    cloud: {
+      aws: {
+        region: 'ap-south-1',
+        secertManager: 'tango-api-dev',
+        sqs: {
+          url: '',
+        },
+        bucket: {
+          name: '',
+        },
+        version: 'v4',
+      },
+      elasticSearch: {
+        cloud: {
+          id: process.env.ELASTIC_CLOUD_ID,
+        },
+        auth: {
+          username: process.env.ELASTIC_USERNAME,
+          password: process.env.ELASTIC_PASSWORD,
+        },
+      //  node: process.env.ELASTIC_NODE,
+      },
+    },
+  
+  };
+  
+  export default appConfig;
+  
+  `;
+
+  fs.writeFileSync(
+      path.join( __dirname, `/config/env`, `env.js` ),
+      envjsContent,
+  );
+
+  // Install specific dependencies
+  console.log( 'Installing dependencies...', {
+    cwd: path.join( __dirname ),
+  } );
+  try {
+    const gitignoreContent = [
+      'node_modules/',
+      'package-lock.json',
+      'storage/',
+      'config/',
+      'app.js',
+      '.env',
+    ].join( '\r\n' ); // Use Windows-style line endings
+
+    // Write content to .gitignore
+    fs.writeFileSync( path.join( __dirname, '.gitignore' ), gitignoreContent );
+
+    // Install npm dependencies
+    const npmCommand = 'npm install express mongodb aws-sdk nodemon tango-api-schema tango-app-api-middleware winston winston-daily-rotate-file dotenv';
+    execSync( npmCommand, { cwd: path.join( __dirname ), stdio: 'inherit' } );
+
+    console.log( 'Dependencies installed successfully.' );
+  } catch ( error ) {
+    console.error( 'Error occurred while installing dependencies:', error );
+  }
+
+  // Install specific dependencies as devDependencies
+  console.log( 'Installing devDependencies...' );
+  try {
+    await execSync(
+        ' npm install --save-dev eslint eslint-config-google eslint-config-semistandard eslint-config-standard eslint-plugin-import eslint-plugin-promise',
+        { cwd: path.join( __dirname ) },
+    );
+    console.log( 'devDependencies installed successfully.' );
+  } catch ( error ) {
+    console.error( 'Error occurred while installing devDependencies:', error );
+  }
+};
+
+// Usage: node createProjectStructure.js myapi
+createProjectStructure( process.argv[2] );

package/src/controllers/zoneTagging.controller.js

@@ -13,7 +13,7 @@ export const addCustomTag = async ( req, res ) => {
         storeId: inputData.storeId,
         tagName: inputData.tagName,
       };
-      await taggingService.deleteMany( { clientId: inputData.clientId, tagName: inputData.tagName, isDeleted: true } );
+      await taggingService.deleteMany( { clientId: inputData.clientId, storeId: inputData.storeId, tagName: inputData.tagName, isDeleted: true } );
       await taggingService.create( data );
     }
     logger.info( 'Tag Created Successfully' );
@@ -23,12 +23,13 @@ export const addCustomTag = async ( req, res ) => {
       userName: req.user?.userName,
       email: req.user?.email,
       date: new Date(),
-      logType: 'add Zone',
-      logSubType: inputData.tagName,
-      changes: [ ],
-      eventType: 'add',
+      logType: 'zone',
+      logSubType: 'addCustomTag',
+      changes: [ `${inputData.tagName} customtag Created.` ],
+      eventType: '',
+      showTo: [ 'client', 'tango' ],
     };
-    insertOpenSearchData( 'tango-retail-activity-logs', logObj );
+    insertOpenSearchData( appConfig.opensearch.activityLog, logObj );
     return res.sendSuccess( 'Tag Created Successfully' );
   } catch ( e ) {
     logger.error( { error: 'e', function: 'addCustomTag' } );
@@ -43,16 +44,17 @@ export const customTagList = async ( req, res ) => {
     customTagList.push( ...defaultZone );
     let tagInfo = await taggingService.find( { clientId: req.query.clientId }, { tagName: 1 } );
     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 ) => {
-      let findTag = tagInfo.findIndex( ( tag ) => tag.tagName == item.tagName && item.storeId == req.query.storeId );
+      let findTag = tagInfo.findIndex( ( tag ) => tag == item.tagName && item.storeId == req.query.storeId );
       if ( findTag != -1 ) {
         tagInfo.splice( findTag, 1 );
       }
     } );
     if ( tagInfo.length ) {
       tagInfo.forEach( ( item ) => {
-        if ( !customTagList.includes( item.tagName ) ) {
-          customTagList.push( item.tagName );
+        if ( !customTagList.includes( item ) ) {
+          customTagList.push( item );
         }
       } );
     }
@@ -113,14 +115,16 @@ export const tagging = async ( req, res ) => {
         userName: req.user?.userName,
         email: req.user?.email,
         date: new Date(),
-        logType: 'add Zone Tagging',
-        logSubType: InputData.tagName,
-        changes: [ 'coordinates' ],
-        eventType: 'add Tagging',
+        logType: 'zone',
+        logSubType: 'addZoneTagging',
+        changes: [ `${InputData.tagName} zone added tagging` ],
+        eventType: '',
+        showTo: [ 'client', 'tango' ],
       };
-      insertOpenSearchData( 'tango-retail-activity-logs', logObj );
-      await taggingService.create( InputData );
+      insertOpenSearchData( appConfig.opensearch.activityLog, logObj );
+      let response = await taggingService.create( InputData );
       await taggingService.deleteOne( { clientId: InputData.clientId, storeId: InputData.storeId, cameraId: { $exists: false }, tagName: InputData.tagName } );
+      await axios.post( `${appConfig.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 } ) );
     } else {
       const logObj = {
         clientId: InputData.clientId,
@@ -128,12 +132,12 @@ export const tagging = async ( req, res ) => {
         userName: req.user?.userName,
         email: req.user?.email,
         date: new Date(),
-        logType: 'add Zone Tagging',
-        logSubType: InputData.tagName,
-        changes: [ 'coordinates' ],
-        eventType: 'update Tagging',
+        logType: 'zone',
+        logSubType: 'updateZoneTagging',
+        changes: [ `${InputData.tagName} zone Updated tagging` ],
+        eventType: '',
       };
-      insertOpenSearchData( 'tango-retail-activity-logs', logObj );
+      insertOpenSearchData( appConfig.opensearch.activityLog, logObj );
       taggingDetails.cameraId = InputData.cameraId;
       taggingDetails.streamName = InputData.streamName;
       if ( req.body?.redoPoint ) {
@@ -143,6 +147,11 @@ export const tagging = async ( req, res ) => {
         if ( InputData.coordinates[0].coor.length ) {
           taggingDetails.coordinates.push( InputData.coordinates[0] );
           taggingDetails.save();
+          await axios.post( `${appConfig.url.oldapidomain}/tagging/oldTaggingUpdate/${taggingDetails._id}`, taggingDetails, { headers: { Authorization: 'Bearer d47433f8-9a33-47c7-ba43-1a0fbac28f66' } } ).then( ( res ) => {
+            logger.info( res?.data );
+          } ).catch( ( error ) => {
+            logger.error( { error: error } );
+          } );
         } else {
           return res.sendError( 'coordinate is required', 500 );
         }
@@ -195,7 +204,7 @@ export const getCameraList = async ( req, res ) => {
         baseImg: '',
         tagImg: '',
       };
-      let taggingDetails = await taggingService.find( { cameraId: camera._id, streamName: camera.streamName, clientId: req.query.clientId }, { tagName: 1, coordinates: 1 } );
+      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.map( ( item ) => {
           if ( item.coordinates.length ) {
@@ -255,24 +264,32 @@ export const updateTag = async ( req, res ) => {
     if ( !taggingDetails ) {
       return res.sendError( 'no data found', 204 );
     }
-    let tagUpdate = await taggingService.updateMany( { clientId: req.body.clientId, tagName: req.body.existTag, isDeleted: false }, { tagName: req.body.tagName } );
-    await taggingService.deleteMany( { clientId: req.body.clientId, tagName: req.body.tagName, isDeleted: true } );
+    let tagUpdate = await taggingService.updateMany( { clientId: req.body.clientId, tagName: req.body.existTag }, { tagName: req.body.tagName } );
+    // await taggingService.deleteMany( { clientId: req.body.clientId, tagName: req.body.existTag, isDeleted: true } );
     if ( tagUpdate.modifiedCount ) {
       logger.info( 'Custom Tag Updated Successfully' );
       return res.sendSuccess( 'Custom Tag Updated Successfully' );
     }
+    taggingDetails.forEach( async ( item ) => {
+      await axios.post( `${appConfig.url.oldapidomain}/tagging/oldTaggingUpdate/${item._id}`, item, { headers: { Authorization: 'Bearer d47433f8-9a33-47c7-ba43-1a0fbac28f66' } } ).then( ( res ) => {
+        logger.info( res?.data );
+      } ).catch( ( error ) => {
+        logger.error( { error: error } );
+      } );
+    } );
     const logObj = {
       clientId: req.body.clientId,
       storeId: taggingDetails?.storeId,
       userName: req.user?.userName,
       email: req.user?.email,
       date: new Date(),
-      logType: 'add Zone Tagging',
-      logSubType: req.body.existTag,
-      changes: [ 'tagName' ],
-      eventType: 'update Custom Tag Name',
+      logType: 'zone',
+      logSubType: 'updateCustomTag',
+      changes: [ `${req.body.tagName} tagName Updated` ],
+      eventType: '',
+      showTo: [ 'client', 'tango' ],
     };
-    insertOpenSearchData( 'tango-retail-activity-logs', logObj );
+    insertOpenSearchData( appConfig.opensearch.activityLog, logObj );
     logger.error( { error: 'something went wrong', function: 'updateTag' } );
     return res.sendError( 'something went wrong', 500 );
   } catch ( e ) {
@@ -283,7 +300,7 @@ export const updateTag = async ( req, res ) => {
 
 export const deleteTag = async ( req, res ) => {
   try {
-    let taggingDetails = await taggingService.find( { clientId: req.body.clientId, tagName: req.body.tagName, isDeleted: false }, { storeId: 1 } );
+    let taggingDetails = await taggingService.find( { clientId: req.body.clientId, tagName: req.body.tagName }, { storeId: 1 } );
     if ( !taggingDetails.length ) {
       return res.sendError( 'no data found', 204 );
     }
@@ -302,20 +319,37 @@ export const deleteTag = async ( req, res ) => {
     if ( req.user?.role == 'superadmin' || ( req.user?.role == 'admin' && enableDelete ) ) {
       await taggingService.deleteMany( { clientId: req.body.clientId, tagName: req.body.tagName } );
     } else {
-      await taggingService.updateOne( { clientId: req.body.clientId, storeId: req.body.storeId, tagName: req.body.tagName }, { isDeleted: true } );
+      let deleteTag = await taggingService.updateOne( { clientId: req.body.clientId, storeId: req.body.storeId, tagName: req.body.tagName }, { isDeleted: true } );
+      if ( !deleteTag.modifiedCount ) {
+        let data = {
+          clientId: req.body.clientId,
+          storeId: req.body.storeId,
+          tagName: req.body.tagName,
+          isDeleted: true,
+        };
+        taggingService.create( data );
+      }
     }
+    taggingDetails.forEach( async ( item ) => {
+      await axios.post( `${appConfig.url.oldapidomain}/tagging/oldTaggingDelete/${item._id}`, '', { headers: { Authorization: 'Bearer d47433f8-9a33-47c7-ba43-1a0fbac28f66' } } ).then( ( res ) => {
+        logger.info( res?.data );
+      } ).catch( ( error ) => {
+        logger.error( { error: error } );
+      } );
+    } );
     const logObj = {
       clientId: req.body?.clientId,
       storeId: taggingDetails ? taggingDetails.map( ( item ) => item?.storeId ) : '',
       userName: req.user?.userName,
       email: req.user?.email,
       date: new Date(),
-      logType: 'add Zone Tagging',
-      logSubType: req.body?.tagName,
-      changes: [ 'tagName' ],
-      eventType: 'Delete Tagging Name',
+      logType: 'zone',
+      logSubType: 'deleteTag',
+      changes: [ `${req.body.tagName} tag Deleted` ],
+      eventType: '',
+      showTo: [ 'client', 'tango' ],
     };
-    insertOpenSearchData( 'tango-retail-activity-logs', logObj );
+    insertOpenSearchData( appConfig.opensearch.activityLog, logObj );
     await updatezoneTagging( req, res );
     // return res.sendSuccess( 'Tag Deleted Successfully' );
   } catch ( e ) {
@@ -333,7 +367,7 @@ export const getCameraTagging = async ( req, res ) => {
       return res.sendError( 'no data found', 204 );
     }
     if ( camDetails ) {
-      query = { clientId: req.query.clientId, cameraId: camDetails._id, streamName: camDetails.streamName, storeId: req.query.storeId };
+      query = { clientId: req.query.clientId, cameraId: camDetails._id, streamName: camDetails.streamName, storeId: req.query.storeId, isDeleted: false };
       if ( req.query?.tagName != 'undefined' && req.query?.tagName != '' ) {
         query.tagName = req.query.tagName;
       }
@@ -392,11 +426,11 @@ async function getCamTaggingDetails( req, res ) {
   try {
     let camDetails = await cameraService.find( { storeId: req.body.storeId, isActivated: true, isUp: true } );
     if ( !camDetails.length ) {
-      return res.sendError( 'no data found', 204 );
+      return false;
     }
     let result = [];
     for ( let camera of camDetails ) {
-      let taggingDetails = await taggingService.find( { cameraId: camera._id, streamName: camera.streamName, storeId: req.body.storeId, clientId: camera.clientId } );
+      let taggingDetails = await taggingService.find( { cameraId: camera._id, streamName: camera.streamName, storeId: req.body.storeId, clientId: camera.clientId, isDeleted: false } );
       let zoneList = [];
       if ( taggingDetails.length ) {
         taggingDetails.forEach( ( zone ) => {
@@ -485,8 +519,8 @@ export const updateOldData = async ( req, res ) => {
           if ( !upload.Key ) {
             logger.error( { message: `JSON Upload Error`, store: item.storeId } );
           }
-          if ( index == tagDetails.length-1 ) {
-            return res.sendSuccess( 'Zone Updated Successfully' );
+          if ( index == 0 ) {
+            res.sendSuccess( 'Zone Updated Successfully' );
           }
         } else {
           logger.error( { message: 'no data', store: item.storeId } );

package/src/routes/zone.routes.js

@@ -0,0 +1,10 @@
+
+import express from 'express';
+
+export const zoneRouter = express.Router();
+
+zoneRouter.get( '/', ( req, res ) => {
+  res.send( 'Hello, world!' );
+} );
+
+

package/src/docs/zoneTagging.docs.js

@@ -1,9 +0,0 @@
-
-
-// import * as schema from '../dtos/validation.dtos.js';
-// import j2s from 'joi-to-swagger';
-
-// export const paymentDocs = {
-
-// };
-