@tiledesk/tiledesk-server 2.2.37 → 2.3.1

package/pubmodules/analytics/index.js

@@ -0,0 +1,3 @@
+const analyticsRoute = require("./analytics");
+
+module.exports = {analyticsRoute:analyticsRoute};

package/pubmodules/canned/cannedResponse.js

@@ -0,0 +1,51 @@
+var mongoose = require('mongoose');
+var Schema = mongoose.Schema;
+var winston = require('../../config/winston');
+
+
+var CannedResponseSchema = new Schema({
+  
+  title: {
+    type: String,
+    required: false,
+    index: true
+  },
+  text: {
+    type: String,
+    required: true,
+  },
+  attributes: {
+    type: Object,
+  },
+  id_project: {
+    type: String,
+    required: true,
+    index: true
+  },
+  createdBy: {
+    type: String,
+    required: true
+  },
+  status: {
+    type: Number,
+    required: false,
+    default: 100,
+    index: true
+  }, 
+},{
+  timestamps: true
+}
+);
+
+
+// CannedResponseSchema.index({text: 'text'},
+//  {"name":"cannedresponse_fulltext","default_language": "italian","language_override": "dummy"}); // schema level
+
+ var CannedResponse = mongoose.model('cannedResponse', CannedResponseSchema);
+
+ if (process.env.MONGOOSE_SYNCINDEX) {
+  CannedResponse.syncIndexes();
+  winston.info("CannedResponse syncIndexes")
+}
+
+module.exports = CannedResponse;

package/pubmodules/canned/cannedResponseRoute.js

@@ -0,0 +1,157 @@
+var express = require('express');
+var router = express.Router();
+var CannedResponse = require("./cannedResponse");
+var winston = require('../../config/winston');
+// const CannedResponseEvent = require('../event/CannedResponseEvent');
+
+
+router.post('/', function (req, res) {
+
+  winston.debug(req.body);
+  winston.debug("req.user", req.user);
+
+  var newCannedResponse = new CannedResponse({
+    title: req.body.title,  
+    text: req.body.text,  
+    id_project: req.projectid,
+    createdBy: req.user.id,
+    updatedBy: req.user.id
+  });
+
+  newCannedResponse.save(function (err, savedCannedResponse) {
+    if (err) {
+      winston.error('--- > ERROR ', err)
+
+      return res.status(500).send({ success: false, msg: 'Error saving object.' });
+    }
+
+    res.json(savedCannedResponse);
+  });
+});
+
+router.put('/:cannedResponseid', function (req, res) {
+  winston.debug(req.body);
+  var update = {};
+  
+  if (req.body.title!=undefined) {
+    update.title = req.body.title; 
+  }  
+  if (req.body.text!=undefined) {
+    update.text = req.body.text;   
+  }
+  if (req.body.attributes!=undefined) {
+    update.attributes = req.body.attributes;
+  }
+  
+  
+  CannedResponse.findByIdAndUpdate(req.params.cannedResponseid, update, { new: true, upsert: true }, function (err, updatedCannedResponse) {
+    if (err) {
+      winston.error('--- > ERROR ', err);
+      return res.status(500).send({ success: false, msg: 'Error updating object.' });
+    }
+
+  
+
+    // CannedResponseEvent.emit('CannedResponse.update', updatedCannedResponse);
+    res.json(updatedCannedResponse);
+  });
+});
+
+router.delete('/:cannedResponseid', function (req, res) {
+  winston.debug(req.body);
+
+  CannedResponse.findByIdAndUpdate(req.params.cannedResponseid, {status: 1000}, { new: true, upsert: true }, function (err, updatedCannedResponse) {
+    if (err) {
+      winston.error('--- > ERROR ', err);
+      return res.status(500).send({ success: false, msg: 'Error updating object.' });
+    }
+
+   
+
+    // CannedResponseEvent.emit('CannedResponse.delete', updatedCannedResponse);
+    res.json(updatedCannedResponse);
+  });
+});
+
+router.delete('/:cannedResponseid/physical', function (req, res) {
+  winston.debug(req.body);
+
+  CannedResponse.remove({ _id: req.params.cannedResponseid }, function (err, cannedResponse) {
+    if (err) {
+      winston.error('--- > ERROR ', err);
+      return res.status(500).send({ success: false, msg: 'Error deleting object.' });
+    }
+
+  
+    // CannedResponseEvent.emit('CannedResponse.delete', CannedResponse);
+
+    res.json(cannedResponse);
+  });
+});
+
+router.get('/:cannedResponseid', function (req, res) {
+  winston.debug(req.body);
+
+  CannedResponse.findById(req.params.cannedResponseid, function (err, cannedResponse) {
+    if (err) {
+      return res.status(500).send({ success: false, msg: 'Error getting object.' });
+    }
+    if (!cannedResponse) {
+      return res.status(404).send({ success: false, msg: 'Object not found.' });
+    }
+    res.json(cannedResponse);
+  });
+});
+
+router.get('/', function (req, res) {
+  var limit = 40; // Number of CannedResponses per page
+  var page = 0;
+
+  if (req.query.page) {
+    page = req.query.page;
+  }
+
+  var skip = page * limit;
+  winston.debug('CannedResponse ROUTE - SKIP PAGE ', skip);
+
+
+  var query = { "id_project": req.projectid, "status": {$lt:1000}};
+
+  if (req.query.full_text) {
+    winston.debug('CannedResponse ROUTE req.query.fulltext', req.query.full_text);
+    query.$text = { "$search": req.query.full_text };
+  }
+
+
+  var direction = -1; //-1 descending , 1 ascending
+  if (req.query.direction) {
+    direction = req.query.direction;
+  }
+
+  var sortField = "createdAt";
+  if (req.query.sort) {
+    sortField = req.query.sort;
+  }
+
+  var sortQuery = {};
+  sortQuery[sortField] = direction;
+
+  winston.debug("sort query", sortQuery);
+
+  return CannedResponse.find(query).
+    skip(skip).limit(limit).
+    sort(sortQuery).
+    exec(function (err, cannedResponses) {
+      if (err) {
+        winston.error('CannedResponse ROUTE - REQUEST FIND ERR ', err)
+        return (err);
+      }
+    
+        return res.json(cannedResponses);
+    });
+});
+
+
+
+
+module.exports = router;

package/pubmodules/canned/index.js

@@ -0,0 +1,3 @@
+const cannedResponseRoute = require("./cannedResponseRoute");
+
+module.exports = {cannedResponseRoute: cannedResponseRoute};

package/pubmodules/pubModulesManager.js

@@ -1,10 +1,9 @@
 
 var winston = require('../config/winston');
-// var validtoken = require('../middleware/valid-token');
-// var roleChecker = require('../middleware/has-role');
-// var passport = require('passport');
-// require('../middleware/passport')(passport);
-
+var validtoken = require('../middleware/valid-token');
+var roleChecker = require('../middleware/has-role');
+var passport = require('passport');
+require('../middleware/passport')(passport);
 
 class PubModulesManager {
 
@@ -20,12 +19,29 @@ class PubModulesManager {
         this.scheduler = undefined;
 
         this.rasa = undefined;
+        this.rasaRoute = undefined;
+
+        this.activityArchiver = undefined;
+        this.activityRoute = undefined;
+
+        this.analyticsRoute = undefined;
+
+        this.cannedResponseRoute = undefined;
+
+        this.trigger = undefined;
+        this.triggerRoute = undefined;
+
     }
 
   
 
     use(app) {
         
+        if (this.rasaRoute) {
+            app.use('/modules/rasa', this.rasaRoute);
+            winston.info("ModulesManager rasaRoute controller loaded");       
+        }
+
     }
     useUnderProjects(app) {
         var that = this;
@@ -39,10 +55,31 @@ class PubModulesManager {
             winston.info("ModulesManager eventsRoute controller loaded");       
         }
         
+
+        if (this.activityRoute) {
+            app.use('/:projectid/activities', [passport.authenticate(['basic', 'jwt'], { session: false }), validtoken, roleChecker.hasRole('admin')], this.activityRoute);
+             winston.info("ModulesManager activities controller loaded");       
+        }
+
+        if (this.analyticsRoute) {
+            app.use('/:projectid/analytics', [passport.authenticate(['basic', 'jwt'], { session: false }), validtoken, roleChecker.hasRole('agent')], this.analyticsRoute);
+             winston.info("ModulesManager analytics controller loaded");       
+         }
+
+         if (this.cannedResponseRoute) {            
+            app.use('/:projectid/canned', [passport.authenticate(['basic', 'jwt'], { session: false }), validtoken, roleChecker.hasRole('agent')], this.cannedResponseRoute);
+            winston.info("ModulesManager canned controller loaded");       
+        }
+
+        if (this.triggerRoute) {
+            app.use('/:projectid/modules/triggers', [passport.authenticate(['basic', 'jwt'], { session: false }), validtoken, roleChecker.hasRole('admin')], this.triggerRoute);
+            winston.info("ModulesManager trigger controller loaded");       
+        }
+
     }
 
    
-    init() {
+    init(config) {
         winston.debug("PubModulesManager init");
 
         try {
@@ -145,7 +182,10 @@ class PubModulesManager {
         try {
             this.rasa = require('./rasa');
             winston.debug("this.rasa:"+ this.rasa);    
-            this.rasa.listener.listen();      
+            this.rasa.listener.listen(config);      
+
+            this.rasaRoute = this.rasa.rasaRoute;
+
             winston.info("PubModulesManager initialized rasa.");
         } catch(err) {
             if (err.code == 'MODULE_NOT_FOUND') { 
@@ -157,7 +197,65 @@ class PubModulesManager {
 
 
 
+
+        try {
+            this.activityArchiver = require('./activities').activityArchiver;
+            // this.activityArchiver.listen();
+            winston.debug("this.activityArchiver:"+ this.activityArchiver);   
+            
+            this.activityRoute = require('./activities').activityRoute;
+            winston.debug("this.activityRoute:"+ this.activityRoute);
+
+            winston.info("ModulesManager activities initialized");
+        } catch(err) {
+            if (err.code == 'MODULE_NOT_FOUND') {
+                winston.info("ModulesManager init activities module not found");
+            }else {
+                winston.error("ModulesManager error initializing init activities module", err);
+            }
+        }
+
+
+        try {
+            this.analyticsRoute = require('./analytics').analyticsRoute;
+            winston.debug("this.analyticsRoute:"+ this.analyticsRoute);        
+            winston.info("ModulesManager analyticsRoute initialized");
+        } catch(err) {
+            if (err.code == 'MODULE_NOT_FOUND') {
+                winston.info("ModulesManager init analytics module not found");
+            }else {
+                winston.error("ModulesManager error initializing init analytics module", err);
+            }
+        }
+
+
+
+        try {
+            this.cannedResponseRoute = require('./canned').cannedResponseRoute;
+            winston.debug("this.cannedResponseRoute:"+ this.cannedResponseRoute);        
+            winston.info("ModulesManager cannedResponseRoute initialized");
+        } catch(err) {
+            if (err.code == 'MODULE_NOT_FOUND') {
+                winston.info("ModulesManager init canned module not found");
+            }else {
+                winston.error("ModulesManager error initializing init canned module", err);
+            }
+        }
+
       
+        try {
+            this.trigger = require('./trigger').start;
+            winston.debug("this.trigger:"+ this.trigger);
+            this.triggerRoute = require('./trigger').triggerRoute;
+            winston.debug("this.triggerRoute:"+ this.triggerRoute);       
+            winston.info("ModulesManager trigger initialized");
+        } catch(err) {
+            if (err.code == 'MODULE_NOT_FOUND') {
+                winston.info("ModulesManager init trigger module not found");
+            }else {
+                winston.error("ModulesManager error initializing init trigger module", err);
+            }
+        }
         
     }
 
@@ -212,6 +310,16 @@ class PubModulesManager {
         } 
 
 
+        if (this.activityArchiver) {
+            try {
+                this.activityArchiver.listen();
+                winston.info("ModulesManager activityArchiver started");
+            } catch(err) {        
+                winston.info("ModulesManager error starting activityArchiver module", err);            
+            }
+        }
+
+
     }
 
 

package/pubmodules/rasa/index.js

@@ -1,3 +1,10 @@
 const listener = require("./listener");
 
-module.exports = {listener:listener };
+const rasa = require("@tiledesk/tiledesk-rasa-connector");
+const rasaRoute = rasa.router;
+
+
+
+
+
+module.exports = { listener: listener, rasaRoute: rasaRoute };

package/pubmodules/rasa/listener.js

@@ -1,25 +1,46 @@
 const botEvent = require('../../event/botEvent');
 var Faq_kb = require("../../models/faq_kb");
 var winston = require('../../config/winston');
+const rasa = require("@tiledesk/tiledesk-rasa-connector");
+var configGlobal = require('../../config/global');
 
-const BOT_RASA_ENDPOINT = process.env.BOT_RASA_ENDPOINT;
+var port = process.env.PORT || '3000';
+
+const BOT_RASA_ENDPOINT = "http://localhost:" + port+ "/modules/rasa/rasabot" ||  process.env.BOT_RASA_ENDPOINT;
 winston.debug("BOT_RASA_ENDPOINT: " + BOT_RASA_ENDPOINT);
 
-if (BOT_RASA_ENDPOINT) {
+// if (BOT_RASA_ENDPOINT) {
   winston.info("Rasa endpoint: " + BOT_RASA_ENDPOINT);
-} else {
-   winston.info("Rasa endpoint not configured");
-}
+// } else {
+//    winston.info("Rasa endpoint not configured");
+// }
 
+const apiUrl = process.env.API_URL || configGlobal.apiUrl;
+winston.info('Rasa apiUrl: '+ apiUrl);
 
 class Listener {
 
-    listen() {
+    listen(config) {
 
-        winston.debug('rasa Listener listen');   
+        winston.info('Rasa Listener listen');
+        winston.debug("config databaseUri: " + config.databaseUri);  
+        
 
         var that = this;
 
+
+        rasa.startRasa(
+            {
+                KVBASE_COLLECTION : process.env.KVBASE_COLLECTION,
+                MONGODB_URI: config.databaseUri,          
+                API_ENDPOINT: apiUrl,   
+                log: true
+            }, () => {
+                winston.info("RASA proxy server successfully started.");   
+            });
+
+
+      
         botEvent.on('faqbot.create', function(bot) {
             if (BOT_RASA_ENDPOINT) {
 

package/pubmodules/scheduler/tasks/closeBotUnresponsiveRequestTask.js

@@ -50,8 +50,8 @@ scheduleUnresponsiveRequests() {
  //https://crontab.guru/examples.html
  var s= schedule.scheduleJob(this.cronExp, function(fireDate){   //TODO aggiungi un bias random
 
-    let timeInMs = Math.random() * (1000);  // avoid cluster concurrent jobs in multiple nodes between 0 and 1sec
-    winston.info('timeInMs => '+ timeInMs);
+    let timeInMs = Math.random() * (1000);  // avoid cluster concurrent jobs in multiple nodes delay between 0 and 1sec
+    winston.debug('timeInMs => '+ timeInMs);
 
     setTimeout(function () {
       winston.debug('CloseBotUnresponsiveRequestTask scheduleUnresponsiveRequests job was supposed to run at ' + fireDate + ', but actually ran at ' + new Date());