tango-app-api-report 3.0.2-dev → 3.0.4-dev

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-report",
-    "version": "3.0.2-dev",
+    "version": "3.0.4-dev",
     "description": "report",
     "main": "index.js",
     "type": "module",
@@ -19,11 +19,12 @@
         "express": "^4.18.3",
         "express-fileupload": "^1.5.0",
         "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.92",
-        "tango-app-api-middleware": "^1.0.60-dev",
+        "tango-api-schema": "^2.0.103",
+        "tango-app-api-middleware": "^1.0.77-dev",
         "winston": "^3.12.0",
         "winston-daily-rotate-file": "^5.0.0"
     },

package/src/controllers/report.controllers.js

@@ -1,6 +1,9 @@
-import { reportCreate, reportGet, reportGetSingle, reportUpdate } from '../service/report.service.js';
-import { insertOpenSearchData, logger } from 'tango-app-api-middleware';
-import { getUserNameEmailById } from '../service/user.service.js';
+import { findOneReport, findReport, reportCreate, reportGet, reportGetSingle, reportUpdate } from '../service/report.service.js';
+import { appConfig, fileUpload, getObject, insertOpenSearchData, listFoldersByPath, logger, sendMessageToQueue } from 'tango-app-api-middleware';
+import { findOneUser, getUserNameEmailById } from '../service/user.service.js';
+import { updateOneBasePriceModel } from '../service/basePrice.service.js';
+import { aggregateClient } from '../service/client.service.js';
+// import basePricingModel from 'tango-api-schema/schema/basePricing.model.js';
 
 
 export async function createReport( req, res ) {
@@ -88,3 +91,391 @@ export async function updateReport( req, res ) {
     return res.sendError( error, 500 );
   }
 }
+
+export async function clientReportList( req, res ) {
+  try {
+    const inputData = req.body;
+    const limit = inputData.limit || 10;
+    const offset = inputData.offset? ( inputData.offset - 1 ) * inputData.limit : 0;
+    logger.info( { inputData: inputData } );
+    const daysDifference = Math.ceil( ( new Date( inputData.toDate ) - new Date( inputData.fromDate ) ) / ( 24 * 60 * 60 * 1000 ) );
+    logger.info( { daysDifference: daysDifference, value: ( new Date( inputData.toDate ) - new Date( inputData.fromDate ) ) / ( 24 * 60 * 60 * 1000 ), fromdate: inputData.fromDate, toDate: inputData.toDate } );
+    const query = [
+      {
+        $match: {
+          $and: [
+            { 'reportConfigs.report': { $eq: true } },
+            { clientId: { $in: inputData.clientId } },
+          ],
+
+        },
+      },
+      {
+        $project: {
+          clientId: 1,
+          tangoId: 1,
+          clientName: 1,
+          daysDifference: 1,
+          datesArray: {
+            $map: {
+              input: { $range: [ 0, { $toInt: daysDifference+1 } ] },
+              as: 'day',
+              in: { $add: [ new Date( inputData.fromDate ), { $multiply: [ '$$day', 1000 * 60 * 60 * 24 ] } ] },
+            },
+          },
+        },
+      },
+      {
+        $unwind: '$datesArray',
+      },
+      {
+        $sort: {
+          datesArray: -1,
+        },
+      },
+
+      {
+        $project: {
+          clientId: 1,
+          clientName: 1,
+          tangoId: 1,
+          fileDate: '$datesArray',
+        },
+      },
+    ];
+    if ( inputData.searchValue ) {
+      query.push(
+          {
+            $match: {
+              $or: [
+                {
+                  clientName: { $regex: inputData.searchValue, $options: 'i' },
+                },
+                {
+                  clientId: { $regex: inputData.searchValue, $options: 'i' },
+
+                },
+              ],
+            },
+          },
+      );
+    }
+    if ( inputData.sortColumnName ) {
+      const sortBy = inputData.sortBy || -1;
+      const sortColumnName =inputData.sortColumnName == 'clientId'? 'tangoId': inputData.sortColumnName;
+      query.push( {
+        $sort: { [sortColumnName]: sortBy },
+      } );
+    }
+    const count = await aggregateClient( query );
+    if ( count?.length == 0 ) {
+      return res.sendError( 'No Data Found', 204 );
+    }
+
+    query.push(
+        { $skip: offset },
+        { $limit: limit },
+    );
+    const result = await aggregateClient( query );
+    res.sendSuccess( { result: result, count: count?.length } );
+  } catch ( error ) {
+    logger.info( { error: error, message: req.body, function: 'clientReportList' } );
+    return res.sendError( 'Internal Server Error', 500 );
+  }
+}
+
+export async function generateReport( req, res ) {
+  try {
+    const inputData = req.body;
+    const sqsProduceQueue = {
+      QueueUrl: `${appConfig.cloud.aws.sqs.url}${appConfig.cloud.aws.sqs.generateReport}`,
+      MessageBody: JSON.stringify( {
+        file_date: inputData.fileDate,
+        client_name: inputData.getReportName?.reportName,
+        client_id: Number( inputData.clientId ),
+        message: 'good to trigger',
+      } ),
+    };
+    const sqsQueue = await sendMessageToQueue( sqsProduceQueue.QueueUrl, sqsProduceQueue.MessageBody );
+    if ( sqsQueue.MessageId ) {
+      const log = {
+        userName: req.user.userName,
+        Date: new Date(),
+        userId: req.user._id,
+        logType: 'report',
+        logSubType: 'generateReport',
+        logData: {
+          clientName: inputData.getReportName?.clientName,
+          fileDate: inputData.fileDate,
+          reportName: inputData.getReportName?.reportName,
+          clientId: inputData.ClientId,
+          sqsMessageId: sqsQueue.MessageId,
+        },
+      };
+      await insertOpenSearchData( 'tango-retail-activity-logs', log );
+
+      return res.sendSuccess( { result: 'Report has been Initiated Sucessfully' } );
+    }
+  } catch ( error ) {
+    const err = error.code || 'Internal Server Error';
+    logger.error( { error: error, message: req.body, function: 'generateReport' } );
+    return res.sendError( err, 500 );
+  }
+}
+
+export async function uploadManualReport( req, res ) {
+  try {
+    const inputData = req.body;
+    const name = inputData.fileName;
+    const regex = /^(\d{2}-\d{2}-\d{4})_(.*?)\.([a-zA-Z0-9]+)$/;
+    const matches = name.match( regex );
+    if ( matches ) {
+      const date = matches[1];
+      const filenameWithoutExtension = matches[2];
+      const extension = matches[3];
+      if ( inputData.fileDate !== date ) {
+        return res.sendError( 'File Date is Incorrect in the File Name', 400 );
+      }
+      const query = {
+        'fileName': filenameWithoutExtension,
+        'fileType': extension,
+        'clientId': inputData.clientId,
+      };
+      const data = await findOneReport( query );
+      if ( !data ) {
+        return res.sendError( 'Report does not configured', 400 );
+      }
+      const uploadDataParams = {
+        Bucket: appConfig.cloud.aws.bucket.reportBucket,
+        Key: `${inputData.fileDate}/${data.reportName}/`,
+        fileName: inputData.filename,
+        Body: req.files.fileuplaod_data.data,
+      };
+      const result = await fileUpload( uploadDataParams );
+      logger.info( { result: result, value: 'file upload response' } );
+      if ( !result ) {
+        return res.sendError( 'File Upload Failed', 500 );
+      }
+      let user = await findOneUser( { _id: req.user._id, isActive: true } );
+      if ( !user ) {
+        return res.sendError( 'Forbidden', 403 );
+      }
+      const log = {
+        userName: user.userName,
+        Date: new Date(),
+        userId: req.user._id,
+        logType: 'report',
+        logSubType: 'uploadReport',
+        logData: {
+          fileDate: inputData.fileDate,
+          reportName: data.reportName,
+          clientId: data.clientId,
+        },
+      };
+
+      await insertOpenSearchData( 'tango-retail-activity-logs', log );
+      return res.sendSuccess( { result: 'uploaded Sucessfully' } );
+    } else {
+      return res.sendError( 'File Name is Incorrect', 400 );
+    }
+  } catch ( error ) {
+    logger.error( { error: error, message: req.body, function: 'generateReport' } );
+    return res.sendError( error, 500 );
+  }
+}
+
+export async function getReportList( req, res ) {
+  try {
+    const inputData = req.query;
+    const fetchData = {
+      Bucket: appConfig.cloud.aws.bucket.reportBucket,
+      file_path: `${inputData.fileDate}/${inputData.getReportName?.reportName}/`,
+    };
+    const folderPath = await listFoldersByPath( fetchData );
+    logger.info( { folderPath: folderPath, value: 'report list from bucket' } );
+    if ( folderPath.length == 0 ) {
+      return res.sendError( 'No Reports Found', 204 );
+    }
+    return res.sendSuccess( { result: folderPath } );
+  } catch ( error ) {
+    logger.error( { error: error, message: req.query, function: 'getReportList' } );
+    return res.sendError( error, 500 );
+  }
+}
+
+export async function dowloadReport( req, res ) {
+  try {
+    const inputData = req.query;
+    const params = {
+      Bucket: appConfig.cloud.aws.bucket.reportBucket,
+      Key: inputData.filePath,
+    };
+    const fileName = inputData.filePath.split( '/' );
+    const getReport = await getObject( params );
+    if ( getReport.code ) {
+      return res.sendError( getReport, 500 );
+    }
+    res.setHeader(
+        'Content-disposition',
+        `attachment; filename=${fileName[2]}`,
+    );
+    res.setHeader(
+        'Content-Type',
+        `${getReport.ContentType}`,
+    );
+    res.status( 200 ).send( getReport.Body );
+  } catch ( error ) {
+    logger.error( { error: error, message: req.query, function: 'dowloadReport' } );
+    return res.sendError( error, 500 );
+  }
+}
+export async function sendReport( req, res ) {
+  try {
+    const inputData = req.body;
+    const getReportList = await findReport( { clientId: inputData.clientId } );
+    let reportName = [];
+    let name = [];
+    let regionalKey = [];
+    let result = [];
+    let file = {};
+    let sendMailCount = 0;
+    let subject = 'Fwd: Tango Eye\'s Customer Intelligence Report - ' + inputData.fileDate;
+    let messageBody = `<br>Hi Team,<br><br>&nbsp;Please find attached Tango RetailEye report on customer footfall and shopping patterns for ${inputData.fileDate}.<br><br>&nbsp;Thanks <br>&nbsp;Team Tango`;
+    let UserattachmentDetails = [];
+    for ( const data of getReportList ) {
+      const fetchData = {
+        Bucket: appConfig.cloud.aws.bucket.reportBucket,
+        Key: `${inputData.fileDate}/${data.reportName}/${inputData.fileDate}_${data.fileName}.${data.fileType}`,
+      };
+      reportName.push( `${inputData.fileDate}_${data.fileName}` );
+      name.push( `${data.fileName}` );
+      regionalKey.push( `${inputData.fileDate}_${data.fileName}.${data.fileType}` );
+      file = await getObject( fetchData );
+      if ( file.statusCode == 404 ) {
+        logger.info( 'File not available in bucket ' + `${JSON.stringify( file )}` );
+        sendMailCount += 1;
+      } else {
+        data.email.forEach( ( email ) => {
+          let UserIndex = UserattachmentDetails.findIndex( ( user ) => user.email == email );
+          if ( UserIndex == -1 ) {
+            UserattachmentDetails.push( {
+              email: email,
+              attachments: [
+                {
+                  filename: `${inputData.fileDate}_${data.fileName}.${data.fileType}`,
+                  content: file.Body,
+                  contentType: file.ContentType,
+                },
+              ],
+            } );
+          } else {
+            UserattachmentDetails[UserIndex].attachments.push( {
+              filename: `${req.body.fileDate}_${data.fileName}.${data.fileType}`,
+              content: file.Body,
+              contentType: file.ContentType,
+            } );
+          }
+        } );
+      }
+    }
+    UserattachmentDetails.forEach( async ( userattach ) => {
+      await sendEmail( userattach.email, subject, messageBody, userattach.attachments, config.ses.reportEmail ).then( ( response ) => {
+        result.push( response );
+      } );
+    } );
+    if ( sendMailCount == getReportList.length ) {
+      return res.sendError( 'File not available in bucket', 404 );
+    }
+    let user = await findOneUser( { _id: req.user._id, isActive: true } );
+    if ( !user ) {
+      return res.sendError( 'Forbiddon to Access', 403 );
+    }
+    const sqsProduceQueue = {
+      QueueUrl: `${appConfig.cloud.aws.sqs.url}${appConfig.cloud.aws.sqs.sendReport}`,
+      MessageBody: JSON.stringify( {
+        file_date: inputData.fileDate,
+        client_name: getReportList[0].reportName,
+        client_id: Number( inputData.clientId ),
+        file_name: regionalKey,
+        report_name: name,
+      } ),
+    };
+    const sqsQueue = await sendMessageToQueue( sqsProduceQueue.QueueUrl, sqsProduceQueue.MessageBody );
+    if ( sqsQueue.MessageId ) {
+      logger.info( 'successfully Pushed to SQS ' + `${JSON.stringify( sqsQueue )}`, 'Send Report' );
+      const log = {
+        userName: user.userName,
+        Date: new Date(),
+        userId: user._id,
+        logType: 'report',
+        logSubType: 'sendReport',
+        logData: {
+          fileDate: inputData.fileDate,
+          reportName: getReportList[0].reportName,
+          clientId: getReportList[0].clientId,
+        },
+      };
+      await insertOpenSearchData( 'tango-retail-activity-logs', log );
+      return res.sendSuccess( { result: 'Report has been Sent Successfully' } );
+    } else {
+      return res.sendError( ' Message does not Sent & Report has been Sent Successfully', 500 );
+    }
+  } catch ( error ) {
+    logger.error( { error: error, message: req.body, function: 'sendReport' } );
+
+    return res.sendError( error, 500 );
+  }
+}
+
+export async function updateBasePrice( req, res ) {
+  try {
+    const inputData = req.body;
+    let count=0;
+    let increment = 0;
+    for ( let i =0; i< inputData.length; i++ ) {
+      increment = increment+1;
+      // await basePricingModel.create( {
+      //   'clientId': inputData[i].clientId,
+      //   'standard': [
+      //     {
+      //       'productName': 'tangoTraffic',
+
+      //     },
+
+      //   ],
+      //   'step': [
+      //     {
+      //       'productName': 'tangoTraffic',
+
+      //     },
+
+      //   ],
+      // } );
+      const query = {
+        'clientId': inputData[i].clientId,
+        'standard.productName': { $exists: true },
+      };
+      const record={
+        'clientId': inputData[i].clientId,
+        'standard.$[elem].basePrice': inputData[i].pricePerStore,
+        'standard.$[elem].negotiatePrice': inputData[i].pricePerStore,
+        'step.$[elem].basePrice': inputData[i].pricePerStore,
+        'step.$[elem].negotiatePrice': inputData[i].pricePerStore,
+        'step.$[elem].storeRange': '1-100',
+      };
+      const result = await updateOneBasePriceModel( query, record );
+      if ( result ) {
+        count= count+1;
+      }
+      console.log( result, '.data' );
+    }
+    if ( increment == inputData.length ) {
+      res.sendSuccess( { result: `The given ${count } recoeds updated` } );
+    }
+  } catch ( error ) {
+    logger.error( { error: error, message: req.params, function: 'updateBasePrice' } );
+    return res.sendError( error, 500 );
+  }
+}
+
+

package/src/docs/report.docs.js

@@ -0,0 +1,153 @@
+import j2s from 'joi-to-swagger';
+
+import { clientListTableSchema, downloadReportSchema, generateReportSchema, getReportListSchema, sendReportSchema, uploadManualReportSchema } from '../dtos/report.dtos.js';
+
+export const reportDocs = {
+
+  '/v3/report/client-list-table': {
+    post: {
+      tags: [ 'Report' ],
+      description: `Get list of client with date range`,
+      operationId: 'client-list-table',
+      parameters: {},
+      requestBody: {
+        content: {
+          'application/json': {
+            schema: j2s( clientListTableSchema ).swagger,
+          },
+        },
+      },
+      responses: {
+        200: { description: 'Get user permission successfully' },
+        401: { description: 'Unauthorized User' },
+        422: { description: 'Field Error' },
+        500: { description: 'Server Error' },
+        204: { description: 'Not Found' },
+      },
+    },
+  },
+
+
+  '/v3/report/generate-report': {
+    post: {
+      tags: [ 'Report' ],
+      description: `Push message to Qeueue to Generate Report Manually`,
+      operationId: 'generate-report',
+      parameters: {},
+      requestBody: {
+        content: {
+          'application/json': {
+            schema: j2s( generateReportSchema ).swagger,
+          },
+        },
+      },
+      responses: {
+        200: { description: 'Report Genrate Initiated Successfully' },
+        401: { description: 'Unauthorized User' },
+        422: { description: 'Field Error' },
+        500: { description: 'Server Error' },
+        204: { description: 'Not Found' },
+      },
+    },
+  },
+
+  '/v3/report/upload-manual-report': {
+    post: {
+      tags: [ 'Report' ],
+      description: `upload a Report`,
+      operationId: 'upload-manual-report',
+      parameters: {},
+      requestBody: {
+        content: {
+          'application/json': {
+            schema: j2s( uploadManualReportSchema ).swagger,
+          },
+        },
+      },
+      responses: {
+        200: { description: 'Report Uploaded Successfully' },
+        401: { description: 'Unauthorized User' },
+        422: { description: 'Field Error' },
+        500: { description: 'Server Error' },
+        204: { description: 'Not Found' },
+      },
+    },
+  },
+
+  '/v3/report/get-report-list': {
+    get: {
+      tags: [ 'Report' ],
+      description: 'Get List of Reports',
+      operationId: 'get-report-list',
+      parameters: [
+        {
+          in: 'query',
+          name: 'fileDate',
+          scema: j2s( getReportListSchema ).swagger,
+          require: true,
+        },
+        {
+          in: 'query',
+          name: 'clientId',
+          scema: j2s( getReportListSchema ).swagger,
+          require: true,
+        },
+      ],
+      responses: {
+        200: { description: 'Received successfully' },
+        401: { description: 'Unauthorized User' },
+        422: { description: 'Field Error' },
+        500: { description: 'Server Error' },
+        204: { description: 'Not Found' },
+      },
+    },
+  },
+
+  '/v3/report/download-report': {
+    get: {
+      tags: [ 'Report' ],
+      description: 'Download a Report',
+      operationId: 'download-report',
+      parameters: [
+        {
+          in: 'query',
+          name: 'filePath',
+          scema: j2s( downloadReportSchema ).swagger,
+          require: true,
+        },
+      ],
+      responses: {
+        200: { description: 'Report has been Successfully' },
+        401: { description: 'Unauthorized User' },
+        422: { description: 'Field Error' },
+        500: { description: 'Server Error' },
+        204: { description: 'Not Found' },
+      },
+    },
+  },
+
+  '/v3/report/send-report': {
+    post: {
+      tags: [ 'Report' ],
+      description: `send report a client`,
+      operationId: 'send-report',
+      parameters: {},
+      requestBody: {
+        content: {
+          'application/json': {
+            schema: j2s( sendReportSchema ).swagger,
+          },
+        },
+      },
+      responses: {
+        200: { description: 'Report has been Sent Successfully' },
+        401: { description: 'Unauthorized User' },
+        422: { description: 'Field Error' },
+        500: { description: 'Server Error' },
+        204: { description: 'Not Found' },
+      },
+    },
+  },
+
+};
+

package/src/dtos/report.dtos.js

@@ -55,3 +55,71 @@ export const updateReportValid = {
   params: updateReportSchemaParam,
 
 };
+
+
+export const clientListTableSchema = joi.object( {
+  fromDate: joi.string().required(),
+  toDate: joi.string().required(),
+  clientId: joi.array().required(),
+  limit: joi.number().optional(),
+  offset: joi.number().optional(),
+  searchValue: joi.string().optional(),
+  filterByType: joi.array().optional(),
+  sortColumnName: joi.string().optional(),
+  sortBy: joi.number().optional(),
+} );
+
+export const clientListTableValid = {
+  body: clientListTableSchema,
+
+};
+
+export const generateReportSchema = joi.object( {
+  fileDate: joi.string().required(),
+  clientId: joi.string().required(),
+} );
+
+export const generateReportValid = {
+  body: generateReportSchema,
+
+};
+
+export const uploadManualReportSchema = joi.object( {
+  fileDate: joi.string().required(),
+  clientId: joi.string().required(),
+  fileName: joi.string().required(),
+} );
+
+export const uploadManualReportValid = {
+  body: uploadManualReportSchema,
+};
+
+export const getReportListSchema = joi.object( {
+  fileDate: joi.string().required(),
+  clientId: joi.string().required(),
+} );
+
+export const getReportListValid = {
+  query: getReportListSchema,
+
+};
+
+export const downloadReportSchema = joi.object( {
+  filePath: joi.string().required(),
+} );
+
+export const downloadReportValid = {
+  query: downloadReportSchema,
+
+};
+
+export const sendReportSchema = joi.object( {
+  fileDate: joi.string().required(),
+  clientId: joi.string().required(),
+} );
+
+export const sendReportValid = {
+  body: sendReportSchema,
+
+};
+

package/src/routes/report.routes.js

@@ -1,8 +1,9 @@
 
 import express from 'express';
 import { authorize, isAllowedSessionHandler, validate } from 'tango-app-api-middleware';
-import { addReportValid, getReportValid, getSingleReportValid, updateReportValid } from '../dtos/report.dtos.js';
-import { createReport, getReport, getSingleReport, updateReport } from '../controllers/report.controllers.js';
+import { addReportValid, clientListTableValid, downloadReportValid, generateReportValid, getReportListValid, getReportValid, getSingleReportValid, sendReportValid, updateReportValid, uploadManualReportValid } from '../dtos/report.dtos.js';
+import { clientReportList, createReport, dowloadReport, generateReport, getReport, getReportList, getSingleReport, sendReport, updateBasePrice, updateReport, uploadManualReport } from '../controllers/report.controllers.js';
+import { isFileExist, isFolderExist, isReportEnable } from '../validations/report.validations.js';
 
 export const reportRouter = express.Router();
 
@@ -15,10 +16,51 @@ reportRouter.get( '/get-client-reports/:id', isAllowedSessionHandler, authorize(
 reportRouter.get( '/get-report/:id', isAllowedSessionHandler, authorize( { userType: [ 'tango' ], access: [
   { featureName: 'settings', name: 'configuration', permissions: [ 'isView' ] },
 ] } ), validate( getSingleReportValid ), getSingleReport );
+
 reportRouter.put( '/update-report/:id', isAllowedSessionHandler, authorize( { userType: [ 'tango' ], access: [
   { featureName: 'settings', name: 'configuration', permissions: [ 'isEdit' ] },
 ] } ), validate( updateReportValid ), updateReport );
 
+
+// admin report's overview
+reportRouter.post( '/client-list-table', isAllowedSessionHandler,
+    authorize( { userType: [ 'tango' ], access: [
+      { featureName: 'settings', name: 'configuration', permissions: [ 'isView' ] },
+    ] } ),
+    validate( clientListTableValid ), clientReportList );
+
+reportRouter.post( '/generate-report', isAllowedSessionHandler,
+    authorize( { userType: [ 'tango' ], access: [
+      { featureName: 'settings', name: 'configuration', permissions: [ 'isEdit' ] },
+    ] } ),
+    validate( generateReportValid ), isReportEnable, generateReport );
+
+reportRouter.post( '/upload-manual-report', isAllowedSessionHandler,
+    authorize( { userType: [ 'tango' ], access: [
+      { featureName: 'settings', name: 'configuration', permissions: [ 'isEdit' ] },
+    ] } ),
+    validate( uploadManualReportValid ), isReportEnable, uploadManualReport );
+
+reportRouter.get( '/get-report-list', isAllowedSessionHandler,
+    authorize( { userType: [ 'tango' ], access: [
+      { featureName: 'settings', name: 'configuration', permissions: [ 'isView' ] },
+    ] } ),
+    validate( getReportListValid ), isReportEnable, isFolderExist, getReportList );
+
+reportRouter.get( '/download-report', isAllowedSessionHandler,
+    authorize( { userType: [ 'tango' ], access: [
+      { featureName: 'settings', name: 'configuration', permissions: [ 'isEdit' ] },
+    ] } ),
+    validate( downloadReportValid ), isFileExist, dowloadReport );
+
+reportRouter.post( '/send-report', isAllowedSessionHandler,
+    authorize( { userType: [ 'tango' ], access: [
+      { featureName: 'settings', name: 'configuration', permissions: [ 'isEdit' ] },
+    ] } ),
+    validate( sendReportValid ), isReportEnable, sendReport );
+
+reportRouter.post( '/invoice', updateBasePrice );
+
 export default reportRouter;
 
 

package/src/service/basePrice.service.js

@@ -0,0 +1,6 @@
+import basePricingModel from 'tango-api-schema/schema/basePricing.model.js';
+
+
+export function updateOneBasePriceModel( query, record ) {
+  return basePricingModel.updateOne( query, { $set: record }, { arrayFilters: [ { 'elem.productName': 'tangoTraffic' } ], upsert: true } );
+}

package/src/service/client.service.js

@@ -0,0 +1,10 @@
+import clientModel from 'tango-api-schema/schema/client.model.js';
+
+
+export function aggregateClient( query ) {
+  return clientModel.aggregate( query );
+}
+
+export function findOneClient( query ) {
+  return clientModel.findOne( query );
+}

package/src/service/report.service.js

@@ -37,3 +37,11 @@ export function reportUpdate( { _id, fileType, email, clientId } ) {
         },
       } );
 }
+
+export function findOneReport( query ) {
+  return reportModel.findOne( query );
+}
+
+export function findReport( query, fields ) {
+  return reportModel.find( query, fields );
+}

package/src/service/user.service.js

@@ -3,3 +3,7 @@ import userModel from 'tango-api-schema/schema/user.model.js';
 export function getUserNameEmailById( objectId ) {
   return userModel.findOne( { _id: objectId }, { userName: 1, email: 1, _id: 0 } );
 }
+
+export async function findOneUser( query, fields ) {
+  return userModel.findOne( query, fields );
+}

package/src/validations/report.validations.js

@@ -0,0 +1,56 @@
+import { checkFileExist, logger } from 'tango-app-api-middleware';
+import { findOneClient } from '../service/client.service.js';
+
+
+export async function isReportEnable( req, res, next ) {
+  try {
+    const inputData = req.method !== 'GET'? req.body: req.query;
+    const getReportName = await findOneClient( { 'clientId': inputData.clientId, 'reportConfigs.report': true }, { reportName: '$reportConfigs.reportName', clientName: 1 } );
+    if ( !getReportName ) {
+      return res.sendError( 'reportName is not there in the client', 204 );
+    }
+    req.body.reportName = getReportName;
+    return next();
+  } catch ( error ) {
+    logger.error( { error: error, message: req.body, function: 'isReportEnable' } );
+    return res.sendError( error, 500 );
+  }
+}
+
+export async function isFolderExist( req, res, next ) {
+  try {
+    const inputData = req.query;
+    const fetchData = {
+      Bucket: appConfig.cloud.aws.bucket.reportBucket,
+      Key: `${inputData.fileDate}/${inputData.getReportName?.reportName}/`,
+    };
+    const isExist = await checkFileExist( fetchData );
+    if ( isExist ) {
+      return next();
+    } else {
+      return res.sendError( 'Folder does not Exists', 204 );
+    }
+  } catch ( error ) {
+    logger.error( { error: error, message: req.query, function: 'isFolderExist' } );
+    return res.sendError( error, 500 );
+  }
+}
+
+export async function isFileExist( req, res, next ) {
+  try {
+    const inputData = req.query;
+    const fetchData = {
+      Bucket: appConfig.cloud.aws.bucket.reportBucket,
+      Key: inputData.Key,
+    };
+    const isExist = await checkFileExist( fetchData );
+    if ( isExist ) {
+      return next();
+    } else {
+      return res.sendError( 'Folder does not Exists', 204 );
+    }
+  } catch ( error ) {
+    logger.error( { error: error, message: req.query, function: 'isFolderExist' } );
+    return res.sendError( error, 500 );
+  }
+}