feat: added routes to insert all informations

app.js

@@ -28,13 +28,13 @@ const notFoundMiddlware = require('./middleware/not-found')
 
 //middleware
 app.set('trust proxy', 1)
-app.use(rateLimiter({
+// app.use(rateLimiter({
-    windowMs: 15 * 60 * 1000,
+//     windowMs: 15 * 60 * 1000,
-    max: 60,
+//     max: 60,
-}))
+// }))
  
 // Security packages
-app.use(helmet())
+// app.use(helmet())
 app.use(cors())
 app.use(xss())
 

controllers/apiUsagePricing.js

@@ -7,6 +7,8 @@ const {
 const API_Usage = require("../models/API_Usage.js")
 const billingSumUsage = require("../utils/billingSumUsage.js")
 const moment = require('moment')
+const API_Call = require("../models/API_Call.js")
+const API_Operation = require("../models/API_Operation.js")
 
 const setApiPricing = async (req, res) => {
 
@@ -18,74 +20,64 @@ const setApiPricing = async (req, res) => {
         'billingBy',
         'billingUnit'])
 
-    const apiPricing = await API_Pricing.create({
+    const normalizedProvider = provider.trim().toLowerCase()
-        provider: provider.trim().toLowerCase(),
+    const normalizedProduct = product.trim().toLowerCase()
-        product: product.trim().toLowerCase(),
+
+    const filter = { provider: normalizedProvider, product: normalizedProduct }
+    const update = {
+        provider: normalizedProvider,
+        product: normalizedProduct,
         currency,
         price,
         billingBy,
         billingUnit,
         type
-    })
+    }
+    const options = { new: true, upsert: true }
+
+    const apiPricing = await API_Pricing.findOneAndUpdate(filter, update, options)
 
     res.status(StatusCodes.OK).json({ apiPricing })
 }
 
 const registerUsage = async (req, res) => {
-    const { 
+    const {
         provider,
         product,
         usage,
-        callerId, 
+        callerId,
-        companyId,
+        sessionId,
-        quantityOfOperationAttempts,
+        companyId, 
-        chosenOperation,
+
-        requestLogsOpenAI,
-        responseErrorLogsOpenAI,
-        quantityOfCallsToFalconFlowAPI,
-        requestLogsFalconFlowAPI,
-        responseErrorLogsFalconFlowAPI,
     } = req.body
 
     mustContainProperties(req, [
         'companyId',
         'callerId',
-        'quantityOfOperationAttempts',
+        'sessionId', 
-        'chosenOperation',
-        'requestLogsOpenAI',
-        // 'responseErrorLogsOpenAI',
-        'quantityOfCallsToFalconFlowAPI',
-        'requestLogsFalconFlowAPI',
-        // 'responseErrorLogsFalconFlowAPI',
         'provider',
         'product',
         'usage',
-    ])  
+    ])
 
     const apiPricing = await API_Pricing.findOne({
         provider: provider.trim().toLowerCase(),
         product: product.trim().toLowerCase(),
     })
-  
-    if (apiPricing) {  
 
-        const { price, billingBy, billingUnit } = apiPricing  
+    if (apiPricing) {
+
+        const { price, billingBy, billingUnit } = apiPricing
 
         const apiUsage = await API_Usage.create({
             provider: provider.trim().toLowerCase(),
-            product: product.trim().toLowerCase(), 
+            product: product.trim().toLowerCase(),
-            callerId, 
+            callerId,
-            quantityOfOperationAttempts,
+            sessionId, 
-            chosenOperation,
-            requestLogsOpenAI,
-            responseErrorLogsOpenAI,
-            quantityOfCallsToFalconFlowAPI,
-            requestLogsFalconFlowAPI,
-            responseErrorLogsFalconFlowAPI,  
             usage,
             price,
             billingBy,
-            billingUnit, 
+            billingUnit,
             companyId,
             total_cost: calculateApiUsage(price, billingUnit, usage, billingBy)
         })
@@ -98,6 +90,142 @@ const registerUsage = async (req, res) => {
 
 }
 
+const registerAPICall = async (req, res) => {
+    const {
+        callerId,
+        companyId,
+        sessionId,
+        type,
+        requestLogs,
+        responseError,
+        quantityOfAPICall
+    } = req.body
+
+    mustContainProperties(req, [
+        'companyId',
+        'callerId',
+        'sessionId'
+    ])
+
+
+    const apiCall = await API_Call.create({
+        callerId,
+        companyId,
+        sessionId,
+        type,
+        requestLogs,
+        responseError,
+        quantityOfAPICall
+    })
+
+    res.status(StatusCodes.OK).json({ apiCall })
+}
+
+const registerOperation = async (req, res) => {
+    const {
+        callerId,
+        companyId,
+        sessionId,
+        operation,
+        quantityOfOperationAttempts: quantityOfAttempts,
+    } = req.body
+  
+    mustContainProperties(req, [
+        'companyId',
+        'callerId',
+        'sessionId',
+        'operation', 
+    ])
+
+    const apiOperation = await API_Operation.create({
+        callerId,
+        companyId,
+        sessionId,
+        operation,
+        quantityOfAttempts
+    })
+
+    res.status(StatusCodes.OK).json({ apiOperation })
+}
+
+const registerAll = async (req, res) => {
+    const {
+        callerId,
+        companyId,
+        sessionId,
+        lstUsage,
+        lstRequest,
+        lstOperation,
+    } = req.body
+
+    if (lstUsage) {
+        for (const used of lstUsage) {
+
+            const { product, provider, usage } = used
+
+            const apiPricing = await API_Pricing.findOne({
+                provider: provider.trim().toLowerCase(),
+                product: product.trim().toLowerCase(),
+            })
+
+            if (apiPricing) {
+
+                const { price, billingBy, billingUnit } = apiPricing
+
+                const apiUsage = await API_Usage.create({
+                    provider: provider.trim().toLowerCase(),
+                    product: product.trim().toLowerCase(),
+                    callerId,
+                    sessionId, 
+                    usage,
+                    price,
+                    billingBy,
+                    billingUnit,
+                    companyId,
+                    total_cost: calculateApiUsage(price, billingUnit, usage, billingBy)
+                })
+
+            }
+
+        }
+    }
+    if (lstRequest) {
+        for (const request of lstRequest) {
+
+            const { type,
+                requestLogs,
+                responseError,
+                quantityOfAPICall } = request
+
+            const apiCall = await API_Call.create({
+                callerId,
+                companyId,
+                sessionId,
+                type,
+                requestLogs,
+                responseError,
+                quantityOfAPICall
+            })
+
+        }
+    }
+    if (lstOperation) {
+        for (const op of lstOperation) {
+            const { operation, quantityOfOperationAttempts: quantityOfAttempts } = op
+
+            const apiOperation = await API_Operation.create({
+                callerId,
+                companyId,
+                sessionId,
+                operation,
+                quantityOfAttempts
+            })
+        }
+    }
+
+    res.send(StatusCodes.OK) 
+}
+
 const getUsage = async (req, res) => {
 
     const { startDate, endDate, companyId, } = req.body
@@ -124,5 +252,8 @@ const getUsage = async (req, res) => {
 module.exports = {
     setApiPricing,
     registerUsage,
-    getUsage
+    registerAPICall,
+    registerOperation,
+    getUsage,
+    registerAll
 }

models/API_Call.js

@@ -0,0 +1,36 @@
+const mongoose = require('../db/connect')
+
+const { Schema } = mongoose
+
+const apiCall = new Schema({
+    companyId: {
+        type: String,
+        required: true,
+    },
+    callerId: {
+        type: String,
+        required: true,
+    }, 
+    sessionId: {
+        type: String,
+        required: true,
+    }, 
+    type: {
+        type: String,
+        enum: ['IAProvider', 'externalAPI',],
+    },
+    requestLogs: {
+        type: String, 
+    },
+    responseError: {
+        type: String, 
+    },
+    quantityOfAPICall: {
+        type: String, 
+    }, 
+
+}, { timestamps: true })
+ 
+const API_Call = mongoose.model('API_Call', apiCall)
+
+module.exports = API_Call

models/API_Operation.js

@@ -0,0 +1,31 @@
+const mongoose = require('../db/connect')
+
+const { Schema } = mongoose
+
+const apiOperation = new Schema({
+    companyId: {
+        type: String,
+        required: true,
+    },
+    callerId: {
+        type: String,
+        required: true,
+    },
+    sessionId: {
+        type: String,
+        required: true,
+    }, 
+    operation: {
+        type: String,
+        required: true,
+    }, 
+    quantityOfAttempts: {
+        type: String,
+        required: true,
+    }, 
+
+}, { timestamps: true })
+ 
+const API_Operation = mongoose.model('API_Operation', apiOperation)
+
+module.exports = API_Operation

models/API_Usage.js

@@ -11,33 +11,37 @@ const apiUsage = new Schema({
         type: String,
         required: true,
     },
-    quantityOfOperationAttempts: {
+    sessionId: {
         type: String,
         required: true,
-    },
+    }, 
-    chosenOperation: {
+    // quantityOfOperationAttempts: {
-        type: String,
+    //     type: String,
-        required: true,
+    //     required: true,
-    },
+    // },
-    requestLogsOpenAI: {
+    // chosenOperation: {
-        type: String,
+    //     type: String,
-        required: true,
+    //     required: true,
-    },
+    // },
-    responseErrorLogsOpenAI: {
+    // requestLogsOpenAI: {
-        type: String, 
+    //     type: String,
-    },
+    //     required: true,
-    quantityOfCallsToFalconFlowAPI: {
+    // },
-        type: String,
+    // responseErrorLogsOpenAI: {
-        required: true,
+    //     type: String, 
-    },
+    // },
-    requestLogsFalconFlowAPI: {
+    // quantityOfCallsToFalconFlowAPI: {
-        type: String,
+    //     type: String,
-        required: true,
+    //     required: true,
-    },
+    // },
-    responseErrorLogsFalconFlowAPI: {
+    // requestLogsFalconFlowAPI: {
-        type: String,
+    //     type: String,
-        required: true,
+    //     required: true,
-    },
+    // },
+    // responseErrorLogsFalconFlowAPI: {
+    //     type: String,
+    //     required: true,
+    // },
     provider: {
         type: String,
         required: true,

routes/apiPriceRoute.js

@@ -1,11 +1,14 @@
 const express = require('express')
 const router = express.Router()
 const { authorization, } = require('../middleware/authentication') 
-const { setApiPricing, registerUsage, getUsage} = require('../controllers/apiUsagePricing')
+const { setApiPricing, registerUsage, getUsage, registerAPICall, registerOperation, registerAll} = require('../controllers/apiUsagePricing')
 
 router.route('/create').post(authorization, setApiPricing)  
 router.route('/usage').post(authorization, registerUsage)
 router.route('/report').post(authorization, getUsage)  
+router.route('/api-call').post(authorization, registerAPICall)  
+router.route('/api-operation').post(authorization, registerOperation)  
+router.route('/api-register-all').post(authorization, registerAll)  
 
 
 

swagger.yaml

@@ -24,68 +24,82 @@ paths:
               properties:
                 companyId:
                   type: string
-                  description: Company identifier
                   example: "1"
                 callerId:
                   type: string
-                  description: Identifier of the person who made the call
                   example: "17988310949"
                 quantityOfOperationAttempts:
                   type: string
-                  description: Number of attempts to perform the operation made by the person who made the call
                   example: "2"
                 chosenOperation:
                   type: string
-                  description: Operation chosen by the person who made the call
                   example: "unblokUser"
                 requestLogsOpenAI:
                   type: string
-                  description: Response logs of requests made to openai
                   example: "{}"
                 responseErrorLogsOpenAI:
                   type: string
-                  description: Openai error request response logs
                   example: "{}"
                 quantityOfCallsToFalconFlowAPI:
                   type: string
-                  description: Number of requests made to third-party api
                   example: "2"
                 requestLogsFalconFlowAPI:
                   type: string
-                  description: Response logs of requests made to third-party api
                   example: "{}"
                 responseErrorLogsFalconFlowAPI:
                   type: string
-                  description: Third-party api error request response logs
                   example: "{}"
                 provider:
                   type: string
-                  description: Identifier of the organization providing the AI ​​solution
                   example: "openai"
                 product:
                   type: string
-                  description: Product provided by the organization that is providing AI solution
                   example: "whisper"
                 usage:
-                  type: integer
+                  type: string
-                  description: "Using the API. The product Whisper should be sent in seconds"
+                  description: "Time in seconds"
-                  example: 15
+                  example: "15"
               required:
                 - companyId
                 - callerId
                 - quantityOfOperationAttempts
                 - chosenOperation
-                - requestLogsOpenAI 
+                - requestLogsOpenAI
+                - responseErrorLogsOpenAI
                 - quantityOfCallsToFalconFlowAPI
-                - requestLogsFalconFlowAPI 
+                - requestLogsFalconFlowAPI
+                - responseErrorLogsFalconFlowAPI
                 - provider
                 - product
                 - usage
         required: true
       responses:
         '200':
-          description: ''
+          description: 'Successful response'
-          headers: {}
+          content:
+            application/json:
+              example:
+                apiUsage:
+                  companyId: "1"
+                  callerId: "17988310949"
+                  quantityOfOperationAttempts: "2"
+                  chosenOperation: "unblokUser"
+                  requestLogsOpenAI: "{}"
+                  responseErrorLogsOpenAI: "{}"
+                  quantityOfCallsToFalconFlowAPI: "2"
+                  requestLogsFalconFlowAPI: "{}"
+                  responseErrorLogsFalconFlowAPI: "{}"
+                  provider: "openai"
+                  product: "whisper"
+                  usage: 15
+                  price: "0.006"
+                  billingBy: "minute"
+                  billingUnit: 1
+                  total_cost: "0.0015000000"
+                  _id: "66a8df390cbb7371c4ade653"
+                  createdAt: "2024-07-30T12:40:25.782Z"
+                  updatedAt: "2024-07-30T12:40:25.782Z"
+                  __v: 0
       deprecated: false
       security:
       - bearer: []