@tiledesk/tiledesk-server 2.2.39 → 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 {
 
@@ -21,6 +20,17 @@ class PubModulesManager {
 
         this.rasa = undefined;
         this.rasaRoute = undefined;
+
+        this.activityArchiver = undefined;
+        this.activityRoute = undefined;
+
+        this.analyticsRoute = undefined;
+
+        this.cannedResponseRoute = undefined;
+
+        this.trigger = undefined;
+        this.triggerRoute = undefined;
+
     }
 
   
@@ -45,6 +55,27 @@ 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");       
+        }
+
     }
 
    
@@ -166,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);
+            }
+        }
         
     }
 
@@ -221,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/trigger/default.js

@@ -0,0 +1,271 @@
+var Trigger = require('./models/trigger');
+
+
+var defTrigger = {};
+var defTriggerObj = {};
+       
+
+
+var tNewConversationObj = {
+name: 'New Conversation',
+description: 'Create a temporary chat when new conversation button is pressed.',
+trigger: {key:'event.emit',name:'Event emit event', description: 'Standard event emit event'},
+conditions:{ all: [{key:'event.name',fact: 'json',path: 'name', operator:'equal', value: 'new_conversation'}]},
+actions: [{key:'request.create', parameters: {departmentid: 'default', text:"welcome:tdk_req_status_hidden"}}], 
+enabled: true,
+code: 's_new_conversation_01',
+type: 'internal',
+version: 1,
+createdBy: 'system',
+updatedBy: 'system'
+};
+
+var tNewConversation = new Trigger(tNewConversationObj);          
+
+defTrigger['s_new_conversation_01'] = tNewConversation;
+defTriggerObj['s_new_conversation_01'] = tNewConversationObj;
+
+
+
+
+
+var tWelcomeOnlineObj = 
+{
+    name: 'Online Welcome Greeting',
+    description: 'Send a welcome message if there are online agents to the visitor that create a chat.',
+    trigger: {key:'request.create',name:'Request create event', description: 'Standard request create event'},
+    conditions:{ all: [
+                    {key:'request.departmentHasBot',fact: 'json',path: 'department.hasBot', operator:'equal', value: false},
+                    {key:'request.snapshot.availableAgentsCount',fact: 'json',path: 'snapshot.availableAgentsCount', operator:'greaterThan', value: 0},
+                    {key:'request.isOpen',fact: 'json',path: 'isOpen', operator:'equal', value: true},
+                    {key:'request.first_text',fact: 'json',path: 'first_text', operator:'equal', value: 'welcome'},
+                    {key:'request.statusRequestStatus',fact: 'json',path: 'status', operator:'equal', value: 50}
+                ]},
+    actions: [{key:'message.send', parameters: {text:"${LABEL_FIRST_MSG}"}}], 
+    enabled:true,
+    code: 's_online_welcome_01',
+    type: 'internal',
+    version: 3,
+    createdBy: 'system',
+    updatedBy: 'system'
+}
+
+var tWelcomeOnline = new Trigger(tWelcomeOnlineObj);          
+
+defTrigger['s_online_welcome_01'] = tWelcomeOnline;
+defTriggerObj['s_online_welcome_01'] = tWelcomeOnlineObj
+
+
+
+
+var tWelcomeOfflineObj = {
+    name: 'Offline Welcome Greeting',
+    description: 'Send a welcome message if there aren\'t online agents to the visitor that create a chat.',
+    trigger: {key:'request.create',name:'Request create event', description: 'Standard request create event'},
+    conditions:{ all: [
+                    {key:'request.departmentHasBot',fact: 'json',path: 'department.hasBot', operator:'equal', value: false},
+                    {key:'request.snapshot.availableAgentsCount',fact: 'json',path: 'snapshot.availableAgentsCount', operator:'equal', value: 0},
+                    {key:'request.statusRequestStatus',fact: 'json',path: 'status', operator:'equal', value: 50},
+                    {key:'request.isOpen',fact: 'json',path: 'isOpen', operator:'equal', value: true},
+                    {key:'request.first_text',fact: 'json',path: 'first_text', operator:'equal', value: 'welcome'}
+                ]},
+    actions: [{key:'message.send', parameters: {text:"${LABEL_FIRST_MSG_NO_AGENTS}"}}], 
+    enabled:true,
+    code: 's_offline_welcome_01',
+    type: 'internal',
+    version: 3,
+    createdBy: 'system',
+    updatedBy: 'system'
+}
+var tWelcomeOffline = new Trigger(tWelcomeOfflineObj);      
+
+defTrigger['s_offline_welcome_01'] = tWelcomeOffline;
+defTriggerObj['s_offline_welcome_01'] = tWelcomeOfflineObj;
+
+
+
+var tWelcomeClosedOperatingHoursObj = {
+    name: 'Office Closed Notice',
+    description: 'Send an office closed message if a visitor asks for support outside of the operating hours.',
+    trigger: {key:'request.create',name:'Request create event', description: 'Standard request create event'},
+    conditions:{ all: [
+                    {key:'request.departmentHasBot',fact: 'json',path: 'department.hasBot', operator:'equal', value: false},
+                    {key:'request.statusRequestStatus',fact: 'json',path: 'status', operator:'equal', value: 50},
+                    {key:'request.isOpen',fact: 'json',path: 'isOpen', operator:'equal', value: false},
+                    {key:'request.first_text',fact: 'json',path: 'first_text', operator:'equal', value: 'welcome'}
+                ]},
+    actions: [{key:'message.send', parameters: {text:"${LABEL_FIRST_MSG_OPERATING_HOURS_CLOSED}"}}], 
+    enabled:true,
+    code: 's_closed_operating_hours_01',
+    type: 'internal',
+    version: 2,
+    createdBy: 'system',
+    updatedBy: 'system'
+}
+var tWelcomeClosedOperatingHours = new Trigger(tWelcomeClosedOperatingHoursObj);      
+
+defTrigger['s_closed_operating_hours_01'] = tWelcomeClosedOperatingHours;
+defTriggerObj['s_closed_operating_hours_01'] = tWelcomeClosedOperatingHoursObj;
+
+
+
+
+
+
+var tInviteBotObj = {
+    name: 'Invite Bot',
+    description: 'Invite if available the department bot to the temporary chat and start it.',
+    trigger: {key:'request.create',name:'Request create event', description: 'Standard request create event'},
+    conditions:{ all: [
+                    {key:'request.statusRequestStatus',fact: 'json',path: 'status', operator:'equal', value: 50},
+                    {key:'request.departmentHasBot',fact: 'json',path: 'department.hasBot', operator:'equal', value: true},
+                    {key:'request.first_text',fact: 'json',path: 'first_text', operator:'equal', value: 'welcome'}
+                ]},
+    actions: [{key:'request.department.bot.launch'}], 
+    enabled:true,
+    code: 's_invite_bot_01',
+    type: 'internal',
+    version: 2,
+    createdBy: 'system',
+    updatedBy: 'system'
+}
+
+var tInviteBot = new Trigger(tInviteBotObj);          
+
+defTrigger['s_invite_bot_01'] = tInviteBot;
+defTriggerObj['s_invite_bot_01'] = tInviteBotObj;
+
+
+
+
+
+var tCheckoutPageObj = {
+    name: 'Checkout Page',
+    description: 'Reduce cart abandonment by engaging customer that are on the checkout page.',
+    trigger: {key:'request.create',name:'Request create event', description: 'Standard request create event'},
+    conditions:{ all: [
+                    {key:"request.sourcePageUrl", fact:"json", path:"sourcePage", operator:"in", value:"/checkout.html"},
+                    {key:'request.departmentHasBot',fact: 'json',path: 'department.hasBot', operator:'equal', value: false},
+                    {key:'request.statusRequestStatus',fact: 'json',path: 'status', operator:'equal', value: 50}
+                ]},
+    actions: [{key:'message.send', parameters: {text:"Hey, do you need help to complete the checkout?"}}], 
+    enabled:false,
+    code: 's_checkout_page_01',
+    version: 1,
+    createdBy: 'system',
+    updatedBy: 'system'
+}
+
+var tCheckoutPage = new Trigger(tCheckoutPageObj);          
+
+defTrigger['s_checkout_page_01'] = tCheckoutPage;
+defTriggerObj['s_checkout_page_01'] = tCheckoutPageObj;
+
+
+var tAuthStateChangeProactiveGreetingObj = {
+    name: 'New visitor login',
+    description: 'Create a temporary chat when a new visitor signin.',
+    trigger: {key:'event.emit',name:'Event emit event', description: 'Standard event emit event'},
+    conditions:{ all: [
+                        {key:'event.name',fact: 'json',path: 'name', operator:'equal', value: 'auth_state_changed'},
+                        {key: 'event.attributes.code', fact: 'json', path: 'attributes.event', operator:'equal', value : 201}
+                    ]},
+
+    actions: [{key:'request.create', parameters: {departmentid: 'default', text:"callout:tdk_req_status_hidden"}}], 
+    enabled: true,
+    code: 's_new_login_01',
+    type: 'internal',
+    version: 1,
+    createdBy: 'system',
+    updatedBy: 'system'
+    };
+    
+    var tAuthStateChangeProactiveGreeting = new Trigger(tAuthStateChangeProactiveGreetingObj);          
+    
+    defTrigger['s_new_login_01'] = tAuthStateChangeProactiveGreeting;
+    defTriggerObj['s_new_login_01'] = tAuthStateChangeProactiveGreetingObj;
+
+
+
+var tInviteProactiveGreetingBotObj = {
+    name: 'Invite Proactive Greeting Bot',
+    description: 'Invite if available the department bot to proactively greet the temporary chat and start it.',
+    trigger: {key:'request.create',name:'Request create event', description: 'Standard request create event'},
+    conditions:{ all: [
+                    {key:'request.statusRequestStatus',fact: 'json',path: 'status', operator:'equal', value: 50},
+                    {key:'request.departmentHasBot',fact: 'json',path: 'department.hasBot', operator:'equal', value: true},
+                    {key:'request.first_text',fact: 'json',path: 'first_text', operator:'equal', value: 'callout'}
+                ]},
+    actions: [{key:'request.department.bot.launch'}], 
+    enabled:true,
+    code: 's_invite_proactive_greeting_bot_01',
+    type: 'internal',
+    version: 2,
+    createdBy: 'system',
+    updatedBy: 'system'
+}
+
+var tInviteProactiveGreetingBot = new Trigger(tInviteProactiveGreetingBotObj);          
+
+defTrigger['s_invite_proactive_greeting_bot_01'] = tInviteProactiveGreetingBot;
+defTriggerObj['s_invite_proactive_greeting_bot_01'] = tInviteProactiveGreetingBotObj;
+
+
+
+
+
+var tProactiveGreetingMessageObj = 
+{
+    name: 'Proactive Greeting',
+    description: 'Send a proactive message when a new user signin.',
+    trigger: {key:'request.create',name:'Request create event', description: 'Standard request create event'},
+    conditions:{ all: [
+                    {key:'request.departmentHasBot',fact: 'json',path: 'department.hasBot', operator:'equal', value: false},                  
+                    {key:'request.first_text',fact: 'json',path: 'first_text', operator:'equal', value: 'callout'},
+                    {key:'request.statusRequestStatus',fact: 'json',path: 'status', operator:'equal', value: 50}
+                ]},
+    actions: [{key:'message.send', parameters: {text:"${WELLCOME_MSG}"}}],  
+    enabled:true,
+    code: 's_proactivegreeting_message_01',
+    type: 'internal',
+    version: 1,
+    createdBy: 'system',
+    updatedBy: 'system'
+}
+
+var tProactiveGreetingMessage = new Trigger(tProactiveGreetingMessageObj);          
+
+defTrigger['s_proactivegreeting_message_01'] = tProactiveGreetingMessage;
+defTriggerObj['s_proactivegreeting_message_01'] = tProactiveGreetingMessageObj
+
+
+
+
+
+
+
+var tTicketingTakingObj = 
+{
+    name: 'Ticketing Taking',
+    description: 'Send a taking message when a new ticket is created.',
+    trigger: {key:'request.create',name:'Request create event', description: 'Standard request create event'},
+    conditions:{ all: [
+                    {key:'request.channel.name',fact: 'json',path: 'channel.name', operator:'equal', value: 'email'},
+                    {key:'request.departmentHasBot',fact: 'json',path: 'department.hasBot', operator:'equal', value: false}                    
+                ]},
+    actions: [{key:'message.send', parameters: {text:"${TICKET_TAKING}"}}],  
+    enabled:true,
+    code: 's_ticketing_taking_01',
+    type: 'internal',
+    version: 1,
+    createdBy: 'system',
+    updatedBy: 'system'
+}
+
+var tTicketingTaking = new Trigger(tTicketingTakingObj);          
+
+defTrigger['s_ticketing_taking_01'] = tTicketingTaking;
+defTriggerObj['s_ticketing_taking_01'] = tTicketingTakingObj
+
+
+module.exports = {defTrigger:defTrigger, defTriggerObj: defTriggerObj};

package/pubmodules/trigger/event/actionEventEmitter.js

@@ -0,0 +1,10 @@
+const EventEmitter = require('events');
+
+class ActionEventEmitter extends EventEmitter {}
+
+
+const actionEventEmitter = new ActionEventEmitter();
+
+
+
+module.exports = actionEventEmitter;

package/pubmodules/trigger/event/flowEventEmitter.js

@@ -0,0 +1,10 @@
+const EventEmitter = require('events');
+
+class FlowEventEmitter extends EventEmitter {}
+
+
+const flowEventEmitter = new FlowEventEmitter();
+
+
+
+module.exports = flowEventEmitter;

package/pubmodules/trigger/event/triggerEventEmitter.js

@@ -0,0 +1,10 @@
+const EventEmitter = require('events');
+
+class TriggerEventEmitter extends EventEmitter {}
+
+
+const triggerEventEmitter = new TriggerEventEmitter();
+
+
+
+module.exports = triggerEventEmitter;

package/pubmodules/trigger/index.js

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