tango-app-api-audit 3.5.17 → 3.5.18

package/src/docs/eyeTestAudit.docs.js

@@ -1,5 +1,5 @@
 import j2s from 'joi-to-swagger';
-import { getListSchema, getFileSchema, getFileHistorySchema, userAuditedDataSchema, viewFileSchema, saveSchema, cancelSchema } from '../dtos/eyeTestAudit.dtos.js';
+import { getListSchema, getFileSchema, getFileHistorySchema, userAuditedDataSchema, viewFileSchema, saveSchema, cancelSchema, summaryCardSchema, getUserConfigSchema, rmListSchema, updateUserConfigParamsSchema, updateUserConfigSchema, updateEmailConfigParamaSchema, updateEmailConfigSchema, getEmailConfigSchema, summaryListSchema, emailAlertLogSchema } from '../dtos/eyeTestAudit.dtos.js';
 
 export const eyeTestAuditDocs = {
 
@@ -160,4 +160,196 @@ export const eyeTestAuditDocs = {
       },
     },
   },
+  '/v3/eye-test-audit/summary-list': {
+    post: {
+      tags: [ 'Eye Test Audit' ],
+      description: 'Eye test audit report',
+      operationId: 'summary-list',
+      requestBody: {
+        content: {
+          'application/json': {
+            schema: j2s( summaryListSchema ).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/email-alert-log': {
+    post: {
+      tags: [ 'Eye Test Audit' ],
+      description: 'logs of email alert against of optum',
+      operationId: 'email-alert-log',
+      requestBody: {
+        content: {
+          'application/json': {
+            schema: j2s( emailAlertLogSchema ).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/summary-card': {
+    post: {
+      tags: [ 'Eye Test Audit' ],
+      description: 'Eye test audit overview by counts',
+      operationId: 'summary-card',
+      requestBody: {
+        content: {
+          'application/json': {
+            schema: j2s( summaryCardSchema ).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-user-config': {
+    get: {
+      tags: [ 'Eye Test Audit' ],
+      description: `Get regional manager list`,
+      operationId: 'get-user-config',
+      parameters: [
+        {
+          in: 'query',
+          name: 'clientId',
+          scema: j2s( getUserConfigSchema ).swagger,
+          require: false,
+        },
+      ],
+      responses: {
+        200: { description: 'Successful' },
+        401: { description: 'Unauthorized User' },
+        422: { description: 'Field Error' },
+        500: { description: 'Server Error' },
+        204: { description: 'Not Found' },
+      },
+    },
+  },
+
+  '/v3/eye-test-audit/rm-list': {
+    get: {
+      tags: [ 'Eye Test Audit' ],
+      description: `Get regional manager list`,
+      operationId: 'rm-list',
+      parameters: [
+        {
+          in: 'query',
+          name: 'clientId',
+          scema: j2s( rmListSchema ).swagger,
+          require: false,
+        },
+      ],
+      responses: {
+        200: { description: 'Successful' },
+        401: { description: 'Unauthorized User' },
+        422: { description: 'Field Error' },
+        500: { description: 'Server Error' },
+        204: { description: 'Not Found' },
+      },
+    },
+  },
+
+  '/v3/eye-test-audit/update-user-config': {
+    put: {
+      tags: [ 'Eye Test Audit' ],
+      description: `Update user list`,
+      operationId: 'get-user-config',
+      parameters: [
+        {
+          in: 'query',
+          name: '_id',
+          scema: j2s( updateUserConfigParamsSchema ).swagger,
+          require: false,
+        },
+      ],
+      requestBody: {
+        content: {
+          'application/json': {
+            schema: j2s( updateUserConfigSchema ).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-email-config': {
+    get: {
+      tags: [ 'Eye Test Audit' ],
+      description: `Get email configuration`,
+      operationId: 'get-email-config',
+      parameters: [
+        {
+          in: 'query',
+          name: 'clientId',
+          scema: j2s( getEmailConfigSchema ).swagger,
+          require: false,
+        },
+      ],
+      responses: {
+        200: { description: 'Successful' },
+        401: { description: 'Unauthorized User' },
+        422: { description: 'Field Error' },
+        500: { description: 'Server Error' },
+        204: { description: 'Not Found' },
+      },
+    },
+  },
+
+  '/v3/eye-test-audit/update-email-config': {
+    put: {
+      tags: [ 'Eye Test Audit' ],
+      description: `Update email configuration`,
+      operationId: 'update-email-config',
+      parameters: [
+        {
+          in: 'query',
+          name: '_id',
+          scema: j2s( updateEmailConfigParamaSchema ).swagger,
+          require: false,
+        },
+      ],
+      requestBody: {
+        content: {
+          'application/json': {
+            schema: j2s( updateEmailConfigSchema ).swagger,
+          },
+        },
+      },
+      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

@@ -1,4 +1,5 @@
 import joi from 'joi';
+import dayjs from 'dayjs';
 
 export const getListSchema = joi.object(
     {
@@ -95,4 +96,290 @@ export const userAuditedDataValid = {
   params: userAuditedDataSchema,
 };
 
+export const summaryListSchema = joi.object( {
+  keyType: joi.string()
+      .valid( 'rm', 'cluster', 'store' )
+      .required()
+      .messages( {
+        'any.only': 'Please give a valid key type',
+        'any.required': 'keyType is required',
+      } ),
+  fromDate: joi.string()
+      .pattern( /^\d{4}-\d{2}-\d{2}$/, 'YYYY-MM-DD format' )
+      .required()
+      .messages( {
+        'string.pattern.name': `'fromDate' must be in the format YYYY-MM-DD (e.g., 2025-07-19).`,
+        'string.empty': `'fromDate' is required.`,
+      } )
+      .custom( ( value, helpers ) => {
+        const from = dayjs( value );
+        if ( !from.isValid() ) {
+          return helpers.error( 'any.invalid', { message: 'Invalid fromDate' } );
+        }
+        return value;
+      } ),
+
+  toDate: joi.string()
+      .pattern( /^\d{4}-\d{2}-\d{2}$/, 'YYYY-MM-DD format' )
+      .required()
+      .messages( {
+        'string.pattern.name': `'toDate' must be in the format YYYY-MM-DD (e.g., 2025-07-19).`,
+        'string.empty': `'toDate' is required.`,
+      } )
+      .custom( ( value, helpers ) => {
+        const to = dayjs( value );
+        const today = dayjs();
+
+        if ( !to.isValid() ) {
+          return helpers.error( 'any.invalid', { message: 'Invalid toDate' } );
+        }
+        if ( to.isAfter( today, 'day' ) ) {
+          return helpers.error( 'any.invalid', { message: 'toDate cannot be in the future' } );
+        }
+
+        return value;
+      } ),
+  type: joi.string().required().messages( {
+    'any.required': 'Type is required',
+    'string.empty': 'Type cannot be empty',
+  } ),
+  demographics: joi.array().optional(),
+  RMList: joi.array().items(
+      joi.object( {
+        email: joi.string().required(),
+        _id: joi.string().required(),
+      } ).required(),
+  ).optional(),
+  storeId: joi.array().items( joi.string().required() ).required(),
+  complianceScore: joi.number().optional().allow( null ),
+  nearAddition: joi.string().optional().allow( '' ),
+  isExport: joi.boolean().optional(),
+  searchValue: joi.string().optional().allow( '' ),
+  sortBy: joi.string().optional(),
+  sortOrder: joi.number().optional(),
+} );
+
+export const summaryListValid = {
+  body: summaryListSchema,
+};
+
+
+export const summaryCardSchema = joi.object( {
+
+  fromDate: joi.string()
+      .pattern( /^\d{4}-\d{2}-\d{2}$/, 'YYYY-MM-DD format' )
+      .required()
+      .messages( {
+        'string.pattern.name': `'fromDate' must be in the format YYYY-MM-DD (e.g., 2025-07-19).`,
+        'string.empty': `'fromDate' is required.`,
+      } )
+      .custom( ( value, helpers ) => {
+        const from = dayjs( value );
+        if ( !from.isValid() ) {
+          return helpers.error( 'any.invalid', { message: 'Invalid fromDate' } );
+        }
+        return value;
+      } ),
+
+  toDate: joi.string()
+      .pattern( /^\d{4}-\d{2}-\d{2}$/, 'YYYY-MM-DD format' )
+      .required()
+      .messages( {
+        'string.pattern.name': `'toDate' must be in the format YYYY-MM-DD (e.g., 2025-07-19).`,
+        'string.empty': `'toDate' is required.`,
+      } )
+      .custom( ( value, helpers ) => {
+        const to = dayjs( value );
+        const today = dayjs();
+
+        if ( !to.isValid() ) {
+          return helpers.error( 'any.invalid', { message: 'Invalid toDate' } );
+        }
+        if ( to.isAfter( today, 'day' ) ) {
+          return helpers.error( 'any.invalid', { message: 'toDate cannot be in the future' } );
+        }
 
+        return value;
+      } ),
+  type: joi.string().required().messages( {
+    'any.required': 'Type is required',
+    'string.empty': 'Type cannot be empty',
+  } ),
+  demographics: joi.array().optional(),
+  // RMList: joi.array().items(
+  //     joi.object( {
+  //       email: joi.string().required(),
+  //       _id: joi.string().required(),
+  //     } ).required(),
+  // ).optional(),
+  storeId: joi.array().items( joi.string().required() ).required(),
+  complianceScore: joi.number().optional().allow( null ),
+  nearAddition: joi.string().optional().allow( '' ),
+  category: joi.string().optional() .valid( 'fake', 'genuine' ),
+} );
+
+export const summaryCardValid = {
+  body: summaryCardSchema,
+};
+
+
+export const emailAlertLogSchema = joi.object( {
+  fromDate: joi.string()
+      .pattern( /^\d{4}-\d{2}-\d{2}$/, 'YYYY-MM-DD format' )
+      .required()
+      .messages( {
+        'string.pattern.name': `'fromDate' must be in the format YYYY-MM-DD (e.g., 2025-07-19).`,
+        'string.empty': `'fromDate' is required.`,
+      } )
+      .custom( ( value, helpers ) => {
+        const from = dayjs( value );
+        if ( !from.isValid() ) {
+          return helpers.error( 'any.invalid', { message: 'Invalid fromDate' } );
+        }
+        return value;
+      } ),
+
+  toDate: joi.string()
+      .pattern( /^\d{4}-\d{2}-\d{2}$/, 'YYYY-MM-DD format' )
+      .required()
+      .messages( {
+        'string.pattern.name': `'toDate' must be in the format YYYY-MM-DD (e.g., 2025-07-19).`,
+        'string.empty': `'toDate' is required.`,
+      } )
+      .custom( ( value, helpers ) => {
+        const to = dayjs( value );
+        const today = dayjs();
+
+        if ( !to.isValid() ) {
+          return helpers.error( 'any.invalid', { message: 'Invalid toDate' } );
+        }
+        if ( to.isAfter( today, 'day' ) ) {
+          return helpers.error( 'any.invalid', { message: 'toDate cannot be in the future' } );
+        }
+
+        return value;
+      } ),
+  type: joi.string().required().messages( {
+    'any.required': 'Type is required',
+    'string.empty': 'Type cannot be empty',
+  } ),
+  RMList: joi.array().items(
+      joi.object( {
+        email: joi.string().required(),
+        _id: joi.string().required(),
+      } ).required(),
+  ).optional(),
+  clientId: joi.string().when( '$userType', {
+    is: 'tango',
+    then: joi.required().messages( {
+      'any.required': 'clientId is required',
+      'string.base': 'clientId must be a string',
+    } ),
+    otherwise: joi.optional(),
+  } ),
+  cluster: joi.array().items( joi.string().required() ).required(),
+  isExport: joi.boolean().optional(),
+  searchValue: joi.string().optional().allow( '' ),
+  sortBy: joi.string().optional(),
+  sortOrder: joi.number().optional(),
+} );
+
+export const emailAlertLogValid = {
+  body: emailAlertLogSchema,
+};
+
+export const getUserConfigSchema = joi.object( {
+  clientId: joi.string().when( '$userType', {
+    is: 'tango',
+    then: joi.required().messages( {
+      'any.required': 'clientId is required',
+      'string.base': 'clientId must be a string',
+    } ),
+    otherwise: joi.optional(),
+  } ),
+} );
+
+export const getUserConfigValid = {
+  query: getUserConfigSchema,
+};
+
+export const rmListSchema = joi.object( {
+  clientId: joi.string().when( '$userType', {
+    is: 'tango',
+    then: joi.required().messages( {
+      'any.required': 'clientId is required',
+      'string.base': 'clientId must be a string',
+    } ),
+    otherwise: joi.optional(),
+  } ),
+} );
+
+export const rmListValid = {
+  query: rmListSchema,
+};
+
+export const updateUserConfigSchema = joi.object( {
+  clientId: joi.string().when( '$userType', {
+    is: 'tango',
+    then: joi.required().messages( {
+      'any.required': 'clientId is required',
+      'string.base': 'clientId must be a string',
+    } ),
+    otherwise: joi.optional(),
+  } ),
+  userList: joi.array().items( joi.object( {
+    _id: joi.string().required(),
+    email: joi.string().required() } ) ).required(),
+} );
+
+export const updateUserConfigParamsSchema = joi.object( {
+  _id: joi.string().optional(),
+} );
+
+export const updateUserConfigValid = {
+  body: updateUserConfigSchema,
+  query: updateUserConfigParamsSchema,
+};
+
+
+export const updateEmailConfigSchema = joi.object( {
+
+  clientId: joi.string().when( '$userType', {
+    is: 'tango',
+    then: joi.required().messages( {
+      'any.required': 'clientId is required',
+      'string.base': 'clientId must be a string',
+    } ),
+    otherwise: joi.optional(),
+  } ),
+  complianceThreshold: joi.object( {
+    condition: joi.string().valid( '>', '>=', '<=', '<', '=' ).required(),
+    value: joi.string().required(),
+  } ),
+} );
+
+export const updateEmailConfigParamaSchema = joi.object( {
+
+  _id: joi.string().required(),
+} );
+
+export const updateEmailConfigValid = {
+  body: updateEmailConfigSchema,
+  query: updateEmailConfigParamaSchema,
+};
+
+
+export const getEmailConfigSchema = joi.object( {
+  clientId: joi.string().when( '$userType', {
+    is: 'tango',
+    then: joi.required().messages( {
+      'any.required': 'clientId is required',
+      'string.base': 'clientId must be a string',
+    } ),
+    otherwise: joi.optional(),
+  } ),
+} );
+
+export const getEmailConfigValid = {
+  query: getEmailConfigSchema,
+};

package/src/routes/eyeTestAudit.routes.js

@@ -1,8 +1,9 @@
 import { Router } from 'express';
 import { isAllowedSessionHandler, validate } from 'tango-app-api-middleware';
 import { accessVerification } from 'tango-app-api-middleware';
-import { cancelValid, getFileHistoryValid, getFileValid, getListValid, saveValid, userAuditedDataValid, viewFileValid } from '../dtos/eyeTestAudit.dtos.js';
-import { cancel, getFile, getFileHistory, getList, save, userAuditedData, viewFile } from '../controllers/eyeTestAudit.controllers.js';
+import { cancelValid, emailAlertLogValid, getEmailConfigValid, getFileHistoryValid, getFileValid, getListValid, getUserConfigValid, rmListValid, saveValid, summaryCardValid, summaryListValid, updateEmailConfigValid, updateUserConfigValid, userAuditedDataValid, viewFileValid } from '../dtos/eyeTestAudit.dtos.js';
+import { addUserConfig, cancel, emailAlertLog, getEmailConfig, getFile, getFileHistory, getList, getUserConfig, rmList, save, summaryCard, summaryList, updateEmailConfig, updateEmailConfig1, updateUserConfig, userAuditedData, viewFile } from '../controllers/eyeTestAudit.controllers.js';
+import { isSuperAdmin, roleValidation } from '../validation/eyeTest.validation.js';
 
 export const eyeTestAuditRouter = Router();
 
@@ -14,5 +15,22 @@ eyeTestAuditRouter.post( '/cancel', isAllowedSessionHandler, accessVerification(
 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 );
 
+// enhancement of aug of 2025
+
+eyeTestAuditRouter.post( '/summary-list', isAllowedSessionHandler, accessVerification( { userType: [ 'tango', 'client' ] } ), validate( summaryListValid ), roleValidation, summaryList );
+eyeTestAuditRouter.post( '/summary-card', isAllowedSessionHandler, accessVerification( { userType: [ 'tango', 'client' ] } ), validate( summaryCardValid ), summaryCard );
+eyeTestAuditRouter.post( '/email-alert-log', isAllowedSessionHandler, accessVerification( { userType: [ 'tango', 'client' ] } ), isSuperAdmin, validate( emailAlertLogValid ), emailAlertLog );
+
+// setting
+eyeTestAuditRouter.get( '/get-user-config', isAllowedSessionHandler, accessVerification( { userType: [ 'tango', 'client' ] } ), validate( getUserConfigValid ), getUserConfig );
+eyeTestAuditRouter.put( '/update-user-config', isAllowedSessionHandler, accessVerification( { userType: [ 'tango', 'client' ] } ), isSuperAdmin, validate( updateUserConfigValid ), addUserConfig, updateUserConfig );
+
+eyeTestAuditRouter.get( '/rm-list', isAllowedSessionHandler, accessVerification( { userType: [ 'tango', 'client' ] } ), isSuperAdmin, validate( rmListValid ), rmList );
+eyeTestAuditRouter.get( '/get-email-config', isAllowedSessionHandler, accessVerification( { userType: [ 'tango', 'client' ] } ), isSuperAdmin, validate( getEmailConfigValid ), getEmailConfig );
+eyeTestAuditRouter.put( '/update-email-config', isAllowedSessionHandler, accessVerification( { userType: [ 'tango', 'client' ] } ), validate( updateEmailConfigValid ), updateEmailConfig );
+
+
+eyeTestAuditRouter.put( '/temp', updateEmailConfig1 );
+
 
 export default eyeTestAuditRouter;

package/src/service/clusters.service.js

@@ -0,0 +1,6 @@
+import clusterModel from 'tango-api-schema/schema/cluster.model';
+
+
+export function aggregateClusters( query ) {
+  return clusterModel.aggregate( query, { collation: { locale: 'en', strength: 2 } } );
+}

package/src/service/eyeTestConfiguration.service.js

@@ -0,0 +1,9 @@
+import eyeTestConfigurationModel from 'tango-api-schema/schema/eyeTestConfiguration.model.js';
+
+export function updateOneEyeTestConfig( query, record, upsert ) {
+  return eyeTestConfigurationModel.updateOne( query, { $set: record }, upsert );
+}
+
+export function findOneEyeTestConfig( query, field ) {
+  return eyeTestConfigurationModel.findOne( query, field );
+}

package/src/validation/eyeTest.validation.js

@@ -0,0 +1,39 @@
+import { logger } from 'tango-app-api-middleware';
+
+export async function roleValidation( req, res, next ) {
+  try {
+    const userRole = req?.user?.role;
+    switch ( userRole ) {
+      case 'user':
+        delete req?.body?.RMList;
+        break;
+      case 'admin':
+        delete req?.body?.RMList;
+        break;
+      case 'superadmin':
+        break;
+      default: return res.sendError( 'forbidden to access: you must be User or Admin or Super Admin', 403 );
+    }
+    next();
+    return;
+  } catch ( error ) {
+    logger.error( { error: error, message: req.query, function: 'roleValidation' } );
+    return res.sendError( error, 500 );
+  }
+}
+
+export async function isSuperAdmin( req, res, next ) {
+  try {
+    logger.info( { userType: req?.user?.userType } );
+    if ( req?.user?.role == 'superadmin' ) {
+      next();
+      return;
+    } else {
+      return res.sendError( 'forbidden this action', 403 );
+    }
+  } catch ( error ) {
+    logger.error( { error: error, message: req.query, function: 'isSuperAdmin' } );
+    return res.sendError( error, 500 );
+  }
+}
+