@tiledesk/tiledesk-server 2.10.65 → 2.10.67

package/CHANGELOG.md

@@ -5,6 +5,15 @@
 🚀        IN PRODUCTION                        🚀
 (https://www.npmjs.com/package/@tiledesk/tiledesk-server/v/2.3.77) 
 
+# 2.10.67
+- Added route for webhooks
+- Added endpoint to run webhook
+- Added chatbot subtypes
+- Updated tybot-connector to 0.4.0
+
+# 2.10.66
+- Updated QuoteService with new plans
+
 # 2.10.65
 - fix issue con /rating called by chatbot
 

package/app.js

@@ -144,6 +144,8 @@ var email = require('./routes/email');
 var property = require('./routes/property');
 var segment = require('./routes/segment');
 var webhook = require('./routes/webhook');
+var webhooks = require('./routes/webhooks');
+var copilot = require('./routes/copilot');
 
 var bootDataLoader = require('./services/bootDataLoader');
 var settingDataLoader = require('./services/settingDataLoader');
@@ -612,7 +614,8 @@ app.use('/:projectid/kb', [passport.authenticate(['basic', 'jwt'], { session: fa
 
 app.use('/:projectid/logs', [passport.authenticate(['basic', 'jwt'], { session: false }), validtoken, roleChecker.hasRole('admin')], logs);
 
-
+app.use('/:projectid/webhooks', [passport.authenticate(['basic', 'jwt'], { session: false }), validtoken, roleChecker.hasRole('admin')], webhooks);
+app.use('/:projectid/copilot', [passport.authenticate(['basic', 'jwt'], { session: false }), validtoken, roleChecker.hasRole('agent')], copilot);
 
 
 if (pubModulesManager) {

package/models/chatbotTypes.js

@@ -0,0 +1,6 @@
+module.exports = {
+    CHATBOT: 'chatbot',
+    WEBHOOK: 'webhook',
+    COPILOT: 'copilot',
+    VOICE: 'voice'
+}

package/models/faq_kb.js

@@ -43,6 +43,13 @@ var Faq_kbSchema = new Schema({
     default: 'internal',
     index: true
   },
+  subtype: {
+    type: String,
+    default: function() {
+      return this.type === 'tilebot' ? 'chatbot' : undefined;
+    },
+    index: true
+  },
   // external: {
   //   type: Boolean,
   //   default: false

package/models/webhook.js

@@ -0,0 +1,46 @@
+const mongoose = require('mongoose');
+const { customAlphabet } = require('nanoid');
+const nanoid = customAlphabet('abcdefghijklmnopqrstuvwxyz0123456789', 32);
+
+const WebhookSchema = mongoose.Schema({
+  webhook_id: {
+    type: String,
+    default: () => nanoid(),
+    unique: true,
+    required: true
+  },
+  id_project: {
+    type: String,
+    required: true
+  },
+  chatbot_id: {
+    type: String,
+    required: true
+  },
+  block_id: {
+    type: String,
+    required: true,
+  },
+  async: {
+    type: Boolean,
+    required: true,
+    default: true
+  },
+  copilot: {
+    type: Boolean,
+    required: false
+  }
+}, {
+  timestamps: true
+})
+
+WebhookSchema.index({ id_project: 1, chatbot_id: 1}, { unique: true })
+
+const Webhook = mongoose.model("Webhook", WebhookSchema);
+
+if (process.env.MONGOOSE_SYNCINDEX) {
+  Webhook.syncIndexes();
+  winston.verbose("Webhook syncIndexes");
+}
+
+module.exports = { Webhook };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tiledesk/tiledesk-server",
   "description": "The Tiledesk server module",
-  "version": "2.10.65",
+  "version": "2.10.67",
   "scripts": {
     "start": "node ./bin/www",
     "pretest": "mongodb-runner start",
@@ -47,7 +47,7 @@
     "@tiledesk/tiledesk-messenger-connector": "^0.1.23",
     "@tiledesk/tiledesk-rasa-connector": "^1.0.10",
     "@tiledesk/tiledesk-telegram-connector": "^0.1.14",
-    "@tiledesk/tiledesk-tybot-connector": "^0.3.4",
+    "@tiledesk/tiledesk-tybot-connector": "^0.4.0",
     "@tiledesk/tiledesk-whatsapp-connector": "^0.1.81",
     "@tiledesk/tiledesk-whatsapp-jobworker": "^0.0.11",
     "@tiledesk/tiledesk-sms-connector": "^0.1.11",

package/pubmodules/trigger/start.js

@@ -5,6 +5,7 @@ var projectEvent = require('../../event/projectEvent');
 var winston = require('../../config/winston');
 
 var rulesTrigger = require('./rulesTrigger');
+const chatbotTypeConstants = require('../../models/chatbotTypes');
 
 
 function saveTrigger(trigger) {
@@ -20,7 +21,7 @@ projectEvent.on('project.create', async (project) => {
 
 
         
-        var botIdentity = await faqService.create("Bot", undefined, project._id, "system", "identity", "An identity bot");
+        var botIdentity = await faqService.create("Bot", undefined, project._id, "system", "identity", chatbotTypeConstants.CHATBOT, "An identity bot");
         var botIdentityId = "bot_"+botIdentity.id;
         winston.debug("botIdentityId:"+botIdentityId);
 

package/routes/copilot.js

@@ -0,0 +1,80 @@
+let express = require('express');
+let router = express.Router();
+let winston = require('../config/winston');
+const { Webhook } = require('../models/webhook');
+const webhookService = require('../services/webhookService');
+
+router.get('/', async (req, res) => {
+
+    let id_project = req.projectid;
+    let payload = req.body;
+    let params = req.query;
+    let request_id = req.query.request_id;
+    if (!request_id) {
+        return res.status(400).send({ success: false, error: "Missing query params request_id" })
+    }
+    payload.request_id = request_id;
+    payload.webhook_query_params = params;
+
+    let webhooks = await Webhook.find({ id_project: id_project, copilot: true }).catch((err) => {
+        winston.error("Error finding copilot webhooks: ", err);
+        return res.status(500).send({ success: false, error: err });
+    })
+
+    let promises = webhooks.map((w) => 
+        webhookService.run(w, payload)
+            .then((response) => {
+                return response;
+            }).catch((err) => {
+                winston.error("Error running webhook: ", err);
+                return;
+            })
+    )
+
+    Promise.all(promises).then((result) => {
+        return res.status(200).send(result);
+    }).catch((err) => {
+        // Should never executed - check it
+        return res.status(500).send({ success: false, error: err });
+    })
+
+})
+
+router.post('/', async (req, res) => {
+
+    let id_project = req.projectid;
+    let payload = req.body;
+    let params = req.query;
+    let request_id = req.query.request_id;
+    if (!request_id) {
+        return res.status(400).send({ success: false, error: "Missing query params request_id" })
+    }
+    payload.request_id = request_id;
+    payload.webhook_query_params = params;
+
+    let webhooks = await Webhook.find({ id_project: id_project, copilot: true }).catch((err) => {
+        winston.error("Error finding copilot webhooks: ", err);
+        return res.status(500).send({ success: false, error: err });
+    })
+
+    let promises = webhooks.map((w) => 
+        webhookService.run(w, payload)
+            .then((response) => {
+                return response;
+            }).catch((err) => {
+                winston.error("Error running webhook: ", err);
+                return;
+            })
+    )
+
+    Promise.all(promises).then((result) => {
+        return res.status(200).send(result);
+    }).catch((err) => {
+        // Should never executed - check it
+        return res.status(500).send({ success: false, error: err });
+    })
+
+})
+
+
+module.exports = router;

package/routes/faq_kb.js

@@ -18,6 +18,7 @@ const trainingService = require('../services/trainingService');
 var roleChecker = require('../middleware/has-role');
 const roleConstants = require('../models/roleConstants');
 const errorCodes = require('../errorCodes');
+const chatbotTypeConstants = require('../models/chatbotTypes');
 
 let chatbot_templates_api_url = process.env.CHATBOT_TEMPLATES_API_URL
 
@@ -50,7 +51,7 @@ router.post('/', roleChecker.hasRole('admin'), async function (req, res) {
     //return res.status(403).send({ success: false, error: "Maximum number of chatbots reached for the current plan", plan_limit: chatbots_limit })
   }
 
-  faqService.create(req.body.name, req.body.url, req.projectid, req.user.id, req.body.type, req.body.description, req.body.webhook_url, req.body.webhook_enabled, req.body.language, req.body.template, req.body.mainCategory, req.body.intentsEngine, req.body.attributes).then(function (savedFaq_kb) {
+  faqService.create(req.body.name, req.body.url, req.projectid, req.user.id, req.body.type, req.body.subtype,  req.body.description, req.body.webhook_url, req.body.webhook_enabled, req.body.language, req.body.template, req.body.mainCategory, req.body.intentsEngine, req.body.attributes).then(function (savedFaq_kb) {
     res.json(savedFaq_kb);
   });
 
@@ -683,7 +684,7 @@ router.post('/importjson/:id_faq_kb', roleChecker.hasRole('admin'), upload.singl
   // **** CREATE TRUE option ****
   // ****************************
   if (req.query.create === 'true') {
-    let savedChatbot = await faqService.create(json.name, undefined, req.projectid, req.user.id, "tilebot", json.description, json.webhook_url, json.webhook_enabled, json.language, undefined, undefined, undefined, json.attributes)
+    let savedChatbot = await faqService.create(json.name, undefined, req.projectid, req.user.id, "tilebot", json.subtype, json.description, json.webhook_url, json.webhook_enabled, json.language, undefined, undefined, undefined, json.attributes)
       .catch((err) => {
           winston.error("Error creating new chatbot")
           return res.status(400).send({ succes: false, message: "Error creatings new chatbot", error: err })

package/routes/webhook.js

@@ -1,10 +1,23 @@
 var express = require('express');
 var router = express.Router();
+const uuidv4 = require('uuid/v4');
 var { KB, Namespace } = require('../models/kb_setting');
 var winston = require('../config/winston');
 const JobManager = require('../utils/jobs-worker-queue-manager/JobManagerV2');
 const { Scheduler } = require('../services/Scheduler');
 const { AiReindexService } = require('../services/aiReindexService');
+const { Webhook } = require('../models/webhook');
+const httpUtil = require('../utils/httpUtil');
+var jwt = require('jsonwebtoken');
+const Faq_kb = require('../models/faq_kb');
+const webhookService = require('../services/webhookService');
+
+const port = process.env.PORT || '3000';
+let TILEBOT_ENDPOINT = "http://localhost:" + port + "/modules/tilebot/";;
+if (process.env.TILEBOT_ENDPOINT) {
+    TILEBOT_ENDPOINT = process.env.TILEBOT_ENDPOINT + "/"
+}
+winston.debug("TILEBOT_ENDPOINT: " + TILEBOT_ENDPOINT);
 
 const KB_WEBHOOK_TOKEN = process.env.KB_WEBHOOK_TOKEN || 'kbcustomtoken';
 const AMQP_MANAGER_URL = process.env.AMQP_MANAGER_URL;
@@ -167,6 +180,63 @@ router.post('/kb/status', async (req, res) => {
 
 })
 
+router.all('/:webhook_id', async (req, res) => {
+
+  let webhook_id = req.params.webhook_id;
+  let payload = req.body;
+  payload.webhook_http_method = req.method;
+  let params = req.query;
+  if (params) {
+    payload.webhook_query_params = params;
+  }
+
+  let webhook = await Webhook.findOne({ webhook_id: webhook_id }).catch((err) => {
+    winston.error("Error finding webhook: ", err);
+    return res.status(500).send({ success: false, error: err });
+  })
+
+  if (!webhook) {
+    winston.warn("Webhook not found with id " + webhook_id);
+    return res.status(404).send({ success: false, error: "Webhook not found with id " + webhook_id });
+  }
+
+  webhookService.run(webhook, payload).then((response) => {
+    return res.status(200).send(response);
+  }).catch((err) => {
+    let status = err.status || 500;
+    return res.status(status).send(err.data);
+  })
+  
+  // let chatbot = await Faq_kb.findById(webhook.chatbot_id).select("+secret").catch((err) => {
+  //   winston.error("Error finding chatbot ", err);
+  //   return res.status(500).send({ success: false, error: "Error finding chatbot with id " + webhook.chatbot_id})
+  // })
+
+  // if (!chatbot) {
+  //   winston.verbose("Chatbot not found with id " + webhook.chatbot_id);
+  //   return res.status(404).send({ success: false, error: "Chatbot not found with id " + webhook.chatbot_id })
+  // }
+
+  // let token = await generateChatbotToken(chatbot);
+
+  // let url = TILEBOT_ENDPOINT + 'block/' + webhook.id_project + "/" + webhook.chatbot_id + "/" + webhook.block_id;
+  // winston.info("Webhook chatbot URL: ", url);
+
+  // payload.async = webhook.async;
+  // payload.token = token;
+
+  // if (process.env.NODE_ENV === 'test') {
+  //   return res.status(200).send({ success: true, message: "Webhook disabled in test mode"})
+  // }
+  
+  // let response = await httpUtil.post(url, payload).catch((err) => {
+  //   winston.error("Error calling webhook on post: ", err);
+  //   return res.status(500).send({ success: false, error: err });
+  // })
+
+  // res.status(200).send(response.data);
+})
+
 async function scheduleScrape(resources) {
 
   let scheduler = new Scheduler({ jobManager: jobManager });
@@ -185,4 +255,19 @@ async function scheduleScrape(resources) {
   return true;
 }
 
+async function generateChatbotToken(chatbot) {
+  let signOptions = {
+    issuer: 'https://tiledesk.com',
+    subject: 'bot',
+    audience: 'https://tiledesk.com/bots/' + chatbot._id,
+    jwtid: uuidv4()
+  };
+
+  let botPayload = chatbot.toObject();
+  let botSecret = botPayload.secret;
+
+  var bot_token = jwt.sign(botPayload, botSecret, signOptions);
+  return bot_token;
+}
+
 module.exports = router;

package/routes/webhooks.js

@@ -0,0 +1,156 @@
+var express = require('express');
+var router = express.Router();
+var winston = require('../config/winston');
+const { Webhook } = require('../models/webhook');
+const httpUtil = require('../utils/httpUtil');
+const { customAlphabet } = require('nanoid');
+const nanoid = customAlphabet('abcdefghijklmnopqrstuvwxyz0123456789', 32);
+
+// const port = process.env.PORT || '3000';
+// let TILEBOT_ENDPOINT = "http://localhost:" + port + "/modules/tilebot/ext/";;
+// if (process.env.TILEBOT_ENDPOINT) {
+//     TILEBOT_ENDPOINT = process.env.TILEBOT_ENDPOINT + "/ext/"
+// }
+// winston.debug("TILEBOT_ENDPOINT: " + TILEBOT_ENDPOINT);
+
+
+router.get('/:chatbot_id/', async (req, res) => {
+  
+  let id_project = req.projectid;
+  let chatbot_id = req.params.chatbot_id;
+
+  let webhook = await Webhook.findOne({ id_project: id_project, chatbot_id: chatbot_id }).catch((err) => {
+    winston.error("Error finding webhook: ", err);
+    return res.status(500).send({ success: false, error: "Error findin webhook with for chatbot " + chatbot_id });
+  })
+
+  if (!webhook) {
+    winston.verbose("Webhook not found for chatbot " + chatbot_id);
+    return res.status(404).send({ success: false, error: "Webhook not found for chatbot " + chatbot_id });
+  }
+
+  res.status(200).send(webhook);
+
+})
+
+
+router.post('/', async (req, res) => {
+
+  let id_project = req.projectid;
+
+  let webhook = new Webhook({
+    id_project: id_project,
+    chatbot_id: req.body.chatbot_id || req.body.id_faq_kb,
+    block_id: req.body.block_id,
+    async: req.body.async
+  })
+
+  webhook.save((err, savedWebhook) => {
+    if (err) {
+      if (err.code === 11000) {
+        winston.verbose("Webhook already exists for chatbot " + chatbot_id);
+        return res.status(403).send({ success: false, message: "Webhook already exists for chatbot " + chatbot_id });
+      } 
+      winston.error("Error saving new webhook ", err);
+      return res.status(500).send({ success: false, error: err });
+    }
+
+    res.status(200).send(savedWebhook);
+  })
+
+})
+
+// router.post('/webhook_id', async (req, res) => {
+
+//   let id_project = req.projectid;
+//   let webhook_id = req.params.webhook_id;
+//   let payload = req.body;
+
+//   let webhook = await Webhook.findOne({ id_project: id_project, webhook_id: webhook_id }).catch((err) => {
+//     winston.error("Error finding webhook: ", err);
+//     return res.status(500).send({ success: false, error: err });
+//   })
+
+//   if (!webhook) {
+//     winston.warn("Webhook not found with id " + webhook_id);
+//     return res.status(404).send({ success: false, error: "Webhook not found with id " + webhook_id });
+//   }
+
+//   let url = TILEBOT_ENDPOINT + 'block/' + id_project + "/" + webhook.chatbot_id + "/" + webhook.block_id;
+
+//   payload.async = webhook.async;
+  
+//   let response = httpUtil.post(url, payload).catch((err) => {
+//     winston.error("Error calling webhook on post: ", err);
+//     return res.status(500).send({ success: false, error: err });
+//   })
+
+//   res.status(200).send(response);
+
+// })
+
+router.put("/:chatbot_id/regenerate", async (req, res) => {
+  
+  let id_project = req.projectid;
+  let chatbot_id = req.params.chatbot_id;
+
+  let update = {
+    webhook_id: nanoid()
+  }
+
+  let updatedWebhook = await Webhook.findOneAndUpdate({ id_project: id_project, chatbot_id: chatbot_id }, update, { new: true }).catch((err) => {
+    winston.error("Error updating webhook ", err);
+    return res.status(500).send({ success: false, error: "Error updating webhook for chatbot " + chatbot_id });
+  })
+
+  if (!updatedWebhook) {
+    winston.verbose("Webhook not found for chatbot " + chatbot_id);
+    return res.status(404).send({ success: false, error: "Webhook not found for chatbot " + chatbot_id });
+  }
+
+  res.status(200).send(updatedWebhook);
+})
+
+router.put("/:chatbot_id", async (req, res) => {
+
+  let id_project = req.projectid;
+  let chatbot_id = req.params.chatbot_id;
+
+  let update = {};
+
+  if (req.body.hasOwnProperty("async")) {
+    update.async = req.body.async;
+  }
+
+  if (req.body.hasOwnProperty("copilot")) {
+    update.copilot = req.body.copilot;
+  }
+
+  let updatedWebhook = await Webhook.findOneAndUpdate({ id_project: id_project, chatbot_id: chatbot_id }, update, { new: true }).catch((err) => {
+    winston.error("Error updating webhook ", err);
+    return res.status(500).send({ success: false, error: "Error updating webhook for chatbot " + chatbot_id });
+  })
+
+  if (!updatedWebhook) {
+    winston.verbose("Webhook not found for chatbot " + chatbot_id);
+    return res.status(404).send({ success: false, error: "Webhook not found for chatbot " + chatbot_id });
+  }
+
+  res.status(200).send(updatedWebhook);
+})
+
+router.delete("/:chatbot_id", async (req, res) => {
+
+  let id_project = req.projectid;
+  let chatbot_id = req.params.chatbot_id;
+
+  await Webhook.deleteOne({ id_project: id_project, chatbot_id: chatbot_id }).catch((err) => {
+    winston.error("Error deleting webhook ", err);
+    return res.status(500).send({ success: false, error: "Error deleting webhook for chatbot " + chatbot_id });
+  })
+
+  res.status(200).send({ success: true, message: "Webhook for chatbot " + chatbot_id +  " deleted successfully" });
+})
+
+
+module.exports = router;

package/services/QuoteManager.js

@@ -14,16 +14,23 @@ const emailEvent = require('../event/emailEvent');
 //     CUSTOM:     { requests: 3000,   messages: 0,    tokens: 5000000,    email: 200,    chatbots: 20,       kbs: 500}
 // }
 
-
 const PLANS_LIST = {
-    FREE_TRIAL: { requests: 200,    messages: 0,    tokens: 100000,     voice_duration: 0,       email: 200,     chatbots: 20,      namespace: 3,   kbs: 50     }, // same as PREMIUM
-    SANDBOX:    { requests: 200,    messages: 0,    tokens: 100000,     voice_duration: 0,       email: 200,     chatbots: 2,       namespace: 1,   kbs: 50     },
-    BASIC:      { requests: 800,    messages: 0,    tokens: 2000000,    voice_duration: 0,       email: 200,     chatbots: 5,       namespace: 1,   kbs: 150    },
-    PREMIUM:    { requests: 3000,   messages: 0,    tokens: 5000000,    voice_duration: 0,       email: 200,     chatbots: 20,      namespace: 3,   kbs: 300    },
-    TEAM:       { requests: 5000,   messages: 0,    tokens: 10000000,   voice_duration: 0,       email: 200,     chatbots: 50,      namespace: 10,  kbs: 1000   },
-    CUSTOM:     { requests: 5000,   messages: 0,    tokens: 10000000,   voice_duration: 120000,  email: 200,     chatbots: 50,      namespace: 10,  kbs: 1000   },
+    //FREE_TRIAL: { requests: 200,    messages: 0,    tokens: 100000,     voice_duration: 0,       email: 200,     chatbots: 20,      namespace: 3,   kbs: 50     }, // same as PREMIUM
+    SANDBOX:    { requests: 200,    messages: 0,    tokens: 100000,     voice_duration: 0,          email: 200,     chatbots: 2,    namespace: 1,   kbs: 50 },
+    BASIC:      { requests: 800,    messages: 0,    tokens: 2000000,    voice_duration: 0,          email: 200,     chatbots: 5,    namespace: 1,   kbs: 150 },
+    PREMIUM:    { requests: 3000,   messages: 0,    tokens: 5000000,    voice_duration: 0,          email: 200,     chatbots: 20,   namespace: 3,   kbs: 300 },
+    TEAM:       { requests: 5000,   messages: 0,    tokens: 10000000,   voice_duration: 0,          email: 200,     chatbots: 50,   namespace: 10,  kbs: 1000 },
+    //CUSTOM:     { requests: 5000,   messages: 0,    tokens: 10000000,   voice_duration: 120000,  email: 200,     chatbots: 50,      namespace: 10,  kbs: 1000   },
+    // FROM MARCH 2025
+    FREE_TRIAL: { requests: 3000,   messages: 0,    tokens: 5000000,    voice_duration: 120000,     email: 200,     chatbots: 5,    namespace: 1,   kbs: 50 },  // same as PRO
+    STARTER:    { requests: 800,    messages: 0,    tokens: 2000000,    voice_duration: 0,          email: 200,     chatbots: 5,    namespace: 1,   kbs: 150 },
+    PRO:        { requests: 3000,   messages: 0,    tokens: 5000000,    voice_duration: 0,          email: 200,     chatbots: 20,   namespace: 3,   kbs: 300 },
+    BUSINESS:   { requests: 5000,   messages: 0,    tokens: 10000000,   voice_duration: 0,          email: 200,     chatbots: 50,   namespace: 10,  kbs: 1000 },
+    CUSTOM:     { requests: 5000,   messages: 0,    tokens: 10000000,   voice_duration: 120000,     email: 200,     chatbots: 50,   namespace: 10,  kbs: 1000 }
 }
 
+
+
 const typesList = ['requests', 'messages', 'email', 'tokens', 'voice_duration', 'chatbots', 'kbs']
 
 let quotes_enabled = true;
@@ -88,7 +95,7 @@ class QuoteManager {
             winston.debug("QUOTES DISABLED - incrementTokenCount")
             return key;
         }
-        
+
         let tokens = data.tokens * data.multiplier;
         await this.tdCache.incrbyfloat(key, tokens);
         // await this.tdCache.incrby(key, tokens);
@@ -110,7 +117,7 @@ class QuoteManager {
         if (request?.duration) {
             let duration = Math.round(request.duration / 1000); // from ms to s
             await this.tdCache.incrby(key, duration);
-    
+
             this.sendEmailIfQuotaExceeded(project, request, 'voice_duration', key);
         }
     }
@@ -200,7 +207,6 @@ class QuoteManager {
      * Get current quote for a single type (tokens or request or ...)
      */
     async getCurrentQuote(project, object, type) {
-
         this.project = project;
         let key = await this.generateKey(object, type);
         winston.verbose("[QuoteManager] getCurrentQuote key: " + key);
@@ -261,7 +267,7 @@ class QuoteManager {
     }
 
     async checkQuoteForAlert(project, object, type) {
-        
+
         if (quotes_enabled === false) {
             winston.verbose("QUOTES DISABLED - checkQuote for type " + type);
             return (null, null);
@@ -283,7 +289,7 @@ class QuoteManager {
     }
 
     async sendEmailIfQuotaExceeded(project, object, type, key) {
-        
+
         let data = await this.checkQuoteForAlert(project, object, type);
         let limits = data.limits;
         let limit = data.limits[type];
@@ -312,7 +318,7 @@ class QuoteManager {
             }
 
             emailEvent.emit('email.send.quote.checkpoint', data);
-            await this.tdCache.set(nKey, 'true', {EX: 2592000}); //seconds in one month = 2592000
+            await this.tdCache.set(nKey, 'true', { EX: 2592000 }); //seconds in one month = 2592000
         } else {
             winston.verbose("Quota checkpoint reached email already sent.")
         }
@@ -320,7 +326,7 @@ class QuoteManager {
     }
 
     async percentageCalculator(limit, quote) {
-        
+
         let p = (quote / limit) * 100;
 
         if (p >= 100) { return 100; }
@@ -339,10 +345,10 @@ class QuoteManager {
         let requests_key = await this.generateKey(obj, 'requests');
         let tokens_key = await this.generateKey(obj, 'tokens');
         let email_key = await this.generateKey(obj, 'email');
-        
+
         let checkpoints = ['50', '75', '95', '100']
 
-        checkpoints.forEach( async (checkpoint) => {
+        checkpoints.forEach(async (checkpoint) => {
             let nrequests_key = requests_key + ":notify:" + checkpoint;
             let ntokens_key = tokens_key + ":notify:" + checkpoint;
             let nemail_key = email_key + ":notify:" + checkpoint;
@@ -390,7 +396,22 @@ class QuoteManager {
 
         if (this.project.profile.type === 'payment') {
 
+            if (this.project.isActiveSubscription === false) {
+                limits = PLANS_LIST.SANDBOX;
+                return limits;
+
+            }
+
             switch (plan) {
+                case 'Starter':
+                    limits = PLANS_LIST.STARTER
+                    break;
+                case 'Pro':
+                    limits = PLANS_LIST.PRO
+                    break;
+                case 'Business':
+                    limits = PLANS_LIST.BUSINESS
+                    break;
                 case 'Basic':
                     limits = PLANS_LIST.BASIC;
                     break;
@@ -415,6 +436,7 @@ class QuoteManager {
                 default:
                     limits = PLANS_LIST.FREE_TRIAL;
             }
+
         } else {
 
             if (this.project.trialExpired === false) {
@@ -424,6 +446,7 @@ class QuoteManager {
             }
 
         }
+
         if (this.project?.profile?.quotes) {
             let profile_quotes = this.project?.profile?.quotes;
             const merged_quotes = Object.assign({}, limits, profile_quotes);
@@ -454,7 +477,7 @@ class QuoteManager {
                 winston.debug("Subscription date from project createdAt: " + subscriptionDate.toISOString());
             }
         }
-        
+
         let now = moment();
         winston.debug("now: ", now);