tango-app-api-store-zone 3.0.0-dev

package/.eslintrc.cjs

@@ -0,0 +1,42 @@
+
+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',
+    'no-console': 'error',
+  },
+};
+

package/README.md

@@ -0,0 +1,29 @@
+# README #
+
+This README would normally document whatever steps are necessary to get your application up and running.
+
+### What is this repository for? ###
+
+* Quick summary
+* Version
+* [Learn Markdown](https://bitbucket.org/tutorials/markdowndemo)
+
+### How do I get set up? ###
+
+* Summary of set up
+* Configuration
+* Dependencies
+* Database configuration
+* How to run tests
+* Deployment instructions
+
+### Contribution guidelines ###
+
+* Writing tests
+* Code review
+* Other guidelines
+
+### Who do I talk to? ###
+
+* Repo owner or admin
+* Other community or team contact

package/index.js

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

package/package.json

@@ -0,0 +1,37 @@
+{
+    "name": "tango-app-api-store-zone",
+    "version": "3.0.0-dev",
+    "description": "zone",
+    "main": "index.js",
+    "type": "module",
+    "scripts": {
+        "start": "nodemon --exec \"eslint --fix . && node index.js\""
+    },
+    "engines": {
+        "node": ">=18.10.0"
+    },
+    "author": "praveenraj",
+    "license": "ISC",
+    "dependencies": {
+        "aws-sdk": "^2.1607.0",
+        "dotenv": "^16.4.5",
+        "express": "^4.19.2",
+        "handlebars": "^4.7.8",
+        "joi-to-swagger": "^6.2.0",
+        "mongodb": "^6.5.0",
+        "nodemon": "^3.1.0",
+        "swagger-ui-express": "^5.0.0",
+        "tango-api-schema": "^2.0.76",
+        "tango-app-api-middleware": "^1.0.54-dev",
+        "winston": "^3.13.0",
+        "winston-daily-rotate-file": "^5.0.0"
+    },
+    "devDependencies": {
+        "eslint": "^8.57.0",
+        "eslint-config-google": "^0.14.0",
+        "eslint-config-semistandard": "^17.0.0",
+        "eslint-config-standard": "^17.1.0",
+        "eslint-plugin-import": "^2.29.1",
+        "eslint-plugin-promise": "^6.1.1"
+    }
+}

package/src/controllers/zoneTagging.controller.js

@@ -0,0 +1,352 @@
+import { logger } from 'tango-app-api-middleware';
+import * as cameraService from '../services/camera.service.js';
+import * as taggingService from '../services/tagging.service.js';
+import { appConfig, signedUrl, listFileByPath } from 'tango-app-api-middleware';
+import axios from 'axios';
+export const addCustomTag = async ( req, res ) => {
+  try {
+    let inputData = req.body;
+    let taggingDetails = await taggingService.findOne( { clientId: inputData.clientId, storeId: inputData.storeId, tagName: inputData.tagName } );
+    if ( !taggingDetails ) {
+      let data = {
+        clientId: inputData.clientId,
+        storeId: inputData.storeId,
+        tagName: inputData.tagName,
+      };
+      await taggingService.create( data );
+    }
+    logger.info( 'Tag Created Successfully' );
+    return res.sendSuccess( 'Tag Created Successfully' );
+  } catch ( e ) {
+    logger.error( { error: 'e', function: 'addCustomTag' } );
+    return res.sendError( e, 500 );
+  }
+};
+
+export const customTagList = async ( req, res ) => {
+  try {
+    let customTagList = [];
+    let defaultZone = [ 'Entry', 'Exit', 'Billing', 'Excluded Area' ];
+    customTagList.push( ...defaultZone );
+    let tagInfo = await taggingService.find( { clientId: req.query.clientId }, { tagName: 1 } );
+    if ( tagInfo.length ) {
+      tagInfo.forEach( ( item ) => {
+        if ( !customTagList.includes( item.tagName ) ) {
+          customTagList.push( item.tagName );
+        }
+      } );
+    }
+    let query = [
+      {
+        $match: {
+          clientId: req.query.clientId,
+          storeId: req.query.storeId,
+          coordinates: { $exists: true, $ne: [] },
+          tagName: { $in: customTagList },
+        },
+      },
+      {
+        $group: {
+          _id: '$tagName',
+          count: { $sum: 1 },
+        },
+      },
+      {
+        $project: {
+          tagName: '$_id',
+          count: 1,
+
+        },
+      },
+    ];
+    let taggingDetails = await taggingService.aggregate( query );
+    customTagList = customTagList.map( ( item ) => {
+      let count = '';
+      if ( taggingDetails.length ) {
+        let tagCount = taggingDetails.find( ( tag ) => tag._id == item );
+        if ( tagCount ) {
+          count = tagCount.count;
+        }
+      } else {
+        count = 'New';
+      }
+      return { tagName: item, count: count };
+    } );
+    return res.sendSuccess( customTagList );
+  } catch ( e ) {
+    logger.error( { error: e, function: 'customTagList' } );
+    return res.sendError( e, 500 );
+  }
+};
+
+export const tagging = async ( req, res ) => {
+  try {
+    let InputData = req.body;
+    if ( !InputData?.coordinates?.length ) {
+      return res.sendError( 'Tagging is Required', 400 );
+    }
+    let taggingDetails = await taggingService.findOne( { clientId: InputData.clientId, storeId: InputData.storeId, cameraId: InputData.cameraId, tagName: InputData.tagName } );
+    if ( !taggingDetails ) {
+      await taggingService.create( InputData );
+    } else {
+      taggingDetails.cameraId = InputData.cameraId;
+      taggingDetails.streamName = InputData.streamName;
+      taggingDetails.coordinates.push( InputData.coordinates[0] );
+      taggingDetails.save();
+    }
+    // if ( data?._id ) {
+    //   let camDetails = await cameraService.findOne( { _id: InputData.cameraId } );
+    //   if ( camDetails ) {
+    //     if ( camDetails?.tagging ) {
+    //       if ( !camDetails.tagging.includes( data._id ) ) {
+    //         camDetails.tagging.push( data._id );
+    //       }
+    //     } else {
+    //       camDetails = {
+    //         ...camDetails,
+    //         tagging: [ data._id ],
+    //       };
+    //     }
+    //     camDetails.save();
+    //   }
+    // }
+    return res.sendSuccess( 'Tagging Created Successfully' );
+  } catch ( e ) {
+    logger.error( { error: e, function: 'tagging' } );
+    return res.sendError( e, 500 );
+  }
+};
+
+export const getCameraList = 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 } );
+    if ( !cameraDetails.length ) {
+      return res.sendError( 'no data found', 204 );
+    }
+    const folderPath = { file_path: `${req.query.storeId}/zone_base_images/`,
+      Bucket: appConfig.cloud.aws.bucket.baseImage, MaxKeys: 1000,
+    };
+    let fileList = await listFileByPath( folderPath );
+    const TaggedfolderPath = { file_path: `${req.query.storeId}/zone_tagged_image/`,
+      Bucket: appConfig.cloud.aws.bucket.baseImage, 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 }, { tagName: 1, coordinates: 1 } );
+      if ( taggingDetails.length ) {
+        tagList = taggingDetails.map( ( item ) => {
+          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: appConfig.cloud.aws.bucket.baseImage,
+        };
+        const cameraTagImage = await signedUrl( params );
+        camera.tagImg = cameraTagImage;
+      }
+      if ( imgPath ) {
+        const baseParams = { file_path: imgPath,
+          Bucket: appConfig.cloud.aws.bucket.baseImage,
+        };
+        const cameraBaseImage = await signedUrl( baseParams );
+        camera.baseImg = cameraBaseImage;
+      }
+      camera.tagging = tagList;
+      cameraDetails[index] = camera;
+    }
+    return res.sendSuccess( cameraDetails );
+  } catch ( e ) {
+    logger.error( { error: e, function: 'getCameraList' } );
+    return res.sendError( e, 500 );
+  }
+};
+
+export const updateTag = async ( req, res ) => {
+  try {
+    let taggingDetails = await taggingService.findOne( { clientId: req.body.clientId } );
+    if ( !taggingDetails ) {
+      return res.sendError( 'no data found', 204 );
+    }
+    let tagUpdate = await taggingService.updateMany( { clientId: req.body.clientId, tagName: req.body.existTag }, { tagName: req.body.tagName } );
+    if ( tagUpdate.modifiedCount ) {
+      logger.info( 'Custom Tag Updated Successfully' );
+      return res.sendSuccess( 'Custom Tag Updated Successfully' );
+    }
+    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 );
+  }
+};
+
+export const deleteTag = async ( req, res ) => {
+  try {
+    let taggingDetails = await taggingService.find( { clientId: req.body.clientId, tagName: req.body.tagName } );
+    if ( !taggingDetails.length ) {
+      return res.sendError( 'no data found', 204 );
+    }
+    // let cameraList = taggingDetails.map( ( item ) => item.cameraId );
+    // let tagList = taggingDetails.map( ( item ) => item._id );
+    // console.log( cameraList );
+    // console.log( tagList );
+    // await cameraService.updateMany( { _id: { $in: cameraList } }, { $pull: { tagging: { $in: tagList } } } );
+    await taggingService.deleteMany( { clientId: req.body.clientId, tagName: req.body.tagName } );
+    return res.sendSuccess( 'Tag Deleted Successfully' );
+  } catch ( e ) {
+    logger.error( { error: e, function: 'deleteTag' } );
+    return res.sendError( e, 500 );
+  }
+};
+
+export const getCameraTagging = async ( req, res ) => {
+  try {
+    let camDetails = await cameraService.findOne( { _id: req.query.cameraId } );
+    let query;
+    let details;
+    if ( !camDetails ) {
+      return res.sendError( 'no data found', 204 );
+    }
+    if ( camDetails ) {
+      if ( req.query?.tagName != 'undefined' ) {
+        query = { tagName: req.query.tagName, storeId: req.query.storeId, cameraId: camDetails._id, streamName: camDetails.streamName };
+      } else {
+        query = { cameraId: camDetails._id, streamName: camDetails.streamName, storeId: req.query.storeId };
+      }
+      let taggingDetails = await taggingService.find( query );
+      if ( taggingDetails.length ) {
+        let coordinates = [];
+        details = {
+          ...camDetails._doc,
+          coordinate: coordinates,
+        };
+        taggingDetails.forEach( ( item ) => {
+          if ( item?.coordinates.length ) {
+            item.coordinates.forEach( ( coor ) => {
+              details.coordinate.push( coor );
+            } );
+          }
+        } );
+      }
+    } else {
+      details = {
+        ...camDetails._doc,
+        coordinate: [],
+      };
+    }
+
+    if ( !details?.coordinate?.length ) {
+      let getColor = await taggingService.findOne( { tagName: req.query.tagName } );
+      if ( getColor && getColor.coordinates.length ) {
+        return res.sendSuccess( { ...camDetails._doc, coordinate: [], color: getColor.coordinates[0].color, rgbBorderColor: getColor.coordinates[0].rgbBorderColor } );
+      }
+    }
+    return res.sendSuccess( details );
+  } catch ( e ) {
+    logger.error( { error: e, function: 'getCameraTagging' } );
+    return res.sendError( e, 500 );
+  }
+};
+
+export const getZoneList = async ( req, res ) => {
+  try {
+    let taggingDetails = await taggingService.find( { tagName: req.query.tagName, storeId: { $ne: req.query.storeId } } );
+    if ( taggingDetails ) {
+      return res.sendSuccess( true );
+    }
+    return res.sendSuccess( false );
+  } catch ( e ) {
+    logger.error( { error: e, function: 'getZoneList' } );
+    return res.sendError( e, 500 );
+  }
+};
+
+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 );
+    }
+    let result = [];
+    for ( let camera of camDetails ) {
+      let taggingDetails = await taggingService.find( { cameraId: camera._id, streamName: camera.streamName, storeId: req.body.storeId } );
+      let zoneList = [];
+      if ( taggingDetails.length ) {
+        taggingDetails.forEach( ( zone ) => {
+          zone.coordinates.forEach( ( coor ) => {
+            let colorString = coor.color.replace( 'rgba(', '' ).replace( ')', '' );
+            let rgbaColorArray = colorString.split( ',' ).map( ( value ) => parseFloat( value.trim() ) );
+            let borderColorString = coor.rgbBorderColor.replace( 'rgb(', '' ).replace( ')', '' );
+            let rgbBorderColorArray = borderColorString.split( ',' ).map( ( value ) => parseFloat( value.trim() ) );
+            coor.color = rgbaColorArray;
+            coor.rgbBorderColor = rgbBorderColorArray;
+          } );
+          zoneList.push( {
+            zoneName: zone.tagName,
+            coordinates: zone.coordinates,
+          } );
+        } );
+        result.push( {
+          stream_id: camera.streamName,
+          zones: zoneList,
+          totalZone: zoneList.length,
+          storeId: req.body.storeId,
+        } );
+      }
+    }
+
+    return result;
+  } catch ( e ) {
+    logger.error( { error: e, function: 'getCamTaggingDetails' } );
+    return false;
+  }
+};
+
+export const updatezoneTagging = async ( req, res ) => {
+  try {
+    let camDetails = await getCamTaggingDetails( req, res );
+    if ( !camDetails ) {
+      return res.sendError( 'Something Went Wrong', 500 );
+    }
+    const response = await axios.post( appConfig.url.lamdaUrl, camDetails );
+    if ( response?.data?.status && response?.data?.status == 'success' ) {
+      return res.sendSuccess( 'Zone Updated Successfully' );
+    } else {
+      return res.sendError( 'Something went wrong', 500 );
+    }
+  } catch ( e ) {
+    logger.error( { error: e, function: 'getCamTaggingDetails' } );
+    return res.sendError( e, 500 );
+  }
+};

package/src/docs/zoneTagging.docs.js

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

package/src/dtos/validation.dtos.js

@@ -0,0 +1,82 @@
+import joi from 'joi';
+
+export const addTagSchema = joi.object( {
+  clientId: joi.string().required(),
+  tagName: joi.string().required(),
+  storeId: joi.string().required(),
+} );
+
+export const validateAddTagParams = {
+  body: addTagSchema,
+};
+
+export const tagSchema = joi.object( {
+  clientId: joi.string().required(),
+  storeId: joi.string().required(),
+} );
+
+export const validateTagParams = {
+  query: tagSchema,
+};
+
+export const validateUpdateTagSchema = joi.object( {
+  clientId: joi.string().required(),
+  // storeId: joi.string().required(),
+  existTag: joi.string().required(),
+  tagName: joi.string().required(),
+} );
+
+export const validateUpdateTagParams = {
+  body: validateUpdateTagSchema,
+};
+
+
+export const validateDeleteTagSchema = joi.object( {
+  tagName: joi.string().required(),
+  clientId: joi.string().required(),
+  storeId: joi.string().required(),
+} );
+
+export const validateDeleteTagParams = {
+  body: validateDeleteTagSchema,
+};
+
+export const validateTaggingSchema = joi.object( {
+  clientId: joi.string().required(),
+  storeId: joi.string().required(),
+  cameraId: joi.string().required(),
+  tagName: joi.string().required(),
+  coordinates: joi.array().required(),
+  streamName: joi.string().required(),
+} );
+
+export const validateTaggingParams = {
+  body: validateTaggingSchema,
+};
+
+export const validateCameraTagSchema = joi.object( {
+  cameraId: joi.string().required(),
+  tagName: joi.string().optional().empty(),
+  storeId: joi.string().required(),
+} );
+
+export const validateCameraTagParams = {
+  query: validateCameraTagSchema,
+};
+
+export const validateZonetagSchema = joi.object( {
+  tagName: joi.string().required(),
+  storeId: joi.string().optional().empty(),
+} );
+
+export const validateZonetagParams = {
+  query: validateZonetagSchema,
+};
+
+export const validateCamZonetagSchema= joi.object( {
+  storeId: joi.string().required(),
+} );
+
+export const validateCamZonetagParams = {
+  body: validateCamZonetagSchema,
+};

package/src/routes/zoneTagging.routes.js

@@ -0,0 +1,20 @@
+
+
+import express from 'express';
+import { isAllowedSessionHandler, validate } 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, validate( validation.validateAddTagParams ), tagController.addCustomTag );
+zoneTaggingRouter.get( '/customTagList', isAllowedSessionHandler, validate( validation.validateTagParams ), tagController.customTagList );
+zoneTaggingRouter.post( '/tagging', isAllowedSessionHandler, validate( validation.validateTaggingParams ), tagController.tagging );
+zoneTaggingRouter.get( '/cameraList', isAllowedSessionHandler, validate( validation.validateTagParams ), tagController.getCameraList );
+zoneTaggingRouter.post( '/updateCustomTag', isAllowedSessionHandler, validate( validation.validateUpdateTagParams ), tagController.updateTag );
+zoneTaggingRouter.post( '/deleteCustomTag', isAllowedSessionHandler, validate( validation.validateDeleteTagParams ), tagController.deleteTag );
+zoneTaggingRouter.get( '/getCameraTagging', isAllowedSessionHandler, validate( validation.validateCameraTagParams ), tagController.getCameraTagging );
+zoneTaggingRouter.get( '/getZoneTagging', isAllowedSessionHandler, validate( validation.validateZonetagParams ), tagController.getZoneList );
+zoneTaggingRouter.post( '/updatezoneTagging', isAllowedSessionHandler, validate( validation.validateCamZonetagParams ), tagController.updatezoneTagging );
+
+

package/src/services/camera.service.js

@@ -0,0 +1,17 @@
+import model from 'tango-api-schema';
+
+export const find = async ( query ={}, record = {} ) => {
+  return await model.cameraModel.find( query, record ).collation( { locale: 'en_US', numericOrdering: true } ).sort( { cameraNumber: 1 } );
+};
+
+export const updateOne = async ( query ={}, record = {} ) => {
+  return await model.cameraModel.updateOne( query, record );
+};
+
+export const findOne = async ( query ={}, record = {} ) => {
+  return await model.cameraModel.findOne( query, record );
+};
+
+export const updateMany = async ( query ={}, record = {} ) => {
+  return await model.cameraModel.updateMany( query, record );
+};

package/src/services/customTagging.service.js

@@ -0,0 +1,17 @@
+import model from 'tango-api-schema';
+
+export const findOne = async ( query = {}, record = {} ) => {
+  return await model.customTagModel.findOne( query, record );
+};
+
+export const create = async ( data ) => {
+  return await model.customTagModel.create( data );
+};
+
+export const updateOne = async ( query = {}, record = {} ) => {
+  return await model.customTagModel.updateOne( query, { $set: record }, { upsert: true } );
+};
+
+export const updateArrayElement = async ( query = {}, record = {}, filter = {} ) => {
+  return await model.customTagModel.updateOne( query, record, filter );
+};

package/src/services/tagging.service.js

@@ -0,0 +1,30 @@
+import model from 'tango-api-schema';
+
+export const findOne = async ( query ={}, record = {} ) => {
+  return await model.taggingModel.findOne( query, record );
+};
+
+export const find = async ( query ={}, record = {} ) => {
+  return await model.taggingModel.find( query, record );
+};
+
+export const aggregate = async ( query ={}, record = {} ) => {
+  return await model.taggingModel.aggregate( query );
+};
+
+export const deleteMany = async ( query = {} ) => {
+  return await model.taggingModel.deleteMany( query );
+};
+
+export const insertMany = async ( data = [] ) => {
+  return await model.taggingModel.insertMany( data );
+};
+
+export const updateMany = async ( query = {}, record ={} ) => {
+  return await model.taggingModel.updateMany( query, record );
+};
+
+export const create = async ( data = [] ) => {
+  return await model.taggingModel.create( data );
+};
+