tango-app-api-audit 3.4.66 → 3.4.68-beta.0

package/index.js

@@ -6,7 +6,9 @@ import { auditWalletRouter } from './src/routes/auditWallet.routes.js';
 import { auditDocs } from './src/docs/audit.docs.js';
 import { traxAuditDocs } from './src/docs/traxAudit.docs.js';
 import { auditWalletDocs } from './src/docs/auditWallet.docs.js';
+import { eyeTestAuditRouter } from './src/routes/eyeTestAudit.routes.js';
+import { eyeTestAuditDocs } from './src/docs/eyeTestAudit.docs.js';
 
-export { auditRouter, auditDocs, traxAuditRouter, traxAuditDocs, auditWalletRouter, auditWalletDocs };
+export { auditRouter, auditDocs, traxAuditRouter, traxAuditDocs, auditWalletRouter, auditWalletDocs, eyeTestAuditRouter, eyeTestAuditDocs };
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-audit",
-    "version": "3.4.66",
+    "version": "3.4.68-beta.0",
     "description": "audit & audit metrics apis",
     "main": "index.js",
     "type": "module",

package/src/controllers/eyeTestAudit.controllers.js

@@ -0,0 +1,224 @@
+import { getOpenSearchData, insertOpenSearchData, getOpenSearchById, logger } from 'tango-app-api-middleware';
+import { findOneUser } from '../service/user.service.js';
+import mongoose from 'mongoose';
+import dayjs from 'dayjs';
+
+export async function getList( req, res ) {
+  try {
+    const inputData = req.body;
+    const openSearch = JSON.parse( process.env.OPENSEARCH );
+    const limit = inputData.limit || 10;
+    const offset = inputData.offset ? ( inputData.offset - 1 ) * limit : 0;
+
+
+    let filter= [
+      {
+        'range': {
+          'date': {
+            'gte': new Date( inputData.fromDate ),
+            'lte': new Date( inputData.toDate ),
+          },
+        },
+      },
+
+    ];
+    let search ={
+      'must': filter,
+    };
+
+    if ( inputData.visitorsType && inputData.visitorsType.lenght > 0 ) {
+      filter.push( {
+
+        'terms': {
+          'visitorsType.keyword': inputData.visitorsType,
+        },
+
+      } );
+    }
+
+    if ( inputData.storeId && inputData.storeId.lenght > 0 ) {
+      filter.push( {
+
+        'terms': {
+          'storeId.keyword': inputData.storeId,
+        },
+
+      } );
+    }
+
+    if ( inputData.searchValue && inputData.searchValue !== '' ) {
+      search ={
+        'must': filter,
+        'should': [
+          {
+            'wildcard': {
+              'storeName.keyword': {
+                'value': `*${inputData.searchValue}*`,
+              },
+            },
+          },
+          {
+            'wildcard': {
+              'storeId.keyword': {
+                'value': `*${inputData.searchValue}*`,
+              },
+            },
+          },
+          {
+            'wildcard': {
+              'engagementId.keyword': {
+                'value': `*${inputData.searchValue}*`,
+              },
+            },
+          },
+          {
+            'wildcard': {
+              'queueId.keyword': {
+                'value': `*${inputData.searchValue}*`,
+              },
+            },
+          },
+          {
+            'wildcard': {
+              'optumId.keyword': {
+                'value': `*${inputData.engagementId}*`,
+              },
+            },
+          },
+          {
+            'wildcard': {
+              'visitorsType.keyword': {
+                'value': `*${inputData.searchValue}*`,
+              },
+            },
+          },
+          {
+            'wildcard': {
+              'auditStatus.keyword': {
+                'value': `*${inputData.searchValue}*`,
+              },
+            },
+          },
+        ],
+        'minimum_should_match': 1,
+      };
+    }
+
+    let searchQuery={
+      'from': offset,
+      'size': limit,
+      'query': {
+        'bool': search,
+      },
+    };
+    const result = await getOpenSearchData( openSearch.EyeTestInput, searchQuery );
+    const count = result?.body?.hits?.total?.value;
+    if ( !count || count == 0 ) {
+      return res.sendError( 'No data found', 204 );
+    }
+    const searchValue = result?.body?.hits?.hits;
+    if ( !searchValue || searchValue?.length == 0 ) {
+      return res.sendError( 'No data found', 204 );
+    }
+    return res.sendSuccess( { result: searchValue, count: count } );
+  } catch ( error ) {
+    const err = error.message || 'Internal Server Error';
+    logger.error( { message: error, data: req.body, function: 'eyetestAudit-controller-getList' } );
+    return res.sendError( err, 500 );
+  }
+}
+
+export async function getFile( req, res ) {
+  try {
+    const inputData = req.params;
+    const openSearch = JSON.parse( process.env.OPENSEARCH );
+    const result =await insertOpenSearchData( openSearch.EyeTestOutput, physicalRecord );
+    return res.sendSuccess( { result: result, inputData: inputData, record: record } );
+  } catch ( error ) {
+    const err = error.message || 'Internal Server Error';
+    logger.error( { message: error, data: req.body, function: 'eyetestAudit-controller-getFile' } );
+    return res.sendError( err, 500 );
+  }
+}
+
+export async function getFileHistory( req, res ) {
+  try {
+    const parsedOpenSearch = JSON.parse( process.env.OPENSEARCH );
+    const inputData = req.params;
+    let Query = {};
+    if ( inputData.type==='physical' ) {
+      Query = {
+        'size': 100,
+        'query': {
+          'bool': {
+            'must': [
+              {
+                'term': {
+                  'queueId.keyword': inputData.id,
+                },
+              },
+
+            ],
+          },
+        },
+      };
+    } else {
+      Query = {
+        'size': 100,
+        'query': {
+          'bool': {
+            'must': [
+              {
+                'term': {
+                  'engagementId.keyword': inputData.id,
+                },
+              },
+
+            ],
+          },
+        },
+      };
+    };
+
+    const resposnse = await getOpenSearchData( parsedOpenSearch.EyeTestOutput, Query );
+    if ( resposnse.body.hits.hits.length > 0 ) {
+      let sourcesArray = resposnse.body.hits.hits.map( ( hit ) => hit );
+      let outputData=[];
+      for ( let data of sourcesArray ) {
+        let findUser= await findOneUser( { _id: new mongoose.Types.ObjectId( data._source.userId ) } );
+        outputData.push( {
+          _id: data._id,
+          userId: data._source.userId,
+          userName: findUser.userName,
+          Date: dayjs( data._source.endTime ).format( 'DD/MM/YYYY' ),
+          Time: dayjs( data._source.endTime ).format( 'HH:MM:ss' ),
+        } );
+      }
+
+      return res.sendSuccess( { result: outputData } );
+    } else {
+      return res.sendError( 'No data found', 204 );
+    }
+  } catch ( error ) {
+    const err = error.message || 'Internal Server Error';
+    logger.error( { message: error, data: req.body, function: 'eyetestAudit-controller-getFileHistory' } );
+    return res.sendError( err, 500 );
+  }
+}
+
+export async function userAuditedData( req, res ) {
+  try {
+    const parsedOpenSearch = JSON.parse( process.env.OPENSEARCH );
+    const inputData = req.params;
+    const resposnse = await getOpenSearchById( parsedOpenSearch.EyeTestOutput, inputData.id );
+    if ( resposnse.body&&resposnse.body._source ) {
+      return res.sendSuccess( { result: resposnse.body._source.steps } );
+    } else {
+      return res.sendError( 'No data found', 204 );
+    }
+  } catch ( error ) {
+    const err = error.message || 'Internal Server Error';
+    logger.error( { message: error, data: req.body, function: 'eyetestAudit-controller-userAuditedData' } );
+    return res.sendError( err, 500 );
+  }
+}

package/src/controllers/traxAudit.controllers.js

@@ -1739,6 +1739,26 @@ export async function saveBinary( req, res ) {
         } else {
           await insertOpenSearchData( openSearch.traxDetectionOutput, anomalyOutput );
         }
+        if ( inputData.answer==='approved' ) {
+          let usersList=JSON.parse( process.env.SES );
+          let emails =usersList.suspeciousEmails.split( ',' );
+
+          for ( let user of emails ) {
+            let notificationData= {
+              'title': 'Suspecious Activity Detected',
+              'description': `${getData?.sqs?.Body?.zone_name} at ${getStore2?.storeName}- Immediate action required`,
+              'storeId': inputData.storeId,
+              'type': 'suspiciousactivity',
+              'date': inputData.fileDate,
+              'clientId': req.userAudit?.clientId,
+              'email': user,
+            };
+            await axios.post( `${url.apiDomain}/v3/trax/internalAPI/sendAiPushNotification`, notificationData, { headers: {
+              'Content-Type': 'application/json',
+              'Authorization': 'Bearer d47433f8-9a33-47c7-ba43-1a0fbac28f55' },
+            } );
+          }
+        }
 
         const logData4 = {
           userId: req.user._id,

package/src/docs/eyeTestAudit.docs.js

@@ -0,0 +1,102 @@
+import j2s from 'joi-to-swagger';
+import { getListSchema, getFileSchema, getFileHistorySchema, userAuditedDataSchema } from '../dtos/eyeTestAudit.dtos.js';
+
+export const eyeTestAuditDocs = {
+
+  '/v3/eye-test-audit/get-list': {
+    post: {
+      tags: [ 'Eye Test Audit' ],
+      description: 'Get list of files',
+      operationId: 'get-list',
+      requestBody: {
+        content: {
+          'application/json': {
+            schema: j2s( getListSchema ).swagger,
+          },
+        },
+      },
+      responses: {
+        200: { description: 'Successful' },
+        401: { description: 'Unauthorized User' },
+        422: { description: 'Field Error' },
+        500: { description: 'Server Error' },
+        204: { description: 'Not Found' },
+      },
+    },
+  },
+
+  '/v3/eye-test-audit/get-file/{id}/{type}': {
+    get: {
+      tags: [ 'Eye Test Audit' ],
+      description: 'Get a file via Open Serach',
+      operationId: 'get-file',
+      parameters: [
+        {
+          in: 'path',
+          name: 'id',
+          scema: j2s( getFileSchema ).swagger,
+          require: true,
+        },
+        {
+          in: 'path',
+          name: 'type',
+          scema: j2s( getFileSchema ).swagger,
+          require: true,
+        },
+      ],
+      responses: {
+        200: { description: 'Successful' },
+        401: { description: 'Unauthorized User' },
+        422: { description: 'Field Error' },
+        500: { description: 'Server Error' },
+        204: { description: 'Not Found' },
+      },
+    },
+  },
+
+  '/v3/eye-test-audit/get-file-history/{id}': {
+    get: {
+      tags: [ 'Eye Test Audit' ],
+      description: 'Get a file history via Open Serach',
+      operationId: 'get-file-history',
+      parameters: [
+        {
+          in: 'path',
+          name: 'id',
+          scema: j2s( getFileHistorySchema ).swagger,
+          require: true,
+        },
+      ],
+      responses: {
+        200: { description: 'Successful' },
+        401: { description: 'Unauthorized User' },
+        422: { description: 'Field Error' },
+        500: { description: 'Server Error' },
+        204: { description: 'Not Found' },
+      },
+    },
+  },
+
+  '/v3/eye-test-audit/user-audited-data/{id}': {
+    get: {
+      tags: [ 'Eye Test Audit' ],
+      description: `Get a user's audited file`,
+      operationId: 'user-audited-data',
+      parameters: [
+        {
+          in: 'path',
+          name: 'id',
+          scema: j2s( userAuditedDataSchema ).swagger,
+          require: true,
+        },
+      ],
+      responses: {
+        200: { description: 'Successful' },
+        401: { description: 'Unauthorized User' },
+        422: { description: 'Field Error' },
+        500: { description: 'Server Error' },
+        204: { description: 'Not Found' },
+      },
+    },
+  },
+};

package/src/dtos/eyeTestAudit.dtos.js

@@ -0,0 +1,48 @@
+import joi from 'joi';
+
+export const getListSchema = joi.object(
+    {
+      fromDate: joi.string().required(),
+      toDate: joi.string().required(),
+      type: joi.string().required(),
+      demographics: joi.array().optional(),
+      storeId: joi.array().optional(),
+      limit: joi.number().optional(),
+      offset: joi.number().optional(),
+      searchValue: joi.string().optional().allow( '' ),
+      isExport: joi.boolean().optional(),
+    },
+);
+
+export const getListValid = {
+  body: getListSchema,
+};
+
+
+export const getFileSchema = joi.object( {
+  id: joi.string().required(),
+  type: joi.string().required(),
+} );
+
+export const getFileValid = {
+  params: getFileSchema,
+};
+
+export const getFileHistorySchema = joi.object( {
+  id: joi.string().required(),
+  type: joi.string().required(),
+} );
+
+export const getFileHistoryValid = {
+  params: getFileHistorySchema,
+};
+
+export const userAuditedDataSchema = joi.object( {
+  id: joi.string().required(),
+} );
+
+export const userAuditedDataValid = {
+  params: userAuditedDataSchema,
+};
+
+

package/src/routes/eyeTestAudit.routes.js

@@ -0,0 +1,15 @@
+import { Router } from 'express';
+import { isAllowedSessionHandler, validate } from 'tango-app-api-middleware';
+import { accessVerification } from 'tango-app-api-middleware';
+import { getFileHistoryValid, getFileValid, getListValid, userAuditedDataValid } from '../dtos/eyeTestAudit.dtos.js';
+import { getFile, getFileHistory, getList, userAuditedData } from '../controllers/eyeTestAudit.controllers.js';
+
+export const eyeTestAuditRouter = Router();
+
+eyeTestAuditRouter.post( '/get-list', isAllowedSessionHandler, accessVerification( { userType: [ 'tango', 'client' ] } ), validate( getListValid ), getList );
+eyeTestAuditRouter.get( '/get-file/:id/:type', isAllowedSessionHandler, accessVerification( { userType: [ 'tango', 'client' ] } ), validate( getFileValid ), getFile );
+eyeTestAuditRouter.get( '/get-file-history/:id/:type', isAllowedSessionHandler, accessVerification( { userType: [ 'tango', 'client' ] } ), validate( getFileHistoryValid ), getFileHistory );
+eyeTestAuditRouter.get( '/user-audited-data/:id', isAllowedSessionHandler, accessVerification( { userType: [ 'tango', 'client' ] } ), validate( userAuditedDataValid ), userAuditedData );
+
+
+export default eyeTestAuditRouter;