@tiledesk/tiledesk-server 2.3.6 → 2.3.7-1.2

package/routes/request.js

@@ -16,6 +16,10 @@ var MessageConstants = require("../models/messageConstants");
 var Message = require("../models/message");
 var cacheUtil = require('../utils/cacheUtil');
 var RequestConstants = require("../models/requestConstants");
+var cacheEnabler = require("../services/cacheEnabler");
+var Project_user = require("../models/project_user");
+var Lead = require("../models/lead");
+var UIDGenerator = require("../utils/UIDGenerator");
 
 
 csv = require('csv-express');
@@ -32,9 +36,9 @@ const { check, validationResult } = require('express-validator');
 // TODO make a synchronous chat21 version (with query parameter?) with request.support_group.create
 router.post('/', 
 [
-  check('text').notEmpty(),  
+  check('first_text').notEmpty(),  
 ],
-function (req, res) {
+async (req, res)  => {
 
   var startTimestamp = new Date();
   winston.debug("request create timestamp: " + startTimestamp);
@@ -54,41 +58,113 @@ function (req, res) {
       winston.debug("req.projectuser", req.projectuser);                                     
     }
     
-        
+    var project_user = req.projectuser;
+
+    var sender = req.body.sender;
+    var fullname = req.body.senderFullname || req.user.fullName;
+    var email = req.body.email || req.user.email;
+     
     let messageStatus = req.body.status || MessageConstants.CHAT_MESSAGE_STATUS.SENDING;
     winston.debug('messageStatus: ' + messageStatus);
 
-    var request_id = req.params.request_id || 'support-group-' + req.projectid + "-" + uuidv4();
+    var request_id = req.body.request_id || 'support-group-' + req.projectid + "-" + UIDGenerator.generate();
+    winston.debug('request_id: ' + request_id);
 
-    // createIfNotExistsWithLeadId(lead_id, fullname, email, id_project, createdBy, attributes) {
-    return leadService.createIfNotExistsWithLeadId(req.body.sender || req.user._id, req.body.senderFullname || req.user.fullName , req.body.email || req.user.email, req.projectid, null, req.body.attributes || req.user.attributes)
-    .then(function(createdLead) {
+    if (sender) {
 
-      // TODO USE NEW .create()
-        // createWithIdAndRequester(request_id, project_user_id, lead_id, id_project, first_text, departmentid, sourcePage, language, userAgent, status, createdBy, attributes) {
-      return requestService.createWithIdAndRequester(request_id, req.projectuser._id, createdLead._id, req.projectid, 
-        req.body.text, req.body.departmentid, req.body.sourcePage, 
-        req.body.language, req.body.userAgent, null, req.user._id, req.body.attributes, req.body.subject).then(function (savedRequest) {
+      var isObjectId = mongoose.Types.ObjectId.isValid(sender);
+      winston.debug("isObjectId:"+ isObjectId);
+  
+       var queryProjectUser = {id_project:req.projectid, status: "active" };
+  
+      if (isObjectId) {
+        queryProjectUser.id_user = sender;
+      } else {
+        queryProjectUser.uuid_user = sender;
+      }
+  
+      winston.debug("queryProjectUser", queryProjectUser);
+      
+      project_user = await Project_user.findOne(queryProjectUser).populate({path:'id_user', select:{'firstname':1, 'lastname':1, 'email':1}})
+      winston.debug("project_user", project_user);
+  
+      if (!project_user) {
+        return res.status(403).send({success: false, msg: 'Unauthorized. Project_user not found with user id  : '+ sender });
+      }
 
+      if ( project_user.id_user) {
+        fullname = project_user.id_user.fullName;
+        winston.debug("pu fullname: "+ fullname);
+        email = project_user.id_user.email;
+        winston.debug("pu email: "+ email);
+      } else if (project_user.uuid_user) {
+        var lead = await Lead.findOne({lead_id: project_user.uuid_user, id_project: req.projectid});
+        winston.debug("lead: ",lead);
+        if (lead) {
+          fullname = lead.fullname;
+          winston.debug("lead fullname: "+ fullname);
+          email = lead.email;
+          winston.debug("lead email: "+ email);
+        }else {
+          winston.warn("lead not found: " + JSON.stringify({lead_id: project_user.uuid_user, id_project: req.projectid}));
+        }
+        
+      } else {
+        winston.warn("pu fullname and email empty");
+      }
+      
+    }
 
-      // createWithId(request_id, requester_id, id_project, first_text, departmentid, sourcePage, language, userAgent, status, createdBy, attributes) {
-        // return requestService.createWithId(req.params.request_id, req.body.sender, req.projectid, 
-        //     req.body.text, req.body.departmentid, req.body.sourcePage, 
-        //     req.body.language, req.body.userAgent, null, req.user._id, req.body.attributes).then(function (savedRequest) {
 
+    // createIfNotExistsWithLeadId(lead_id, fullname, email, id_project, createdBy, attributes) {
+    return leadService.createIfNotExistsWithLeadId(sender || req.user._id, fullname, email, req.projectid, null, req.body.attributes || req.user.attributes)
+      .then(function(createdLead) {  
+
+
+
+        var new_request = {                                     
+          request_id: request_id, 
+          project_user_id: req.projectuser._id,
+          lead_id: createdLead._id, 
+          id_project:req.projectid,
+          first_text: req.body.first_text, 
+          departmentid: req.body.departmentid, 
+          sourcePage:req.body.sourcePage, 
+          language: req.body.language, 
+          userAgent:req.body.userAgent, 
+          status:null, 
+          createdBy: req.user._id,
+          attributes: req.body.attributes, 
+          subject: req.body.subject, 
+          preflight:undefined, 
+          channel: req.body.channel, 
+          location: req.body.location,
+          participants: req.body.participants,
+          lead: createdLead, requester: project_user,
+          priority: req.body.priority,
+          followers: req.body.followers,
+        };
+
+        return requestService.create(new_request).then(function (savedRequest) {
+        // createWithIdAndRequester(request_id, project_user_id, lead_id, id_project, first_text, departmentid, sourcePage, language, userAgent, status, createdBy, attributes) {
+      // return requestService.createWithIdAndRequester(request_id, req.projectuser._id, createdLead._id, req.projectid, 
+      //   req.body.text, req.body.departmentid, req.body.sourcePage, 
+      //   req.body.language, req.body.userAgent, null, req.user._id, req.body.attributes, req.body.subject).then(function (savedRequest) {
 
+
+          // return messageService.create(sender || req.user._id, fullname, request_id, req.body.text,
+          // req.projectid, req.user._id, messageStatus, req.body.attributes, req.body.type, req.body.metadata, req.body.language, undefined, req.body.channel).then(function(savedMessage){                    
+            
           // create(sender, senderFullname, recipient, text, id_project, createdBy, status, attributes, type, metadata) {
-          return messageService.create(req.body.sender || req.user._id, req.body.senderFullname || req.user.fullName, request_id, req.body.text,
-            req.projectid, req.user._id, messageStatus, req.body.attributes, req.body.type, req.body.metadata).then(function(savedMessage){                    
+          // return messageService.create(req.body.sender || req.user._id, req.body.senderFullname || req.user.fullName, request_id, req.body.text,
+          //   req.projectid, req.user._id, messageStatus, req.body.attributes, req.body.type, req.body.metadata).then(function(savedMessage){                    
               
-              // return requestService.incrementMessagesCountByRequestId(savedRequest.request_id, savedRequest.id_project).then(function(savedRequestWithIncrement) {
-
             
                 winston.debug('res.json(savedRequest)'); 
                 var endTimestamp = new Date();
                 winston.verbose("request create end: " + (endTimestamp - startTimestamp));
                 return res.json(savedRequest);
-              });
+              // });
             // });
           });                           
             
@@ -162,6 +238,20 @@ router.patch('/:requestid', function (req, res) {
     update.priority = req.body.priority;
   }
 
+  if (req.body.smartAssignment!=undefined) {
+    update.smartAssignment = req.body.smartAssignment;
+  }
+  
+  if (req.body.workingStatus!=undefined) {
+    update.workingStatus = req.body.workingStatus;
+  }
+  
+
+  if (req.body.channelName) {
+    update["channel.name"] = req.body.channelName;
+  }
+
+
   
   winston.verbose("Request patch update",update);
 
@@ -198,7 +288,7 @@ router.put('/:requestid/close', function (req, res) {
   
   // closeRequestByRequestId(request_id, id_project, skipStatsUpdate, notify, closed_by)
   const closed_by = req.user.id;
-  return requestService.closeRequestByRequestId(req.params.requestid, req.projectid, false, true, closed_by).then(function(closedRequest) {
+  return requestService.closeRequestByRequestId(req.params.requestid, req.projectid, false, true, closed_by, req.body.force).then(function(closedRequest) {
 
       winston.verbose("request closed", closedRequest);
 
@@ -710,6 +800,10 @@ router.get('/', function (req, res, next) {
     winston.debug('REQUEST ROUTE - QUERY DEPT ID', query.department);
   }
 
+  if (req.query.requester_email) {
+    query["snapshot.lead.email"] = req.query.requester_email;
+  }
+
   if (req.query.full_text) {
     winston.debug('req.query.fulltext', req.query.full_text);
     query.$text = { "$search": req.query.full_text };
@@ -778,8 +872,8 @@ router.get('/', function (req, res, next) {
    *  THE SEARCH FOR DATE INTERVAL OF THE HISTORY OF REQUESTS ARE DISABLED AND 
    *  ARE DISPLAYED ONLY THE REQUESTS OF THE LAST 14 DAYS
    */
-                                                                        //secondo me qui manca un parentesi tonda per gli or
-  if ( history_search === true && req.project && req.project.profile && (req.project.profile.type === 'free' && req.project.trialExpired === true) || (req.project.profile.type === 'payment' && req.project.isActiveSubscription === false)) {
+                                                                        //fixato. secondo me qui manca un parentesi tonda per gli or
+  if ( history_search === true && req.project && req.project.profile && ((req.project.profile.type === 'free' && req.project.trialExpired === true) || (req.project.profile.type === 'payment' && req.project.isActiveSubscription === false))) {
 
 
     var startdate = moment().subtract(14, "days").format("YYYY-MM-DD");
@@ -882,6 +976,11 @@ router.get('/', function (req, res, next) {
     winston.debug('REQUEST ROUTE - QUERY snap_lead_email', query.snap_lead_email);
   }
 
+  if (req.query.smartAssignment) {
+    query.smartAssignment = req.query.smartAssignment;
+    winston.debug('REQUEST ROUTE - QUERY smartAssignment', query.smartAssignment);
+  }
+
   if (req.query.channel) {
     if (req.query.channel === "offline") {
       query["channel.name"] =  {"$in" : ["email", "form"]}
@@ -992,7 +1091,7 @@ router.get('/', function (req, res, next) {
     winston.debug('REQUEST ROUTE - objectToReturn ', objectToReturn);
 
     const endExecTime = new Date();
-    winston.info('REQUEST ROUTE - exec time:  ' + (endExecTime-startExecTime));
+    winston.verbose('REQUEST ROUTE - exec time:  ' + (endExecTime-startExecTime));
 
     return res.json(objectToReturn);
 
@@ -1234,17 +1333,22 @@ router.get('/:requestid', function (req, res) {
   var requestid = req.params.requestid;
   winston.debug("get request by id: "+requestid);
 
-  // cacherequest       // requestcachefarequi populaterequired
-  Request.findOne({request_id: requestid, id_project: req.projectid})
+  
+  let q = Request.findOne({request_id: requestid, id_project: req.projectid})
   // .select("+snapshot.agents")
   .populate('lead')
   .populate('department')
   .populate('participatingBots')
   .populate('participatingAgents')  
-  .populate({path:'requester',populate:{path:'id_user'}})
-  // .cache(cacheUtil.defaultTTL, "/"+req.projectid+"/requests/request_id/"+requestid)
+  .populate({path:'requester',populate:{path:'id_user'}});
+
+  // if (cacheEnabler.request) {  cache disabled beacuse cacheoose don't support .populate without lean. here cache is not important
+  //   q.cache(cacheUtil.defaultTTL, req.projectid+":requests:request_id:"+requestid) //request_cache
+  //   winston.debug('request cache enabled');
+  // }
+  // 
   //  .populate({path:'requester',populate:{path:'id_user', select:{'firstname':1, 'lastname':1}}})
-  .exec(function(err, request) {  
+  q.exec(function(err, request) {  
     if (err) {
       winston.error("error getting request by id ", err);
       return res.status(500).send({ success: false, msg: 'Error getting object.' });

package/routes/troubleshooting.js

@@ -0,0 +1,12 @@
+var express = require('express');
+var router = express.Router();
+var winston = require('../config/winston');
+
+router.get('/headers', function(req, res) {
+  winston.info("req.headers", req.headers);
+  // TODO chech if query is null
+  res.json(req.headers);
+
+});
+
+module.exports = router;

package/routes/users-util.js

@@ -0,0 +1,39 @@
+var express = require('express');
+var router = express.Router();
+
+var User = require("../models/user");
+var winston = require('../config/winston');
+var mongoose = require('mongoose');
+
+
+
+
+
+// sponz: realizza mini servizio senza sec
+router.get('/:userid', function (req, res) {
+  winston.debug("users");
+  var userid = req.params.userid;
+
+  var isObjectId = mongoose.Types.ObjectId.isValid(userid);
+  winston.debug("isObjectId:"+ isObjectId);
+
+  if (!isObjectId) {
+    return res.status(404).send({ success: false, msg: 'User id not found' });
+  }
+
+  User.findById(userid, 'firstname lastname _id', function (err, user) {
+    if (err) {
+      winston.error('Error getting object.',err);
+      return res.status(500).send({ success: false, msg: 'Error getting object.' });
+    }
+    if (!user) {
+      winston.warn("Object not found with id " +userid);
+      return res.status(404).send({ success: false, msg: 'Object not found.' });
+    }
+    winston.debug("GET USER BY ID RES JSON", user);
+    res.json(user);
+  });
+});
+
+
+module.exports = router;

package/routes/users.js

@@ -25,7 +25,7 @@ router.put('/', function (req, res) {
 
   User.findByIdAndUpdate(req.user.id, update, { new: true, upsert: true }, function (err, updatedUser) {
     if (err) {
-      winston.error(err);
+      winston.error("Error putting user",err);
       return res.status(500).send({ success: false, msg: err });
     }
 

package/routes/widget.js

@@ -146,8 +146,12 @@ router.get('/', function(req, res, next) {
                                               //secondo me qui manca un parentesi tonda per gli or
           if (project  && project.profile && ((project.profile.type === 'free' && project.trialExpired === true) || (project.profile.type === 'payment' && project.isActiveSubscription === false))) {
             winston.debug('getProject remove poweredBy tag', project);
-            project.widget.poweredBy = undefined;
-            project.widget.baloonImage = undefined;            
+
+            if (project.widget) {
+              project.widget.poweredBy = undefined;
+              project.widget.baloonImage = undefined;            
+            }
+            
           }
 
         return resolve(project);
@@ -190,7 +194,65 @@ router.get('/', function(req, res, next) {
   
 
 
+  router.get('/ip', function(req, res, next) {
   
+     var xforwarded = req.headers['x-forwarded-for'];
+     winston.info('xforwarded'+ xforwarded);
+
+     var connectionRemoteAddress  = req.connection.remoteAddress;
+     winston.info('connectionRemoteAddress'+ connectionRemoteAddress);
+
+     var socketRemoteAddress = req.socket.remoteAddress;
+     winston.info('socketRemoteAddress'+ socketRemoteAddress);
+
+    if (req.connection.socket ) {
+      var connectionSocketRemoteAddress = req.connection.socket.remoteAddress;
+      winston.info('connectionSocketRemoteAddress'+ connectionSocketRemoteAddress);
+
+    }
+    
+
+    var ip = req.headers['x-forwarded-for'] || 
+     req.connection.remoteAddress || 
+     req.socket.remoteAddress ||
+     (req.connection.socket ? req.connection.socket.remoteAddress : null);
+    winston.info("ip:"+ ip);
+
+
+
+
+    const ipStandard = (req.headers['x-forwarded-for'] || '').split(',').shift().trim() ||        //https://stackoverflow.com/questions/8107856/how-to-determine-a-users-ip-address-in-node
+    req.socket.remoteAddress
+
+    winston.info("standard ip: "+ipStandard); // ip address of the user
+
+
+
+    // const parseIp = (req) =>
+    // req.headers['x-forwarded-for']?.split(',').shift()
+    // || req.socket?.remoteAddress
+
+    
+
+    let parseIp = req.socket.remoteAddress;
+
+    const xFor =  req.headers['x-forwarded-for'];
+    winston.info("parseIp xFor: "+xFor);
+
+    if (xFor ) {
+      const xForArr = xFor.split(',');
+      if (xForArr && xForArr.length>0) {
+        parseIp = xForArr.shift();
+        winston.info("parseIp xFor parseIp: "+parseIp);
+      }
+    }
+    winston.info("parseIp: "+parseIp); // ip address of the user
+
+
+    res.json( {ip:ip, ipStandard:ipStandard, parseIp: parseIp} );
+
+
+  });
 
   
 

package/services/BotSubscriptionNotifier.js

@@ -20,6 +20,10 @@ class BotSubscriptionNotifier {
 
       var url = bot.url;
 
+      // if (url.startsWith("$ext_url")) {
+      //   // url = url.replace ("$res_bot_url", prendi da env)
+      // }
+
       var json = {timestamp: Date.now(), payload: payload};
     
 
@@ -53,6 +57,7 @@ class BotSubscriptionNotifier {
 
           }, function(err, result, json){            
             winston.verbose("SENT notify for bot with url " + url +  " with err " + err);
+            winston.debug("SENT notify for bot with url ", result);
             if (err) {
               winston.error("Error sending notify for bot with url " + url + " with err " + err);
               //TODO Reply with error

package/services/banUserNotifier.js

@@ -0,0 +1,86 @@
+var messageService = require("./messageService");
+var projectEvent = require("../event/projectEvent");
+
+var winston = require('../config/winston');
+
+var MessageConstants = require("../models/messageConstants");
+
+class BanUserNotifier {
+
+    listen() {
+        projectEvent.on("project.update.user.ban", function(data) {
+            var project=data.project;
+            var banInfo = data.banInfo;
+
+            winston.debug("User Banned");
+
+            var message = {
+                sender: 'system',
+                senderFullname: 'Bot',
+                recipient: banInfo.id,
+                recipientFullname: banInfo.id,
+                text: "User Banned",
+                id_project: project._id,
+                createdBy: "system",
+                attributes: {subtype:"info", messagelabel: {key: "USER_BANNED"} },
+                channel_type: MessageConstants.CHANNEL_TYPE.DIRECT,
+                status: MessageConstants.CHAT_MESSAGE_STATUS.SENDING,
+                // channel: {name: "chat21"}
+            };
+            messageService.save(message);
+            winston.info("User banned", message);
+            // messageService.send(
+            //     'system', 
+            //     'Bot',                                     
+            //     banInfo.id,
+            //     "User Banned", 
+            //     project._id,
+            //     'system', 
+            //     {subtype:"info"},
+            //     undefined,
+            //     undefined
+            // );
+        });
+        projectEvent.on("project.update.user.unban", function(data) {
+            var project=data.project;
+            var banInfo = data.banInfo;
+
+            winston.debug("User UnBanned: "+banInfo);
+
+            // var message = {
+            //     sender: 'system',
+            //     senderFullname: 'Bot',
+            //     recipient: banInfo,
+            //     recipientFullname: banInfo,
+            //     text: "User Unbanned",
+            //     id_project: project._id,
+            //     createdBy: "system",
+            //     attributes: {subtype:"info", messagelabel: {key: "USER_BANNED"}},
+            //     channel_type: MessageConstants.CHANNEL_TYPE.DIRECT,
+            //     status: MessageConstants.CHAT_MESSAGE_STATUS.SENDING,
+            // };
+            // messageService.save(message);
+            // winston.info("User UnBanned", message);
+
+
+            
+
+            // messageService.send(
+            //     'system', 
+            //     'Bot',                                     
+            //     banInfo.id,
+            //     "User Unbanned", 
+            //     project._id,
+            //     'system', 
+            //     {subtype:"info"},
+            //     undefined,
+            //     undefined
+            // );
+        });
+    }
+
+}
+var banUserNotifier = new BanUserNotifier();
+
+
+module.exports = banUserNotifier;

package/services/cacheEnabler.js

@@ -0,0 +1,56 @@
+
+class CacheEnabler {
+    constructor() {
+
+        // long TTL
+        this.trigger = true;
+        if (process.env.CACHE_TRIGGER_ENABLED=="false" || process.env.CACHE_TRIGGER_ENABLED==false) {
+            this.trigger = false;
+        }
+
+        // long TTL
+        this.subscription = true;
+        if (process.env.CACHE_SUBSCRIPTION_ENABLED=="false" || process.env.CACHE_SUBSCRIPTION_ENABLED==false) {
+            this.subscription = false;
+        }
+
+        //default TTL
+        this.project = true;
+        if (process.env.CACHE_PROJECT_ENABLED=="false" || process.env.CACHE_PROJECT_ENABLED==false) {
+            this.project = false;
+        }
+
+        //default TTL
+        this.request = true;
+        if (process.env.CACHE_REQUEST_ENABLED=="false" || process.env.CACHE_REQUEST_ENABLED==false) {
+            this.request = false;
+        }
+
+        this.faq_kb = true;
+        if (process.env.CACHE_FAQ_KB_ENABLED=="false" || process.env.CACHE_FAQ_KB_ENABLED==false) {
+            this.faq_kb = false;
+        }
+
+        
+        this.project_user = true;
+        if (process.env.CACHE_PROJECT_USER_ENABLED=="false" || process.env.CACHE_PROJECT_USER_ENABLED==false) {
+            this.project_user = false;
+        }
+
+        // this.user = true;
+        // if (process.env.CACHE_USER_ENABLED=="false" || process.env.CACHE_USER_ENABLED==false) {
+        //     this.user = false;
+        // }
+
+        // this.message = true;
+        // if (process.env.CACHE_MESSAGE_ENABLED=="false" || process.env.CACHE_MESSAGE_ENABLED==false) {
+        //     this.message = false;
+        // }
+    }
+}
+
+
+var cacheEnabler = new CacheEnabler();
+
+
+module.exports = cacheEnabler;

package/services/chatbotService.js

@@ -0,0 +1,101 @@
+const axios = require("axios").default;
+const winston = require('../config/winston');
+var Faq_kb = require("../models/faq_kb");
+
+class ChatbotService {
+
+  constructor() {
+    
+  }
+
+
+  async getBotById(id_faq_kb, published, api_url, chatbot_templates_api_url, token, project_id) {
+
+    winston.info("[CHATBOT SERVICE] getBotById");
+
+    // private bot
+    if (published == "false") {
+
+      return await axios({
+        url: api_url + "/" + project_id + "/faq_kb/exportjson/" + id_faq_kb,
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': token
+        },
+        method: 'GET'
+      }).then((resbody) => {
+        winston.info("(CHATBOT SERVICE) forking private chatbot " + resbody.data.name)
+        let chatbot = resbody.data;
+        return chatbot;
+      }).catch((err) => {
+        winston.error('(CHATBOT SERVICE) FAQ_KB EXPORTJSON ERROR ' + err);
+        return err;
+      })
+
+    // public bot
+    } else {
+
+      return await axios({
+        url: chatbot_templates_api_url + "/" + id_faq_kb,
+        headers: {
+          'Content-Type': 'application/json'
+        },
+        method: 'GET'
+      }).then((resbody) => {
+        winston.info("(CHATBOT SERVICE) forking public chatbot " + resbody.data.name);
+        let chatbot = resbody.data;
+        return chatbot
+      }).catch((err) => {
+        winston.error('(CHATBOT SERVICE) FAQ_KB CHATBOT TEMPLATES ERROR ' + err);
+        return err;
+      })
+    }
+
+  }
+
+  async createBot(api_url, token, chatbot, project_id) {
+
+    winston.info("[CHATBOT SERVICE] createBot");
+
+    return await axios({
+      url: api_url + '/' + project_id + '/faq_kb/',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': token
+      },
+      data: chatbot,
+      method: 'POST'
+    }).then((resbody) => {
+      winston.debug("(CHATBOT SERVICE) createBot resbody: ", resbody.data);
+      return resbody.data;
+    }).catch((err) => {
+      winston.error("(CHATBOT SERVICE) CREATE NEW CHATBOT ERROR " + err);
+      return err;
+    })
+
+  }
+
+  async importFaqs(api_url, id_faq_kb, token, chatbot, project_id) {
+  
+    winston.info("[CHATBOT SERVICE] importFaqs");
+
+    return await axios({
+      url: api_url + '/' + project_id + '/faq_kb/importjson/' + id_faq_kb + "?intentsOnly=true",
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': token
+      },
+      data: chatbot,
+      method: 'POST'
+    }).then((resbody) => {
+      winston.debug("(CHATBOT SERVICE) importFaqs resbody: ", resbody.data);
+      return resbody.data;
+    }).catch((err) => {
+      winston.error("(CHATBOT SERVICE) IMPORT FAQS ERROR " + err);
+      return err;
+    })
+  }
+
+}
+
+module.exports = { ChatbotService }