@tiledesk/tiledesk-server 2.7.25 → 2.7.27

package/routes/openai.js

@@ -4,7 +4,7 @@ var { KBSettings } = require('../models/kb_setting');
 var openaiService = require('../services/openaiService');
 var winston = require('../config/winston');
 const { QuoteManager } = require('../services/QuoteManager');
-const { MODEL_MULTIPLIER } = require('../utils/aiUtils');
+const { MODELS_MULTIPLIER } = require('../utils/aiUtils');
 
 router.post('/', async (req, res) => {
 
@@ -37,7 +37,7 @@ router.post('/', async (req, res) => {
         if (usePublicKey === true) {
             let isAvailable = await quoteManager.checkQuote(req.project, obj, 'tokens');
             if (isAvailable === false) {
-                return res.status(403).send("Tokens quota exceeded")
+                return res.status(403).send({ success: false, message: "Tokens quota exceeded", error_code: 13001})
             }
         }
         
@@ -61,7 +61,7 @@ router.post('/', async (req, res) => {
             json.messages.unshift(message);
         }
 
-        let multiplier = MODEL_MULTIPLIER[json.model];
+        let multiplier = MODELS_MULTIPLIER[json.model];
         if (!multiplier) {
             multiplier = 1;
             winston.info("No multiplier found for AI model")

package/routes/project.js

@@ -239,6 +239,7 @@ router.put('/:projectid', [passport.authenticate(['basic', 'jwt'], { session: fa
   winston.debug('UPDATE PROJECT REQ BODY ', req.body);
 
   var update = {};
+  let updating_quotes = false;
 
   if (req.body.profile) {
 
@@ -248,14 +249,22 @@ router.put('/:projectid', [passport.authenticate(['basic', 'jwt'], { session: fa
           
           winston.debug("Superadmin can modify the project profile")
           update.profile = req.body.profile;
+          if (req.body.profile.quotes) {
+            updating_quotes = true;
+          }
 
-          delete req.user.attributes.isSuperadmin;
-        }
+          /**
+           * Possibile Miglioramento
+           * Eliminare solo le chiavi di redis di notify solo per le quote che si stanno modificando.
+           * Per farlo è necessario permettere la modifica puntuale del project profile, attualmente non disponibile.
+           */
 
-        else {
-          winston.verbose("Project profile can't be modified by the current user " + req.user._id);
-          return res.status(403).send({ success: false,  error: "You don't have the permission required to modify the project profile"});
-        }
+          delete req.user.attributes.isSuperadmin;
+    }
+    else {
+      winston.verbose("Project profile can't be modified by the current user " + req.user._id);
+      return res.status(403).send({ success: false,  error: "You don't have the permission required to modify the project profile"});
+    }
 
     // check if super admin
     // let token = req.headers.authorization
@@ -457,6 +466,12 @@ router.put('/:projectid', [passport.authenticate(['basic', 'jwt'], { session: fa
       return res.status(500).send({ success: false, msg: 'Error updating object.' });
     }
     projectEvent.emit('project.update', updatedProject );
+
+    if (updating_quotes == true) {
+      let obj = { createdAt: new Date() };
+      let quoteManager = req.app.get('quote_manager');
+      quoteManager.invalidateCheckpointKeys(updatedProject, obj);
+    }
     res.json(updatedProject);
   });
 });

package/routes/quotes.js

@@ -2,6 +2,7 @@ var express = require('express');
 var router = express.Router();
 const { QuoteManager } = require('../services/QuoteManager');
 let winston = require('../config/winston');
+const { MODELS_MULTIPLIER } = require('../utils/aiUtils');
 
 
 router.post('/', async (req, res) => {
@@ -39,12 +40,20 @@ router.get('/:type', async (req, res) => {
 router.post('/incr/:type', async (req, res) => {
 
     let type = req.params.type;
-    let body = req.body;
-    body.createdAt = new Date();
+    let data = req.body;
 
     let quoteManager = req.app.get('quote_manager');
-    let incremented_key = await quoteManager.incrementTokenCount(req.project, req.body);
-    let quote = await quoteManager.getCurrentQuote(req.project, req.body, type);
+
+    let multiplier = MODELS_MULTIPLIER[data.model];
+    if (!multiplier) {
+        multiplier = 1;
+        winston.info("No multiplier found for AI model")
+    }
+    data.multiplier = multiplier;
+    data.createdAt = new Date();
+
+    let incremented_key = await quoteManager.incrementTokenCount(req.project, data);
+    let quote = await quoteManager.getCurrentQuote(req.project, data, type);    
 
     res.status(200).send({ message: "value incremented for key " + incremented_key, key: incremented_key, currentQuote: quote });
 })

package/services/QuoteManager.js

@@ -4,12 +4,21 @@ const requestEvent = require('../event/requestEvent');
 const messageEvent = require('../event/messageEvent');
 const emailEvent = require('../event/emailEvent');
 
+// NEW
+// const PLANS_LIST = {
+//     FREE_TRIAL: { requests: 3000,   messages: 0,    tokens: 250000,     email: 200,    chatbots: 20,       kbs: 50 }, // same as PREMIUM
+//     SANDBOX:    { requests: 200,    messages: 0,    tokens: 100000,     email: 200,    chatbots: 2,        kbs: 50 },
+//     BASIC:      { requests: 1000,   messages: 0,    tokens: 2000000,    email: 200,    chatbots: 10,       kbs: 200},
+//     PREMIUM:    { requests: 3000,   messages: 0,    tokens: 5000000,    email: 200,    chatbots: 20,       kbs: 500},
+//     CUSTOM:     { requests: 3000,   messages: 0,    tokens: 5000000,    email: 200,    chatbots: 20,       kbs: 500}
+// }
+
 const PLANS_LIST = {
-    FREE_TRIAL: { requests: 3000,   messages: 0,    tokens: 250000,     email: 200,     chatbots: 20,       kbs: 50 }, // same as PREMIUM
-    SANDBOX:    { requests: 200,    messages: 0,    tokens: 10000,      email: 200,     chatbots: 2,        kbs: 50 },
-    BASIC:      { requests: 800,    messages: 0,    tokens: 50000,      email: 200,     chatbots: 5,        kbs: 150},
-    PREMIUM:    { requests: 3000,   messages: 0,    tokens: 250000,     email: 200,     chatbots: 20,       kbs: 300},
-    CUSTOM:     { requests: 3000,   messages: 0,    tokens: 250000,     email: 200,     chatbots: 20,       kbs: 1000}
+    FREE_TRIAL: { requests: 3000,   messages: 0,    tokens: 5000000,     email: 200,     chatbots: 20,       kbs: 50 }, // same as PREMIUM
+    SANDBOX:    { requests: 200,    messages: 0,    tokens: 100000,      email: 200,     chatbots: 2,        kbs: 50 },
+    BASIC:      { requests: 800,    messages: 0,    tokens: 2000000,     email: 200,     chatbots: 5,        kbs: 150},
+    PREMIUM:    { requests: 3000,   messages: 0,    tokens: 5000000,     email: 200,     chatbots: 20,       kbs: 300},
+    CUSTOM:     { requests: 3000,   messages: 0,    tokens: 5000000,     email: 200,     chatbots: 20,       kbs: 1000}
 }
 
 const typesList = ['requests', 'messages', 'email', 'tokens', 'chatbots', 'kbs']
@@ -41,6 +50,7 @@ class QuoteManager {
         winston.verbose("[QuoteManager] incrementRequestsCount key: " + key);
 
         await this.tdCache.incr(key)
+        this.sendEmailIfQuotaExceeded(project, request, 'requests', key);
         return key;
     }
 
@@ -61,6 +71,7 @@ class QuoteManager {
         winston.verbose("[QuoteManager] incrementEmailCount key: " + key);
 
         await this.tdCache.incr(key)
+        this.sendEmailIfQuotaExceeded(project, email, 'email', key);
         return key;
     }
 
@@ -78,7 +89,7 @@ class QuoteManager {
         let tokens = data.tokens * data.multiplier;
         await this.tdCache.incrbyfloat(key, tokens);
         // await this.tdCache.incrby(key, tokens);
-        
+        this.sendEmailIfQuotaExceeded(project, data, 'tokens', key);
         return key;
     }
     // INCREMENT KEY SECTION - END
@@ -89,11 +100,22 @@ class QuoteManager {
         winston.debug("generateKey object ", object)
         winston.debug("generateKey type " + type)
         let subscriptionDate;
-        if (this.project.profile.subStart) {
-            subscriptionDate = this.project.profile.subStart;
+
+        if (this.project.isActiveSubscription === true) {
+            if (this.project.profile.subStart) {
+                subscriptionDate = this.project.profile.subStart;
+            } else {
+                // it should never happen
+                winston.error("Error: quote manager - isActiveSubscription is true but subStart does not exists.")
+            }
         } else {
-            subscriptionDate = this.project.createdAt;
+            if (this.project.profile.subEnd) {
+                subscriptionDate = this.project.profile.subEnd;
+            } else {
+                subscriptionDate = this.project.createdAt;
+            }
         }
+
         let objectDate = object.createdAt;
         winston.debug("objectDate " + objectDate);
 
@@ -124,7 +146,7 @@ class QuoteManager {
     }
 
     /**
-     * Get quotes for a all types (tokens and request and ...)
+     * Get quotes for all types (tokens and request and ...)
      */
     async getAllQuotes(project, obj) {
 
@@ -174,6 +196,124 @@ class QuoteManager {
         }
     }
 
+    async checkQuoteForAlert(project, object, type) {
+        
+        if (quotes_enabled === false) {
+            winston.verbose("QUOTES DISABLED - checkQuote for type " + type);
+            return (null, null);
+        }
+
+        this.project = project;
+        let limits = await this.getPlanLimits();
+        winston.verbose("limits for current plan: ", limits)
+
+        let quote = await this.getCurrentQuote(project, object, type);
+        winston.verbose("getCurrentQuote resp: ", quote)
+
+        let data = {
+            limits: limits,
+            quote: quote
+        }
+
+        return data;
+    }
+
+    async sendEmailIfQuotaExceeded(project, object, type, key) {
+        
+        let data = await this.checkQuoteForAlert(project, object, type);
+        let limits = data.limits;
+        let limit = data.limits[type];
+        let quote = data.quote;
+
+        const checkpoint = await this.percentageCalculator(limit, quote);
+        if (checkpoint == 0) {
+            return;
+        }
+        winston.verbose("checkpoint perc: ", checkpoint);
+
+        // Generate redis key
+        let nKey = key + ":notify:" + checkpoint;
+        let result = await this.tdCache.get(nKey);
+        if (!result) {
+
+            let allQuotes = await this.getAllQuotes(project, object);
+            let quotes = await this.generateQuotesObject(allQuotes, limits);
+
+            let data = {
+                id_project: project._id,
+                project_name: project.name,
+                type: type,
+                checkpoint: checkpoint,
+                quotes: quotes
+            }
+
+            emailEvent.emit('email.send.quote.checkpoint', data);
+            await this.tdCache.set(nKey, 'true', {EX: 2592000}); //seconds in one month = 2592000
+        } else {
+            winston.verbose("Quota checkpoint reached email already sent.")
+        }
+
+    }
+
+    async percentageCalculator(limit, quote) {
+        
+        let p = (quote / limit) * 100;
+
+        if (p >= 100) { return 100; }
+        if (p >= 95) { return 95; }
+        if (p >= 75) { return 75; }
+        if (p >= 50) { return 50; }
+
+        return 0;
+
+    }
+
+    async invalidateCheckpointKeys(project, obj) {
+
+        this.project = project;
+        winston.verbose("invalidateCheckpointKeys project " + project._id);
+        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) => {
+            let nrequests_key = requests_key + ":notify:" + checkpoint;
+            let ntokens_key = tokens_key + ":notify:" + checkpoint;
+            let nemail_key = email_key + ":notify:" + checkpoint;
+
+            winston.verbose("invalidateCheckpointKeys nrequests_key: " + nrequests_key);
+            winston.verbose("invalidateCheckpointKeys ntokens_key: " + ntokens_key);
+            winston.verbose("invalidateCheckpointKeys nemail_key: " + nemail_key);
+
+            this.tdCache.del(nrequests_key);
+            this.tdCache.del(ntokens_key);
+            this.tdCache.del(nemail_key);
+
+            return true;
+        })
+
+    }
+
+    async generateQuotesObject(quotes, limits) {
+        let quotes_obj = {
+            requests: {
+                quote: quotes.requests.quote,
+                perc: ((quotes.requests.quote / limits['requests']) * 100).toFixed(1)
+            },
+            tokens: {
+                quote: quotes.tokens.quote,
+                perc: ((quotes.tokens.quote / limits['tokens']) * 100).toFixed(1)
+            },
+            email: {
+                quote: quotes.email.quote,
+                perc: ((quotes.email.quote / limits['email']) * 100).toFixed(1)
+            }
+        }
+        return quotes_obj
+    }
+
 
     async getPlanLimits(project) {
 
@@ -182,13 +322,11 @@ class QuoteManager {
         };
 
         let limits;
+        const plan = this.project.profile.name;
+
         if (this.project.profile.type === 'payment') {
 
-            const plan = this.project.profile.name;
             switch (plan) {
-                case 'Sandbox':
-                    limits = PLANS_LIST.SANDBOX;
-                    break;
                 case 'Basic':
                     limits = PLANS_LIST.BASIC;
                     break;
@@ -211,14 +349,21 @@ class QuoteManager {
                     limits = PLANS_LIST.FREE_TRIAL;
             }
         } else {
-            limits = PLANS_LIST.FREE_TRIAL;
-        }
 
+            if (this.project.trialExpired === false) {
+                limits = PLANS_LIST.FREE_TRIAL
+            } else {
+                limits = PLANS_LIST.SANDBOX;
+            }
+
+        }
         if (this.project?.profile?.quotes) {
             let profile_quotes = this.project?.profile?.quotes;
             const merged_quotes = Object.assign({}, limits, profile_quotes);
+            winston.verbose("Custom Limits: ", limits)
             return merged_quotes;
         } else {
+            winston.verbose("Default Limits: ", limits)
             return limits;
         }
     }
@@ -256,6 +401,8 @@ class QuoteManager {
             if (quotes_enabled === true) {
                 winston.verbose("request.create.quote event catched");
                 let result = await this.incrementRequestsCount(payload.project, payload.request);
+
+                
                 return result;
             } else {
                 winston.verbose("QUOTES DISABLED - request.create.quote event")

package/services/emailService.js

@@ -149,7 +149,6 @@ class EmailService {
     var that = this;
     winston.debug('EmailService readTemplate: ' + templateName + ' environmentVariableKey:  ' + environmentVariableKey + ' setting ' + JSON.stringify(settings));
 
-
     if (settings && settings.email && settings.email.templates) {
 
       var templates = settings.email.templates;
@@ -168,6 +167,21 @@ class EmailService {
           return resolve(template);
         });
       } 
+      else {
+        var envTemplate = process.env[environmentVariableKey];
+        winston.debug('EmailService envTemplate: ' + envTemplate);
+
+        if (envTemplate) {
+          winston.debug('EmailService return envTemplate: ' + envTemplate);
+
+          return envTemplate;
+        } else {
+          winston.debug('EmailService return file: ' + templateName);
+
+          return that.readTemplateFile(templateName);
+        }  
+      }
+      
       // else {
       //   return that.readTemplateFile(templateName);
       // }
@@ -1816,6 +1830,44 @@ class EmailService {
 
   }
 
+  async sendEmailQuotaCheckpointReached(to, firstname, project_name, resource_name, checkpoint, quotes) {
+
+    winston.info("sendEmailQuotaCheckpointReached: " + to);
+    
+    var that = this;
+
+    let html = await this.readTemplate('checkpointReachedEmail.html', undefined, "EMAIL_QUOTA_CHECKPOINT_REACHED");
+    winston.debug("html: " + html);
+
+    let template = handlebars.compile(html);
+
+    let requests_quote = quotes.requests.quote;
+    let requests_perc = quotes.requests.perc;
+
+    let tokens_quote = quotes.tokens.quote;
+    let tokens_perc = quotes.tokens.perc;
+
+    let email_quote = quotes.email.quote;
+    let email_perc = quotes.email.perc;
+
+    let replacements = {
+      firstname: firstname,
+      project_name: project_name,
+      resource_name: resource_name,
+      checkpoint: checkpoint,
+      requests_quote: requests_quote,
+      requests_perc: requests_perc,
+      tokens_quote: tokens_quote,
+      tokens_perc: tokens_perc,
+      email_quote: email_quote,
+      email_perc: email_perc
+    }
+
+    html = template(replacements);
+
+    that.send({ to: to, subject: "Update on resources usage", html: html });
+  }
+
   parseText(text, payload) {
 
 

package/services/requestService.js

@@ -525,6 +525,8 @@ class RequestService {
 
       }
 
+      let isTestConversation = false;
+
       var that = this;
 
       return new Promise(async (resolve, reject) => {
@@ -548,10 +550,16 @@ class RequestService {
             request: request
           }
     
-          let available = await qm.checkQuote(p, request, 'requests');
-          if (available === false) {
-            winston.info("Requests limits reached for project " + p._id)
-            return false;
+          if (attributes && attributes.sourcePage && (attributes.sourcePage.indexOf("td_draft=true") > -1)) {
+              winston.verbose("is a test conversation --> skip quote availability check")
+              isTestConversation = true;
+          }
+          else {
+            let available = await qm.checkQuote(p, request, 'requests');
+            if (available === false) {
+              winston.info("Requests limits reached for project " + p._id)
+              return false;
+            }
           }
         
 
@@ -717,7 +725,10 @@ class RequestService {
           winston.verbose("Performance Request created in millis: " + endDate - startDate);
 
           requestEvent.emit('request.create.simple', savedRequest);
-          requestEvent.emit('request.create.quote', payload);;
+
+          if (!isTestConversation) {
+            requestEvent.emit('request.create.quote', payload);;
+          }
 
           return resolve(savedRequest);