@tiledesk/tiledesk-server 2.3.11 → 2.3.14

package/CHANGELOG.md

@@ -1,5 +1,12 @@
-
-# 2.3.11 -> PROD
+# 2.3.14 -> PROD
+- Added ip filter with Deny roles and ban User roles
+- Ban notifier
+- Middleware decodeJwt before passport with passport fallback
+- Removed unused requestService.incrementMessagesCountByRequestId from chat21Webhook
+- Enable agent to manage groups endpoint
+- Added tilebot chat server
+
+# 2.3.13 
 - Getting ip fix
 
 # 2.3.10

package/app.js

@@ -146,10 +146,10 @@ pubModulesManager.init({express:express, mongoose:mongoose, passport:passport, d
 var channelManager = require('./channels/channelManager');
 channelManager.listen(); 
 
-const ipfilter = require('express-ipfilter').IpFilter
-// const IpDeniedError = require('express-ipfilter').IpDeniedError;
-
+var IPFilter = require('./middleware/ipFilter');
 
+var BanUserNotifier = require('./services/banUserNotifier');
+BanUserNotifier.listen();
 
 var modulesManager = undefined;
 try {
@@ -175,6 +175,7 @@ if (process.env.CREATE_INITIAL_DATA !== "false") {
 
 
 
+
 var app = express();
 
 
@@ -335,61 +336,6 @@ var projectSetter = function (req, res, next) {
 }
 
 
-function customDetection (req)  {
-  // const ip = req.headers['x-forwarded-for'] || req.connection.remoteAddress;  
-  // const ip = (req.headers['x-forwarded-for'] || '').split(',').pop().trim() ||        //https://stackoverflow.com/questions/8107856/how-to-determine-a-users-ip-address-in-node
-  //   req.socket.remoteAddress
-
-    const ip = (req) =>
-    req.headers['x-forwarded-for']?.split(',').shift()
-    || req.socket?.remoteAddress
-
-  winston.info("standard ip: "+ip); // ip address of the user
-  return ip;
-}
-
-
-var projectIpFilter = function (req, res, next) {
-  // var projectIpFilter = function (err, req, res, next) {
-
-    // var ip = require('ip');
-    // winston.info("projectIpFilter ip2: " + ip.address() );
-
-
-    const nextIp = function(err) {
-      winston.info("projectIpFilter next",err);
-
-        if (err && err.name === "IpDeniedError") {
-          winston.info("IpDeniedError");
-          return res.status(401).json({ err: "error project ip filter" });
-          // next(err) 
-        } 
-
-      next();
-
-  }
-
-
-  if (!req.project) {
-    return next();
-  }
-  
-  var projectIpFilterEnabled = req.project.ipFilterEnabled;
-  winston.debug("project projectIpFilterEnabled: " +projectIpFilterEnabled)
-
-  var projectIpFilter =  req.project.ipFilter
-  winston.debug("project ipFilter: " + projectIpFilter)
-  
-  if (projectIpFilterEnabled === true && projectIpFilter && projectIpFilter.length > 0) {
-    var ip = ipfilter(projectIpFilter, { detectIp: customDetection, mode: 'allow' })
-    // var ip = ipfilter(projectIpFilter, { mode: 'allow' })
-    ip(req, res, nextIp);
-  } else {
-    next();
-  }
-
-}
-
 
 
 // app.use('/admin', admin);
@@ -435,8 +381,7 @@ if (modulesManager) {
   modulesManager.use(app);
 }
 
-
-app.use('/:projectid/', [projectIdSetter, projectSetter, projectIpFilter]);
+app.use('/:projectid/', [projectIdSetter, projectSetter, IPFilter.projectIpFilter, IPFilter.projectIpFilterDeny, IPFilter.decodeJwt, IPFilter.projectBanUserFilter]);
 
 
 app.use('/:projectid/authtestWithRoleCheck', [passport.authenticate(['basic', 'jwt'], { session: false }), validtoken], authtestWithRoleCheck);
@@ -455,7 +400,7 @@ app.use('/:projectid/departments', department);
 
 channelManager.useUnderProjects(app);
 
-app.use('/:projectid/groups', [passport.authenticate(['basic', 'jwt'], { session: false }), validtoken, roleChecker.hasRole('admin')], group);
+app.use('/:projectid/groups', [passport.authenticate(['basic', 'jwt'], { session: false }), validtoken, roleChecker.hasRole('agent')], group);
 app.use('/:projectid/tags', [passport.authenticate(['basic', 'jwt'], { session: false }), validtoken, roleChecker.hasRole('agent')], tag);
 app.use('/:projectid/subscriptions', [passport.authenticate(['basic', 'jwt'], { session: false }), validtoken, roleChecker.hasRole('admin')], resthook);
 
@@ -544,7 +489,7 @@ app.use(function (err, req, res, next) {
 // error handler
 app.use((err, req, res, next) => {
 
-  winston.info("err.name", err.name)
+  winston.debug("err.name", err.name)
   if (err.name === "IpDeniedError") {
     winston.info("IpDeniedError");
     return res.status(401).json({ err: "error ip filter" });

package/channels/chat21/chat21WebHook.js

@@ -202,7 +202,8 @@ router.post('/', function (req, res) {
                       }
 
 
-                     
+                    
+
                       
                       var new_request = {
                         request_id: message.recipient, project_user_id:project_user_id, lead_id:createdLead._id, id_project:projectid, first_text:message.text,
@@ -229,10 +230,10 @@ router.post('/', function (req, res) {
                        // upsert(id, sender, senderFullname, recipient, text, id_project, createdBy, status, attributes, type, metadata, language)
                         return messageService.upsert(messageId, message.sender, message.sender_fullname, message.recipient, message.text,
                           projectid, null, MessageConstants.CHAT_MESSAGE_STATUS.RECEIVED, message.attributes, message.type, message.metadata, language).then(function(savedMessage){
-                                                                
-                            return requestService.incrementMessagesCountByRequestId(savedRequest.request_id, savedRequest.id_project).then(function(savedRequestWithIncrement) {
-                              return res.json(savedRequestWithIncrement);
-                            });
+                            return res.json(savedRequest);                                  
+                            // return requestService.incrementMessagesCountByRequestId(savedRequest.request_id, savedRequest.id_project).then(function(savedRequestWithIncrement) {
+                              // return res.json(savedRequestWithIncrement);
+                            // });
                           
                         
                       }).catch(function (err) {
@@ -289,21 +290,22 @@ router.post('/', function (req, res) {
 
                 // TOOD update also request attributes and sourcePage
                 
-                    return requestService.incrementMessagesCountByRequestId(request.request_id, request.id_project).then(function(savedRequest) {
+                    // return requestService.incrementMessagesCountByRequestId(request.request_id, request.id_project).then(function(savedRequest) {
                       // winston.debug("savedRequest.participants.indexOf(message.sender)", savedRequest.participants.indexOf(message.sender));
                        
                       // TODO it doesn't work for internal requests bacause participanets == message.sender⁄
-                      if (savedRequest.participants && savedRequest.participants.indexOf(message.sender) > -1) { //update waiitng time if write an  agent (member of participants)
+                      if (request.participants && request.participants.indexOf(message.sender) > -1) { //update waiitng time if write an  agent (member of participants)
                         winston.debug("updateWaitingTimeByRequestId");
                         return requestService.updateWaitingTimeByRequestId(request.request_id, request.id_project).then(function(upRequest) {
                           return res.json(upRequest);
                         });
                       }else {
-                        return res.json(savedRequest);
+                        return res.json(upRequest);
                       }
-                    });
+                    // });
                   }).catch(function(err){
-                    winston.error("Error creating message", {err: err, message: message});
+                    // console.log(err);
+                    winston.error("Error creating chat21 webhook message", {err: err, message: message});
                     return res.status(500).send({success: false, msg: 'Error creating message', err:err });
                   });
 
@@ -539,7 +541,7 @@ router.post('/', function (req, res) {
   
   else if (req.body.event_type == "deleted-archivedconversation" || req.body.event_type == "conversation-unarchived") {
 
-    winston.info("event_type","deleted-archivedconversation");
+    winston.debug("event_type","deleted-archivedconversation");
 
     winston.debug("req.body",req.body);
 
@@ -549,37 +551,42 @@ router.post('/', function (req, res) {
     }
 
 
-      var conversation = req.body.data;
+      var conversation = req.body.data; 
       // winston.debug("conversation",conversation);
 
       var user_id = req.body.user_id;
-      winston.info("user_id",user_id);
+      winston.debug("user_id",user_id);
 
       var recipient_id = req.body.recipient_id;
-      winston.info("recipient_id",recipient_id);
+      winston.debug("recipient_id",recipient_id);
 
      
 //   TODO leggi projectid from support-group
 
       if (!recipient_id.startsWith("support-group")){
-        winston.info("not a support conversation");
+        winston.debug("not a support conversation");
         return res.status(400).send({success: false, msg: "not a support conversation" });
       }
 
       if (user_id!="system"){
-        winston.info("not a system conversation");
+        winston.debug("not a system conversation");
         return res.status(400).send({success: false, msg: "not a system conversation" });
       }
 
 
+
+     // scrivo... nuova viene popolato projectid in attributes poi chiudo ed in archived c'è projectid 
+      // quando scrivo viene cancellato archived e nuovo messaggio crea conv ma senza project id... lineare che è cosi
+      // si verifica solo se admin (da ionic ) archivia di nuovo senza che widget abbia scritto nulla (widget risetta projectid in properties)
+
       var id_project;
       if (conversation && conversation.attributes) {
         id_project = conversation.attributes.projectId;
       }else {
-        winston.info( "not a support deleting archived conversation" );
+        winston.debug( "not a support deleting archived conversation" );
         return res.status(400).send({success: false, msg: "not a support deleting archived conversation" });
       }
-      winston.info("id_project", id_project);
+      winston.debug("id_project", id_project);
 
 
       return requestService.reopenRequestByRequestId(recipient_id, id_project).then(function(updatedRequest) {

package/deploy.sh

@@ -1,3 +1,4 @@
+git pull
 npm version patch
 version=`node -e 'console.log(require("./package.json").version)'`
 echo "version $version"
@@ -8,3 +9,4 @@ if [ "$version" != "" ]; then
     git push --tags
     npm publish --access public
 fi
+git push

package/middleware/ipFilter.js

@@ -0,0 +1,220 @@
+const ipfilter = require('express-ipfilter').IpFilter
+var winston = require('../config/winston');
+var jwt = require('jsonwebtoken');
+
+
+var customDetection = function (req)  {
+    // const ip = req.headers['x-forwarded-for'] || req.connection.remoteAddress;  
+    // const ip = (req.headers['x-forwarded-for'] || '').split(',').pop().trim() ||        //https://stackoverflow.com/questions/8107856/how-to-determine-a-users-ip-address-in-node
+    //   req.socket.remoteAddress
+  
+  
+    let ip = req.socket.remoteAddress;
+  
+      const xFor =  req.headers['x-forwarded-for'];
+      if (xFor ) {
+        const xForArr = xFor.split(',');
+        if (xForArr && xForArr.length>0) {
+          ip = xForArr.shift();
+        }
+      }
+      // const ip = 
+      // req.headers['x-forwarded-for']?.split(',').shift()
+      // || req.socket?.remoteAddress
+  
+    winston.info("standard ip: "+ip); // ip address of the user
+    return ip;
+}
+
+var getToken = function (headers) {
+  winston.debug("getToken",headers);
+  if (headers && headers.authorization) {
+    var parted = headers.authorization.split(' ');
+    if (parted.length === 2) {
+      return parted[1];
+    } else {
+      return null;
+    }
+  } else {
+    return null;
+  }
+};
+  
+
+class IPFilter {
+    
+
+    
+    constructor() {
+    }
+
+
+
+
+
+
+  
+  
+  
+projectIpFilter (req, res, next) {
+    var that = this;
+    // console.log("that", that)
+  
+    const nextIp = function(err) {
+      winston.debug("projectIpFilter next",err);
+    
+        if (err && err.name === "IpDeniedError") {
+          winston.info("IpDeniedError for projectIpFilter");
+          return res.status(401).json({ err: "error project ip filter" });
+          // next(err) 
+        } 
+    
+      next();
+    
+    }
+  
+  
+    if (!req.project) {
+      return next();
+    }
+    
+    var projectIpFilterEnabled = req.project.ipFilterEnabled;
+    winston.debug("project projectIpFilterEnabled: " +projectIpFilterEnabled)
+  
+    var projectIpFilter =  req.project.ipFilter
+    winston.debug("project ipFilter: " + projectIpFilter)
+    
+    if (projectIpFilterEnabled === true && projectIpFilter && projectIpFilter.length > 0) {
+      winston.debug("filtering project IpFilter with ", projectIpFilter );
+      var ip = ipfilter(projectIpFilter, { detectIp: customDetection, mode: 'allow' })
+      // var ip = ipfilter(projectIpFilter, { mode: 'allow' })
+       ip(req, res, nextIp);
+    } else {
+      next();
+    }
+  
+  }
+  
+   projectIpFilterDeny (req, res, next) {
+  
+    const nextIp = function(err) {
+      winston.debug("projectIpFilter next",err);
+    
+        if (err && err.name === "IpDeniedError") {
+          winston.info("IpDeniedError for projectIpFilterDeny");
+          return res.status(401).json({ err: "error project deny ip filter" });
+          // next(err) 
+        } 
+    
+      next();
+    
+    }
+  
+    if (!req.project) {
+      return next();
+    }
+    
+    var projectIpFilterDenyEnabled = req.project.ipFilterDenyEnabled;
+    winston.debug("project projectIpFilterDenyEnabled: " +projectIpFilterDenyEnabled)
+  
+    var projectIpFilterDeny =  req.project.ipFilterDeny
+    winston.debug("project IpFilterDeny: " + projectIpFilterDeny)
+  
+  
+    if (projectIpFilterDenyEnabled === true && projectIpFilterDeny && projectIpFilterDeny.length > 0) {
+      winston.debug("filtering project projectIpFilterDeny with ", projectIpFilterDeny );
+      var ip = ipfilter(projectIpFilterDeny, { detectIp: customDetection, mode: 'deny' })
+      ip(req, res, nextIp);
+    } else {
+      next();
+    }
+  
+  }
+  
+  
+  
+projectBanUserFilter(req, res, next) {
+  
+  winston.debug("projectBanUserFilter hereee*********** ")
+
+    const nextIp = function(err) {
+      winston.debug("projectBanUserFilter next",err);
+    
+        if (err && err.name === "IpDeniedError") {
+          winston.info("IpDeniedError for projectBanUserFilter");
+          return res.status(401).json({ err: "error projectBanUserFilter" });
+          // next(err) 
+        } 
+    
+      next();
+    
+    }
+  
+    if (!req.project) {
+      return next();
+    }
+    
+    var bannedUsers =  req.project.bannedUsers
+    winston.debug("project bannedUsers: " + bannedUsers)
+  
+    if (bannedUsers && bannedUsers.length > 0) {
+  
+      let bannedUsersArr = [];
+      let bannedUsersIdUserArr = [];
+      for (var i =0; i < bannedUsers.length; i++) {
+        bannedUsersArr.push(bannedUsers[i].ip);
+        bannedUsersIdUserArr.push(bannedUsers[i].id);
+      }
+    
+      winston.debug("project req.preDecodedJwt: ", req.preDecodedJwt)
+      // winston.debug("project req.preDecodedJwt._id: "+ req.preDecodedJwt._id)
+
+
+      if (req.preDecodedJwt && req.preDecodedJwt._id && bannedUsersIdUserArr.indexOf(req.preDecodedJwt._id) > -1) {
+        winston.info("filtering project bannedUsers with id: " + req.preDecodedJwt._id)
+        return res.status(401).json({ err: "error projectBanUserFilter by id" });
+      }
+
+
+      // winston.debug("filtering project bannedUsers with ", bannedUsersArr );
+      // var ip = ipfilter(bannedUsersArr, { detectIp: customDetection, mode: 'deny' })
+      // ip(req, res, nextIp);
+      next();
+    } else {
+      next();
+    }
+  
+  }
+  
+  
+
+  
+
+  decodeJwt(req, res, next) {
+  
+    let token = getToken(req.headers);
+    winston.debug("filtering token " + token); 
+
+    if (token) {
+
+      try {
+        var decoded = jwt.decode(token);
+        winston.debug("filtering decoded ", decoded);
+        req.preDecodedJwt = decoded;
+      }catch(e) {
+        winston.debug("Error decoding jwt");
+      }
+     
+    }
+   
+    
+    next();
+  }
+  
+  
+
+
+  
+}
+var iPFilter = new IPFilter();
+module.exports = iPFilter;

package/middleware/passport.js

@@ -77,8 +77,14 @@ module.exports = function(passport) {
               // winston.info("secretOrKeyProvider: "+request.project.name );
               // winston.info("secretOrKeyProvider: "+rawJwtToken );
               
-              var decoded = jwt.decode(rawJwtToken);
+              var decoded = request.preDecodedJwt
               winston.debug("decoded: ", decoded );
+              if (!decoded) { //fallback
+                winston.debug("load decoded after: ");
+                decoded = jwt.decode(rawJwtToken);
+              }
+              
+              winston.debug("decoded after: ", decoded );
 
               // qui arriva questo 
               // decoded:  {"_id":"5ce3ee855c520200176c189e","updatedAt":"2019-05-31T09:50:22.949Z","createdAt":"2019-05-21T12:26:45.192Z","name":"botext","url":"https://tiledesk-v2-simple--andrealeo83.repl.co","id_project":"5ce3d1ceb25ad30017274bc5","trashed":false,"createdBy":"5ce3d1c7b25ad30017274bc2","__v":0,"external":true,"iat":1559297130,"aud":"https://tiledesk.com","iss":"https://tiledesk.com","sub":"5ce3ee855c520200176c189e@tiledesk.com/bot"}

package/models/project.js

@@ -111,6 +111,16 @@ var ProjectSchema = new Schema({
   ipFilter: [{
     type: String
   }],
+  ipFilterDenyEnabled:{
+    type: Boolean,
+    default: false
+  },
+  ipFilterDeny: [{
+    type: String
+  }],
+  bannedUsers: [{
+     id: String, ip: String
+  }],
   // defaultLanguage: {
   //   type: String,
   //   required: true,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tiledesk/tiledesk-server",
   "description": "The Tiledesk server module",
-  "version": "2.3.11",
+  "version": "2.3.14",
   "scripts": {
     "start": "node ./bin/www",
     "pretest": "mongodb-runner start",
@@ -44,6 +44,7 @@
     "@tiledesk/tiledesk-chatbot-util": "^0.8.33",
     "@tiledesk/tiledesk-json-rules-engine": "^4.0.3",
     "@tiledesk/tiledesk-rasa-connector": "^1.0.10",
+    "@tiledesk/tiledesk-tybot-connector": "^0.1.4",
     "app-root-path": "^3.0.0",
     "bcrypt-nodejs": "0.0.3",
     "body-parser": "^1.20.0",

package/pubmodules/emailNotification/requestNotification.js

@@ -355,6 +355,13 @@ async notifyFollowers(savedRequest, project, message) {
     return winston.debug("not sending notifyFollowers for attributes.subtype info messages");
   }
 
+  if (!savedRequest) {
+    return winston.debug("not sending notifyFollowers for direct messages");
+  }
+
+  // Cannot read property '_id' of undefined at RequestNotification.notifyFollowers (/usr/src/app/pubmodules/emailNotification/requestNotification.js:358:62) at /usr/src/app
+  // forse meglio .id
+  
   var reqWithFollowers = await Request.findById(savedRequest._id).populate('followers').exec();
   winston.debug("reqWithFollowers");
   winston.debug("reqWithFollowers",reqWithFollowers);

package/pubmodules/pubModulesManager.js

@@ -32,7 +32,7 @@ class PubModulesManager {
         this.triggerRoute = undefined;
 
         this.tilebot = undefined;
-
+        this.tilebotRoute = undefined;
     }
 
   
@@ -43,6 +43,10 @@ class PubModulesManager {
             app.use('/modules/rasa', this.rasaRoute);
             winston.info("ModulesManager rasaRoute controller loaded");       
         }
+        if (this.tilebotRoute) {
+            app.use('/modules/tilebot', this.tilebotRoute);
+            winston.info("ModulesManager tilebot controller loaded");       
+        }
 
     }
     useUnderProjects(app) {
@@ -266,6 +270,7 @@ class PubModulesManager {
             this.tilebot = require('./tilebot');
             winston.debug("this.tilebot:"+ this.tilebot);    
             this.tilebot.listener.listen(config);      
+            this.tilebotRoute = this.tilebot.tilebotRoute;
 
             winston.info("PubModulesManager initialized tilebot.");
         } catch(err) {

package/pubmodules/rasa/listener.js

@@ -23,7 +23,7 @@ class Listener {
     listen(config) {
 
         winston.info('Rasa Listener listen');
-        winston.debug("config databaseUri: " + config.databaseUri);  
+        winston.debug("rasa config databaseUri: " + config.databaseUri);  
         
 
         var that = this;
@@ -34,7 +34,7 @@ class Listener {
                 KVBASE_COLLECTION : process.env.KVBASE_COLLECTION,
                 MONGODB_URI: config.databaseUri,          
                 API_ENDPOINT: apiUrl,   
-                log: true
+                log: process.env.RASABOT_LOG
             }, () => {
                 winston.info("RASA proxy server successfully started.");   
             });
@@ -44,10 +44,10 @@ class Listener {
         botEvent.on('faqbot.create', function(bot) {
             if (BOT_RASA_ENDPOINT) {
 
-                winston.info('bot.type:'+bot.type); 
+                winston.debug('bot.type:'+bot.type); 
                 if (bot.type==="rasa") {
 
-                    winston.info('qui.type:'+bot.type); 
+                    winston.debug('qui.type:'+bot.type); 
 
 
                     Faq_kb.findByIdAndUpdate(bot.id, {"url":BOT_RASA_ENDPOINT}, { new: true, upsert: true }, function (err, savedFaq_kb) {

package/pubmodules/tilebot/index.js

@@ -1,3 +1,11 @@
 const listener = require("./listener");
 
-module.exports = { listener: listener };
+const tilebot = require("@tiledesk/tiledesk-tybot-connector");
+const tilebotRoute = tilebot.router;
+
+
+
+
+
+module.exports = { listener: listener, tilebotRoute: tilebotRoute };
+

package/pubmodules/tilebot/listener.js

@@ -1,25 +1,43 @@
 const botEvent = require('../../event/botEvent');
 var Faq_kb = require("../../models/faq_kb");
 var winston = require('../../config/winston');
+var configGlobal = require('../../config/global');
 
 var port = process.env.PORT || '3000';
 
-const TILEBOT_ENDPOINT = process.env.TILEBOT_ENDPOINT || "http://localhost:" + port+ "/modules/tilebot/";
+const TILEBOT_ENDPOINT = process.env.TILEBOT_ENDPOINT || "http://localhost:" + port+ "/modules/tilebot/ext/";
 winston.debug("TILEBOT_ENDPOINT: " + TILEBOT_ENDPOINT);
 
 winston.info("Tilebot endpoint: " + TILEBOT_ENDPOINT);
 
+
+const apiUrl = process.env.API_URL || configGlobal.apiUrl;
+winston.info('Rasa apiUrl: '+ apiUrl);
+
+const tybot = require("@tiledesk/tiledesk-tybot-connector");
+
+
 class Listener {
 
     listen(config) {
 
         winston.info('Tilebot Listener listen');
-        // winston.debug("config databaseUri: " + config.databaseUri);  
+        winston.debug("Tilebot config databaseUri: " + config.databaseUri);  
         
 
         var that = this;
+       
+        tybot.startApp(
+            {              
+              MONGODB_URI: config.databaseUri,
+              API_ENDPOINT: apiUrl,
+              log: process.env.TILEBOT_LOG
+            }, () => {
+              winston.info("TileBot proxy server successfully started.");                 
+            }
+          );
+
 
-      
         botEvent.on('faqbot.create', function(bot) {
             if (TILEBOT_ENDPOINT) {
 

package/routes/project.js

@@ -213,6 +213,22 @@ router.put('/:projectid', [passport.authenticate(['basic', 'jwt'], { session: fa
     update.ipFilter = req.body.ipFilter;
   }
 
+  if (req.body.ipFilterDenyEnabled!=undefined) {
+    update.ipFilterDenyEnabled = req.body.ipFilterDenyEnabled;
+  }
+
+  if (req.body.ipFilterDeny!=undefined) {
+    update.ipFilterDeny = req.body.ipFilterDeny;
+  }
+
+  if (req.body.bannedUsers!=undefined) {
+    update.bannedUsers = req.body.bannedUsers;
+  }
+
+  
+
+  
+  
   
   // if (req.body.defaultLanguage!=undefined) {
   //   update.defaultLanguage = req.body.defaultLanguage; 
@@ -360,6 +376,19 @@ router.patch('/:projectid', [passport.authenticate(['basic', 'jwt'], { session:
   if (req.body.ipFilter!=undefined) {
     update.ipFilter = req.body.ipFilter;
   }
+
+  if (req.body.ipFilterDenyEnabled!=undefined) {
+    update.ipFilterDenyEnabled = req.body.ipFilterDenyEnabled;
+  }
+
+  if (req.body.ipFilterDeny!=undefined) {
+    update.ipFilterDeny = req.body.ipFilterDeny;
+  }
+
+  if (req.body.bannedUsers!=undefined) {
+    update.bannedUsers = req.body.bannedUsers;
+  }
+  
     
   // if (req.body.defaultLanguage!=undefined) {
   //   update.defaultLanguage = req.body.defaultLanguage; 
@@ -378,6 +407,43 @@ router.patch('/:projectid', [passport.authenticate(['basic', 'jwt'], { session:
   });
 });
 
+
+router.post('/:projectid/ban', [passport.authenticate(['basic', 'jwt'], { session: false }), validtoken, roleChecker.hasRole('admin')], function (req, res) {
+  winston.debug('PATCH PROJECT REQ BODY ', req.body);
+
+  var ban = {};
+  ban.id = req.body.id;
+  ban.ip = req.body.ip;
+
+  Project.findByIdAndUpdate(req.params.projectid, { $push: { bannedUsers: ban } }, { new: true, upsert: false }, function (err, updatedProject) {
+    if (err) {
+      winston.error('Error putting project ', err);
+      return res.status(500).send({ success: false, msg: 'Error patching object.' });
+    }
+    projectEvent.emit('project.update', updatedProject );
+    projectEvent.emit('project.update.user.ban', {banInfo: ban, project: updatedProject });
+    res.json(updatedProject);
+  });
+
+});
+router.delete('/:projectid/ban/:banid', [passport.authenticate(['basic', 'jwt'], { session: false }), validtoken, roleChecker.hasRole('admin')], function (req, res) {
+  
+  // winston.info('quiiiiii');
+  //cacheinvalidation
+Project.findByIdAndUpdate(req.params.projectid, { $pull: { bannedUsers: { "_id": req.params.banid }}}, { new: true, upsert: false }, function (err, updatedProject) {
+  if (err) {
+    winston.error('Error putting project ', err);
+    return res.status(500).send({ success: false, msg: 'Error patching object.' });
+  }
+  projectEvent.emit('project.update', updatedProject );
+  projectEvent.emit('project.update.user.unban', {banInfo: req.params.banid, project: updatedProject});
+  res.json(updatedProject);
+});
+
+});
+
+
+
 //roleChecker.hasRole('agent') works because req.params.projectid is valid using :projectid of this method
 router.get('/:projectid', [passport.authenticate(['basic', 'jwt'], { session: false }), validtoken, roleChecker.hasRoleOrTypes('agent', ['subscription'])], function (req, res) {
   winston.debug(req.body);

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

@@ -224,12 +224,27 @@ router.get('/', function(req, res, next) {
 
 
 
-    const parseIp = (req) =>
-    req.headers['x-forwarded-for']?.split(',').shift()
-    || req.socket?.remoteAddress
+    // 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/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/utils/orgUtil.js

@@ -36,10 +36,10 @@ class OrgUtil {
         // winston.info("host: "+ host );
 
         let origin = req.get('origin');
-        winston.info("origin: "+ origin );
+        winston.debug("origin: "+ origin );
 
         // winston.info("email: " + email.baseUrl);
-        winston.info("this.ORGANIZATION_BASE_URL: " + this.ORGANIZATION_BASE_URL); 
+        winston.debug("this.ORGANIZATION_BASE_URL: " + this.ORGANIZATION_BASE_URL); 
         // global.organizationBaseUrl
         // if (host !=email.baseUrl ) {
         if (origin && origin.indexOf(this.ORGANIZATION_BASE_URL)>-1) {
@@ -49,7 +49,7 @@ class OrgUtil {
             winston.info("origin found: "+ origin );
             return origin;
         }
-        winston.info("origin not found: "+ origin );
+        winston.debug("origin not found: "+ origin );
         
         // winston.info("host not found: "+ host );
         // if (host.indexOf("localhost1")>-1) {