tango-app-api-report 3.1.1 → 3.1.2

package/index.js

@@ -1,7 +1,8 @@
 
 
 import { reportRouter } from './src/routes/report.routes.js';
+import { reportDocs } from './src/docs/report.docs.js';
 
-export { reportRouter };
+export { reportRouter, reportDocs };
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-report",
-    "version": "3.1.1",
+    "version": "3.1.2",
     "description": "report",
     "main": "index.js",
     "type": "module",
@@ -15,14 +15,18 @@
     "dependencies": {
         "aws-sdk": "^2.1578.0",
         "cors": "^2.8.5",
+        "dayjs": "^1.11.11",
         "dotenv": "^16.4.5",
         "express": "^4.18.3",
         "express-fileupload": "^1.5.0",
         "handlebars": "^4.7.8",
+        "joi-to-swagger": "^6.2.0",
         "mongodb": "^6.5.0",
+        "nodemailer": "^6.9.13",
         "nodemon": "^3.1.0",
-        "tango-api-schema": "^2.0.89",
-        "tango-app-api-middleware": "^3.1.1",
+        "swagger-ui-express": "^5.0.0",
+        "tango-api-schema": "^2.0.111",
+        "tango-app-api-middleware": "^3.1.13",
         "winston": "^3.12.0",
         "winston-daily-rotate-file": "^5.0.0"
     },

package/src/controllers/report.controllers.js

@@ -1,7 +1,17 @@
-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 { deleteOneReport, findOneReport, findReport, reportCreate, reportGet, reportGetSingle, reportUpdate } from '../service/report.service.js';
+import { appConfig, fileUpload, getObject, getOpenSearchData, insertOpenSearchData, listFileByPath, 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 utc from 'dayjs/plugin/utc.js';
+import timezone from 'dayjs/plugin/timezone.js';
+import aws from 'aws-sdk';
+import * as nodemailer from 'nodemailer';
+import dayjs from 'dayjs';
 
+// import basePricingModel from 'tango-api-schema/schema/basePricing.model.js';
+dayjs.extend( utc );
+dayjs.extend( timezone );
 
 export async function createReport( req, res ) {
   try {
@@ -20,9 +30,10 @@ export async function createReport( req, res ) {
       logSubType: 'reportConfig',
       changes: [ `${req.body?.fileName}` ],
       eventType: 'create',
+      showTo: [ 'tango' ],
     };
 
-    await insertOpenSearchData( 'tango-retail-activity-logs', logObj );
+    await insertOpenSearchData( appConfig.opensearch.activityLog, logObj );
     if ( createReport ) {
       res.sendSuccess( { result: 'Created Successfully' } );
     }
@@ -62,6 +73,9 @@ export async function getSingleReport( req, res ) {
 
 export async function updateReport( req, res ) {
   try {
+    const previousReport = await reportGetSingle( {
+      _id: req.params?.id,
+    } );
     const updateAck = await reportUpdate( {
       _id: req.params?.id, fileType: req.body?.fileType, email: req.body?.email, clientId: req.body?.clientId,
     } );
@@ -77,9 +91,13 @@ export async function updateReport( req, res ) {
       logSubType: 'reportConfig',
       changes: [ `Report id ${req.params?.id}` ],
       eventType: 'update',
+      showTo: [ 'tango' ],
+      current: req.body,
+      previous: previousReport,
+
     };
 
-    await insertOpenSearchData( 'tango-retail-activity-logs', logObj );
+    await insertOpenSearchData( appConfig.opensearch.activityLog, logObj );
     if ( updateAck ) {
       res.sendSuccess( { result: 'Updated Successfully' } );
     }
@@ -88,3 +106,493 @@ export async function updateReport( req, res ) {
     return res.sendError( error, 500 );
   }
 }
+
+export async function deleteReport( req, res ) {
+  try {
+    const inputData = req.params;
+    await deleteOneReport( { _id: inputData.id } );
+    return res.sendSuccess( { result: 'Report has been deleted successfully' } );
+  } catch ( error ) {
+    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;
+    const daysDifference = Math.ceil( ( new Date( inputData.toDate ) - new Date( inputData.fromDate ) ) / ( 24 * 60 * 60 * 1000 ) );
+    const query = [
+      {
+        $match: {
+          $and: [
+            { 'reportConfigs.report': { $eq: true } },
+            { status: { $eq: 'active' } },
+            { 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.sortColumnName ) {
+      const sortBy = inputData.sortBy || -1;
+      const sortColumnName =inputData.sortColumnName == 'clientId'? 'tangoId': inputData.sortColumnName;
+      query.push(
+          {
+            $sort: { fileDate: -1 },
+          },
+          {
+            $sort: { [sortColumnName]: sortBy },
+          },
+
+      );
+    }
+
+
+    if ( inputData.searchValue ) {
+      query.push(
+          {
+            $match: {
+              $or: [
+                {
+                  clientName: { $regex: inputData.searchValue, $options: 'i' },
+                },
+                {
+                  clientId: { $regex: inputData.searchValue, $options: 'i' },
+
+                },
+              ],
+            },
+          },
+      );
+    }
+
+
+    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: req.report?.reportConfigs?.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: req.report?.clientName,
+          fileDate: inputData.fileDate,
+          reportName: req.report?.reportConfigs?.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 );
+      }
+      logger.info( { files: req.files } );
+      const uploadDataParams = {
+        Bucket: appConfig.cloud.aws.bucket.reportBucket,
+        Key: `${inputData.fileDate}/${req.report?.reportConfigs?.reportName}/`,
+        fileName: inputData.fileName,
+        body: req.files.files.data,
+      };
+      const result = await fileUpload( uploadDataParams );
+      logger.info( { result: result, value: 'file upload response' } );
+      if ( result.Error ) {
+        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: req.report?.reportConfigs?.reportName,
+          clientId: data.clientId,
+        },
+      };
+      logger.info( { log: log } );
+      // 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: 'uploadManualReport' } );
+    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}/${req.report?.reportConfigs?.reportName}/`,
+    };
+    const folderPath = await listFileByPath( fetchData );
+
+    logger.info( { folderPath: folderPath, value: 'report list from bucket' } );
+    if ( folderPath?.data?.length == 0 ) {
+      return res.sendError( 'No Reports Found', 204 );
+    }
+    let temp =[];
+    for ( const item of folderPath.data ) {
+      temp.push( { Key: item.Key, LastModified: dayjs( item.LastModified ).tz( 'Asia/Kolkata' ).format( 'YYYY-MM-DD HH:mm:ss' ) } );
+    }
+    return res.sendSuccess( { result: temp } );
+  } 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}/${req.report?.reportConfigs?.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, appConfig.cloud.aws.ses.reportEmail ).then( ( response ) => {
+        result.push( response );
+      } );
+    } );
+    if ( sendMailCount == getReportList.length ) {
+      return res.sendError( 'File not available in bucket', 204 );
+    }
+    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: req.report?.reportConfigs?.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: req.report?.reportConfigs?.reportName,
+          clientId: getReportList[0].clientId,
+        },
+      };
+      logger.info( { log: log } );
+      // 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 getReportLog( req, res ) {
+  try {
+    const inputData = req.body;
+    const log = await getOpenSearchData( 'tango-retail-activity-logs',
+        {
+          'size': 100,
+          'query': {
+            'bool': {
+              'must': [
+                {
+                  'term': {
+                    'logType.keyword': 'report',
+                  },
+                },
+                {
+                  'term': {
+                    'logData.fileDate.keyword': inputData.fileDate,
+                  },
+                },
+
+              ],
+
+            },
+          },
+
+        } );
+    return res.sendSuccess( { result: log } );
+  } catch ( error ) {
+    logger.info( { error: error } );
+    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 );
+  }
+}
+
+export async function sendEmail( toEmail, mailSubject, htmlBody, attachment, sourceEmail ) {
+  return new Promise( async ( resolve, reject ) => {
+    try {
+      const ses = new aws.SES( {
+        apiVersion: 'latest',
+        region: appConfig.cloud.aws.region,
+        // accessKeyId: process.env.AWS_ACCESS_KEY_ID_SES,
+        // secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY_SES,
+      } );
+
+      let Attachment = [];
+      if ( attachment ) {
+        Attachment = attachment;
+      }
+      try {
+        let transporter = nodemailer.createTransport( {
+          SES: { ses, aws },
+        } );
+        let mailOptions = {
+          from: sourceEmail,
+          to: toEmail,
+          subject: mailSubject,
+          html: htmlBody,
+          attachments: Attachment,
+        };
+        transporter.sendMail( mailOptions )
+            .then( ( data ) => {
+              resolve( data );
+            } )
+            .catch( ( err ) => {
+              logger.error( err, 'Node Mailer EXCEPTION' );
+              reject( err );
+            } );
+      } catch ( error ) {
+        console.error( 'Error sending email:', error );
+        throw error;
+      }
+    } catch ( error ) {
+      console.error( 'Error sending email:', error );
+      throw error;
+    }
+  } );
+}
+
+

package/src/docs/report.docs.js

@@ -0,0 +1,227 @@
+import j2s from 'joi-to-swagger';
+
+import { clientListTableSchema, deleteReportSchemaParam, downloadReportSchema, generateReportSchema, getReportListSchema, getReportLogSchema, getReportSchemaParam, sendReportSchema, uploadManualReportSchema, uploadManualReportSchema2 } 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: {
+          'multipart/form-data': {
+            schema: j2s( uploadManualReportSchema2 ).swagger,
+          },
+          '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' },
+      },
+    },
+  },
+
+  '/v3/report/get-report-log': {
+    post: {
+      tags: [ 'Report' ],
+      description: `get report log`,
+      operationId: 'get-report-log',
+      parameters: {},
+      requestBody: {
+        content: {
+          'application/json': {
+            schema: j2s( getReportLogSchema ).swagger,
+          },
+        },
+      },
+      responses: {
+        200: { description: 'Successful' },
+        401: { description: 'Unauthorized User' },
+        422: { description: 'Field Error' },
+        500: { description: 'Server Error' },
+        204: { description: 'Not Found' },
+      },
+    },
+  },
+
+  '/v3/report/delete-report/{id}': {
+    get: {
+      tags: [ 'Report' ],
+      description: 'delete report by _id',
+      operationId: 'delete-report/{id}',
+      parameters: [
+        {
+          in: 'path',
+          name: 'id',
+          required: true,
+          description: 'The _id of the report.',
+          scema: j2s( deleteReportSchemaParam ).swagger,
+        },
+      ],
+      responses: {
+        200: { description: 'Success' },
+        401: { description: 'Unauthorized User' },
+        422: { description: 'Field Error' },
+        500: { description: 'Server Error' },
+        204: { description: 'Not Found' },
+      },
+    },
+  },
+
+  '/v3/report/get-client-reports/{id}': {
+    get: {
+      tags: [ 'Report' ],
+      description: 'Get list of reports by client wise',
+      operationId: 'get-client-reports/{id}',
+      parameters: [
+        {
+          in: 'path',
+          name: 'id',
+          required: true,
+          description: 'client Id',
+          scema: j2s( getReportSchemaParam ).swagger,
+        },
+      ],
+      responses: {
+        200: { description: 'Success' },
+        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,96 @@ export const updateReportValid = {
   params: updateReportSchemaParam,
 
 };
+
+export const deleteReportSchemaParam = joi.object( {
+  id: joi.string().required(),
+} );
+
+export const deleteReportValid = {
+  params: deleteReportSchemaParam,
+
+};
+
+
+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(),
+  file: joi.string().required(),
+} );
+
+export const uploadManualReportSchema2 = joi.object( {
+  file: joi.binary().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,
+
+};
+
+export const getReportLogSchema = joi.object( {
+  fileDate: joi.string().required(),
+  clientId: joi.string().required(),
+} );
+
+export const getReportLogValid = {
+  body: getReportLogSchema,
+
+};
+
+

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, deleteReportValid, downloadReportValid, generateReportValid, getReportListValid, getReportLogValid, getReportValid, getSingleReportValid, sendReportValid, updateReportValid } from '../dtos/report.dtos.js';
+import { clientReportList, createReport, deleteReport, dowloadReport, generateReport, getReport, getReportList, getReportLog, 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,61 @@ 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 );
 
+reportRouter.get( '/delete-report/:id', isAllowedSessionHandler, authorize( { userType: [ 'tango' ], access: [
+  { featureName: 'settings', name: 'configuration', permissions: [ 'isEdit' ] },
+] } ), validate( deleteReportValid ), deleteReport );
+
+
+// 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' ] },
+    ] } ),
+    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( '/get-report-log', isAllowedSessionHandler,
+    authorize( { userType: [ 'tango' ], access: [
+      { featureName: 'settings', name: 'configuration', permissions: [ 'isView' ] },
+    ] } ),
+    validate( getReportLogValid ), getReportLog );
+
+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, { collation: { locale: 'en', strength: 2 } } );
+}
+
+export function findOneClient( query, fields ) {
+  return clientModel.findOne( query, fields );
+}

package/src/service/report.service.js

@@ -17,7 +17,9 @@ export function reportGet( { clientId } ) {
   },
   {
     'fileName': 1,
-    '_id': 1,
+    'fileType': 1,
+    'email': 1,
+    'clientId': 1,
   } );
 }
 
@@ -37,3 +39,15 @@ 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 );
+}
+
+export function deleteOneReport( query ) {
+  return reportModel.deleteOne( query );
+}

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,57 @@
+import { appConfig, 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, 'status': 'active', 'reportConfigs.report': true }, { '_id': 0, 'reportConfigs.reportName': 1, 'clientName': 1 } );
+    if ( !getReportName ) {
+      return res.sendError( 'reportName is not there in the client', 204 );
+    }
+    req.report = 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}/${req.report?.reportConfigs?.reportName}/`,
+    };
+    logger.info( { fetchData: fetchData, report: req.report?.reportConfigs?.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 );
+  }
+}