chat-platform 1.2.3

package/__tests__/context-provider-sqlite.js

@@ -0,0 +1,239 @@
+const _ = require('underscore');
+const assert = require('chai').assert;
+const fs = require('fs');
+const RED = require('../lib/red-stub')();
+const ContextProviders = require('../chat-context-factory');
+const { when } = require('../lib/utils');
+const os = require('os');
+
+const copyFile = (source, destination) => new Promise((resolve, reject) => {
+  fs.copyFile(source, destination, error => {
+    if (error != null) {
+      reject(error);
+    } else {
+      resolve();
+    }
+  });
+});
+
+const removeFile = file => new Promise((resolve, reject) => {
+  fs.unlink(file, error => {
+    if (error != null) {
+      reject(error);
+    } else {
+      resolve();
+    }
+  });
+});
+
+describe('Chat context provider sqlite - missing file', () => {
+  const contextProviders = ContextProviders(RED);
+  const path = os.tmpdir();
+  const getProvider = () => contextProviders.getProvider('sqlite', { dbPath: path + '/mission-control.sqlite' });
+
+  beforeAll(async () => {
+    const provider = getProvider();
+    await provider.start();
+  });
+
+  afterAll(async () => {
+    await removeFile(path + '/mission-control.sqlite');
+  });
+
+  it('should create a context provider with some default params with chatId', async () => {
+
+    assert.isTrue(contextProviders.hasProvider('sqlite'));
+    const provider = getProvider();
+    assert.isFunction(provider.getOrCreate);
+    assert.isFunction(provider.get);
+    const chatContext = await provider.getOrCreate(43, null, { chatId: 43 });
+    await chatContext.set({ myVariable: 'initial value' })
+    assert.isFunction(chatContext.get);
+    assert.isFunction(chatContext.set);
+    assert.isFunction(chatContext.all);
+    assert.isFunction(chatContext.remove);
+    assert.isFunction(chatContext.clear);
+    const myVariable = await  chatContext.get('myVariable');
+
+    assert.equal(myVariable, 'initial value');
+  });
+
+
+});
+
+
+describe('Chat context provider sqlite', () => {
+  const contextProviders = ContextProviders(RED);
+  const getProvider = () => contextProviders.getProvider('sqlite', { dbPath: __dirname + '/dummy/mission-control.sqlite' });
+
+  beforeAll(async () => {
+    await copyFile(__dirname + '/dummy/mission-control.backup', __dirname + '/dummy/mission-control.sqlite');
+    const provider = getProvider();
+    await provider.start();
+  });
+
+  afterAll(async () => {
+    await removeFile(__dirname + '/dummy/mission-control.sqlite');
+  });
+
+  beforeEach(async () => {
+    const provider = getProvider();
+    await provider.reset();
+  });
+
+  it('should create a context provider with some default params with chatId', async () => {
+
+    assert.isTrue(contextProviders.hasProvider('sqlite'));
+    const provider = getProvider();
+    assert.isFunction(provider.getOrCreate);
+    assert.isFunction(provider.get);
+    const chatContext = await provider.getOrCreate(43, null, { chatId: 43 });
+    await chatContext.set({ myVariable: 'initial value' })
+    assert.isFunction(chatContext.get);
+    assert.isFunction(chatContext.set);
+    assert.isFunction(chatContext.all);
+    assert.isFunction(chatContext.remove);
+    assert.isFunction(chatContext.clear);
+    const myVariable = await  chatContext.get('myVariable');
+
+    assert.equal(myVariable, 'initial value');
+  });
+
+  it('should create a context provider with some default params with userId', async () => {
+    assert.isTrue(contextProviders.hasProvider('sqlite'));
+    const provider = getProvider();
+    assert.isFunction(provider.getOrCreate);
+    assert.isFunction(provider.get);
+    const chatContext = await provider.getOrCreate(null, 44, { userId: 44 });
+    await chatContext.set({ myVariable: 'initial value' })
+    assert.isFunction(chatContext.get);
+    assert.isFunction(chatContext.set);
+    assert.isFunction(chatContext.all);
+    assert.isFunction(chatContext.remove);
+    assert.isFunction(chatContext.clear);
+    const myVariable = await chatContext.get('myVariable');
+    assert.equal(myVariable, 'initial value');
+  });
+
+
+  it('should set some value and then get and remove it with chatId', async () => {
+    const provider = getProvider();
+    const chatContext = await provider.getOrCreate(42, null, { chatId: 42 });
+    await chatContext.set('firstName', 'Guidone');
+    let firstName = await chatContext.get('firstName');
+    assert.equal(firstName, 'Guidone')
+    await chatContext.remove('firstName')
+    firstName = await chatContext.get('firstName')
+    assert.isNull(firstName);
+  });
+
+  it('should set some value and then get and remove it with userId', async () => {
+    const provider = getProvider();
+    const chatContext = await provider.getOrCreate(null, 43, { userId: 43 });
+    await chatContext.set('firstName', 'Guidone');
+    let firstName = await chatContext.get('firstName');
+    assert.equal(firstName, 'Guidone');
+    await chatContext.remove('firstName')
+    firstName = await chatContext.get('firstName');
+    assert.isNull(firstName);
+  });
+
+
+  it('should set some values and then get and remove it with chatId', async () => {
+    const provider = getProvider();
+    const chatContext = await provider.getOrCreate(42, null, { chatId: 42 });
+    await chatContext.set({ firstName: 'Guido', lastName: 'Bellomo' });
+    let firstName = await chatContext.get('firstName');
+    assert.equal(firstName, 'Guido');
+    let lastName = await chatContext.get('lastName');
+    assert.equal(lastName, 'Bellomo')
+    const json = await chatContext.get('firstName', 'lastName');
+    assert.isObject(json);
+    assert.equal(json.firstName, 'Guido');
+    assert.equal(json.lastName, 'Bellomo');
+  });
+
+  it('should set some values and then get and remove it with userId', async () => {
+    const provider = getProvider();
+    const chatContext = await provider.getOrCreate(null, 43, { userId: 43 });
+    await chatContext.set({firstName: 'Guido', lastName: 'Bellomo'});
+    const firstName = await chatContext.get('firstName');
+    assert.equal(firstName, 'Guido');
+    const lastName = await chatContext.get('lastName');
+    assert.equal(lastName, 'Bellomo');
+    const json = await chatContext.get('firstName', 'lastName');
+    assert.isObject(json);
+    assert.equal(json.firstName, 'Guido');
+    assert.equal(json.lastName, 'Bellomo');
+  });
+
+  it('should set some values and get the dump with chatId', async () => {
+    const provider = getProvider();
+    const chatContext = await provider.getOrCreate(42, null, { chatId: 42 });
+    await chatContext.set({ firstName: 'Guido', lastName: 'Bellomo', email: 'spam@gmail.com' });
+    const json = await chatContext.all();
+    assert.isObject(json);
+    assert.equal(json.firstName, 'Guido');
+    assert.equal(json.lastName, 'Bellomo');
+    assert.equal(json.email, 'spam@gmail.com');
+  });
+
+  it('should set some values and get the dump with userId', async () => {
+    const provider = getProvider();
+    const chatContext = await provider.getOrCreate(null, 43, { userId: 43 });
+    await chatContext.set({ firstName: 'Guido', lastName: 'Bellomo', email: 'spam@gmail.com' })
+    const json = await chatContext.all();
+    assert.isObject(json);
+    assert.equal(json.firstName, 'Guido');
+    assert.equal(json.lastName, 'Bellomo');
+    assert.equal(json.email, 'spam@gmail.com');
+  });
+
+  it('should set some values and remove all with chatId', async () => {
+    const provider = getProvider();
+    const chatContext = await provider.getOrCreate(42, null, { userId: 42 });
+    await chatContext.set({ firstName: 'Guido', lastName: 'Bellomo' });
+    await chatContext.clear();
+    const json = await chatContext.all();
+    assert.isObject(json);
+    assert.isTrue(_.isEmpty(json));
+  });
+
+  it('should set some values and remove all with userId', async () => {
+    const provider = getProvider();
+    const chatContext = await provider.getOrCreate(null, 43, { userId: 43 });
+    await chatContext.set({ firstName: 'Guido', lastName: 'Bellomo' });
+    await chatContext.clear();
+    const json = await chatContext.all();
+    assert.isObject(json);
+    assert.isTrue(_.isEmpty(json));
+  });
+
+  it('should set some value the remove with multiple arguments', async () => {
+    const provider = getProvider();
+    const chatContext = await provider.getOrCreate(42, null, { chatId: 42 });
+    await chatContext.set({ firstName: 'Guidone', lastName: 'Bellomo', email: 'some@email' });
+    const firstName = await chatContext.get('firstName');
+    assert.equal(firstName, 'Guidone');
+    await chatContext.remove('firstName', 'lastName', 'email');
+    const json = await chatContext.all();
+    assert.isUndefined(json.firstName);
+    assert.isUndefined(json.lastName);
+    assert.isUndefined(json.email);
+  });
+
+  it('should set some value with chatId and userId', async () => {
+    const provider = getProvider();
+    let chatContext = await provider.getOrCreate(42, 44, { userId: 44, chatId: 42 });
+    await chatContext.set('firstName', 'Guidone');
+    let firstName = await chatContext.get('firstName');
+    assert.equal(firstName, 'Guidone');
+    chatContext = await provider.getOrCreate(null, 44, { userId: 44, chatId: 42 });
+    assert.equal(await chatContext.get('userId'), 44);
+    assert.equal(await chatContext.get('firstName'), 'Guidone');
+    await chatContext.remove('firstName');
+    firstName = await chatContext.get('firstName');
+    assert.isNull(firstName);
+  });
+
+});

package/__tests__/universal-platform.js

@@ -0,0 +1,190 @@
+const moment = require('moment');
+const chai = require('chai');
+const assert = chai.assert;
+const expect = chai.expect;
+const spies = require('chai-spies');
+const RED = require('../lib/red-stub')();
+const Universal = require('../universal');
+const ContextProviders = require('../chat-context-factory');
+const contextProviders = ContextProviders(RED);
+
+chai.use(spies);
+
+describe('Universal Connector', () => {
+
+  let chatServer = null;
+  let chatServerAlt = null;
+  let sendFunction = null;
+
+  beforeEach(() => {
+    // Fake chat server
+    sendFunction = chai.spy(() => { });
+    chatServer = Universal.createServer({
+      contextProvider: contextProviders.getProvider('memory'),
+      debug: false
+    });
+    chatServer.onUserId(payload => payload.user.id);
+    chatServer.onChatId(payload => payload.chat_id);
+    chatServer.onMessageId(payload => payload._id);
+    chatServer.onLanguage(payload =>payload.lang);
+    chatServer.in(message => {
+      return new Promise((resolve) => {
+        const chat = message.chat();
+        if (message.originalMessage.text != null) {
+          chat.set('payload', message.originalMessage.text);
+          message.payload.content = message.originalMessage.text;
+          message.payload.type = 'message';
+        }
+        resolve(message);
+      });
+    });
+    chatServer.use(message => new Promise((resolve, reject) => {
+        message.custom_value = 42;
+        resolve(message);
+      })
+    );
+    chatServer.out('a-message-type', message => new Promise(resolve => {
+        message.message_id = '444';
+        sendFunction();
+        resolve(message);
+      })
+    );
+    // Alt fake server
+    sendFunctionAlt = chai.spy(() => { });
+    chatServerAlt = Universal.createServer({
+      contextProvider: contextProviders.getProvider('memory'),
+      transport: 'universal-alt',
+      debug: false
+    });
+    chatServerAlt.onUserId(payload => payload.user.id);
+    chatServerAlt.onChatId(payload => payload.chat_id);
+    chatServerAlt.onMessageId(payload => payload._id);
+    chatServerAlt.onLanguage(payload =>payload.lang);
+    chatServerAlt.in(message => {
+      return new Promise((resolve) => {
+        const chat = message.chat();
+        if (message.originalMessage.text != null) {
+          chat.set('payload', message.originalMessage.text);
+          message.payload.content = message.originalMessage.text;
+          message.payload.type = 'message';
+        }
+        resolve(message);
+      });
+    });
+    chatServerAlt.use(message => new Promise((resolve, reject) => {
+        message.custom_value = 42;
+        resolve(message);
+      })
+    );
+    chatServerAlt.out('a-message-type', message => new Promise(resolve => {
+        message.message_id = '445';
+        sendFunctionAlt();
+        resolve(message);
+      })
+    );
+    // store the global resolver
+    chatServer.onGetChatIdFromUserId((userId, transport, message) => {
+      if (userId === '1234' && transport === 'universal') {
+        return '42';
+      } else if (userId === '1234' && transport === 'universal-alt') {
+        return '43';
+      }
+      return null;
+    });
+  });
+
+  it('receive incoming message', () => {
+    chatServer.start()
+      .then(() => {
+        chatServer.on('message', message => {
+          assert.equal(message.payload.type, 'message');
+          assert.equal(message.custom_value, 42);
+          assert.equal(message.payload.chatId, '42');
+          assert.equal(message.originalMessage.messageId, 'xyz');
+          assert.equal(message.originalMessage.userId, 24);
+          assert.isFunction(message.chat);
+          const variables = message.chat().all();
+          assert.equal(variables.payload, 'Bazinga');
+          assert.equal(variables.transport, 'universal');
+          assert.equal(variables.authorized, false);
+          assert.equal(variables.language, 'it');
+          assert.instanceOf(message.payload.ts, moment);
+        });
+        chatServer.receive({
+          text: 'Bazinga',
+          lang: 'it',
+          chat_id: '42',
+          _id: 'xyz',
+          user: { id: 24 }
+        });
+      });
+  });
+
+  it('send outgoing message', () => {
+    return chatServer.start()
+      .then(() => chatServer.createMessage('42', '1234', '4567', {
+        payload: {
+          type: 'a-message-type',
+          chatId: '42'
+        }
+      }))
+      .then(message => chatServer.send(message))
+      .then(message => {
+        assert.equal(message.message_id, '444');
+        expect(sendFunction).to.have.been.called();
+      });
+  });
+
+  it('send outgoing message wrong type', () => {
+    return chatServer.start()
+      .then(() => chatServer.createMessage('42', '1234', '4567', {
+        payload: {
+          type: 'a-different-type',
+          chatId: '42'
+        }
+      }))
+      .then(message => chatServer.send(message))
+      .then(() => expect(sendFunction).to.not.have.been.called());
+  });
+
+  it('create a message with just a userId and resolves it', () => {
+    return chatServer.start()
+      .then(() => chatServer.createMessage(null, '1234', '4567', {
+        payload: {
+          type: 'a-message-type'
+        }
+      }))
+      .then(message => chatServer.send(message))
+      .then(() => expect(sendFunction).to.have.been.called());
+  });
+
+  it('create a message with just a userId and doesn\'t resolve it', () => {
+    return chatServer.start()
+      .then(() => chatServer.createMessage(null, '5678', '4567', {
+        payload: {
+          type: 'a-message-type'
+        }
+      }))
+      .then(message => chatServer.send(message))
+      .then(
+        () => {},
+        e => {
+          assert.include(e.toString(), 'Error: The userId<->chatId resolver was not able to find a valid chatId for user 5678');
+          expect(sendFunction).to.not.have.been.called()
+        }
+      );
+  });
+
+  it('create a message with a server and just a userId and try to send to the other server', () => {
+    return chatServer.start()
+      .then(() => chatServer.createMessage(null, '1234', '4567', {
+        payload: {
+          type: 'a-message-type'
+        }
+      }))
+      .then(message => chatServerAlt.send(message))
+      .then(() => expect(sendFunctionAlt).to.have.been.called());
+  });
+
+
+});

package/chat-context-factory.js

@@ -0,0 +1,92 @@
+const _ = require('underscore');
+
+const contextProviders = {};
+contextProviders.memory = require('./providers/memory');
+contextProviders.sqlite = require('./providers/sqlite');
+contextProviders['plain-file'] = require('./providers/plain-file');
+
+let _contexts = {};
+
+const ContextProviders = function(RED) {
+
+  RED = RED || {};
+  // register Slack server
+  if (RED.redbot == null) {
+    RED.redbot = {};
+  }
+  if (RED.redbot.contextProviders == null) {
+    RED.redbot.contextProviders = {};
+  }
+
+  if (RED.settings != null) {
+    RED.settings.set('contextProviders', contextProviders);
+  }
+
+  if (RED.redbot.utils == null) {
+    RED.redbot.utils = {
+      when: function (param) {
+        if (param != null && _.isFunction(param.then)) {
+          return param;
+        } else if (param != null) {
+          return new Promise(function(resolve) {
+            resolve(param);
+          })
+        }
+        return new Promise(function(resolve, reject) {
+          reject();
+        });
+      }
+    };
+  }
+
+  const methods = {
+
+    when(param) {
+      if (param != null && _.isFunction(param.then)) {
+        return param;
+      } else if (param != null) {
+        return new Promise(function(resolve) {
+          resolve(param);
+        })
+      }
+      return new Promise(function(resolve, reject) {
+        reject();
+      });
+    },
+
+    getProviders() {
+      return _.keys(contextProviders);
+    },
+
+    hasProvider(provider) {
+      return _(methods.getProviders()).contains(provider);
+    },
+
+    getProvider(providerName, params = {}) {
+      const provider = contextProviders[providerName];
+      const context = new provider(params);
+      if (params.id != null) {
+        _contexts[params.id] = context;
+      }
+      return context;
+    },
+
+    reset() {
+      _contexts = {};
+    }
+  };
+
+  return methods;
+};
+
+// Static methods
+
+ContextProviders.getProviderById = function(id) {
+  return _contexts[id];
+};
+
+ContextProviders.reset = function() {
+  return _contexts = {};
+};
+
+module.exports = ContextProviders;

package/chat-log.js

@@ -0,0 +1,115 @@
+var _ = require('underscore');
+var moment = require('moment');
+var fs = require('fs');
+var lcd = require('./helpers/lcd');
+
+module.exports = function(variables) {
+
+  var self = {
+
+    log: function(msg, fileName) {
+      return new Promise(function(resolve) {
+        if (_.isEmpty(fileName)) {
+          // resolve immediately if empty and do nothing
+          resolve(msg);
+        } else {
+          fs.appendFile(fileName, self.message(msg) + '\n', function (err) {
+            if (err) {
+              // eslint-disable-next-line no-console
+              console.error(err);
+            }
+            // resolve anyway, problem on logging should not stop the chatbot
+            resolve(msg);
+          });
+        }
+      });
+    },
+
+    toString: function(msg) {
+
+      var logString = null;
+
+      if (_.isObject(msg.payload)) {
+
+        switch (msg.payload.type) {
+          case 'message':
+            logString = msg.payload.content;
+            break;
+          case 'location':
+            logString = 'latitude: ' + msg.payload.content.latitude + ' longitude: ' + msg.payload.content.latitude;
+            break;
+          case 'photo':
+            logString = 'image: ' + (msg.payload.filename != null ? msg.payload.filename : '<buffer>');
+            break;
+          case 'video':
+            logString = 'video: ' + (msg.payload.filename != null ? msg.payload.filename : '<buffer>');
+            break;
+          case 'document':
+            logString = 'document: ' + (msg.payload.filename != null ? msg.payload.filename : '<buffer>');
+            break;
+          case 'audio':
+            logString = 'audio: ' + (msg.payload.filename != null ? msg.payload.filename : '<buffer>');
+            break;
+          case 'inline-buttons':
+            logString = msg.payload.content + ' ' + msg.payload.buttons.map(function (button) {
+                return '[' + button.label + ']';
+              }).join(' ');
+            break;
+          case 'intent':
+            logString = 'intent: ' + msg.payload.intent + ' vars: ' + JSON.stringify(msg.payload.variables);
+            break;
+          case 'event':
+            logString = 'event: ' + msg.payload.eventType;
+            break;
+          case 'speech':
+            logString = 'speech: '
+              + (!_.isEmpty(msg.payload.text) ? msg.payload.text : '')
+              + (!_.isEmpty(msg.payload.ssml) ? msg.payload.ssml : '');
+            break;
+          case 'directive':
+            logString = 'directive: ' +  msg.payload.directiveType;
+            break;
+          default:
+            // eslint-disable-next-line no-console
+            console.log(lcd.warn('Un-handled message type ' + msg.payload.type + ' in logs'));
+            logString = msg.payload.content instanceof Buffer ? '<buffer>' : String(msg.payload.content);
+        }
+      }
+
+      return logString;
+    },
+
+    message: function(msg) {
+
+      var chatId = variables.chatId || msg.originalMessage.chatId || msg.payload.chatId;
+      var inbound = msg.payload != null && msg.payload.inbound === true;
+      var firstName = variables.firstName;
+      var lastName = variables.lastName;
+      var transport = msg.originalMessage != null ? msg.originalMessage.transport : null;
+      var logString = null;
+
+      var name = [];
+      if (firstName != null) {
+        name.push(firstName);
+      }
+      if (lastName != null) {
+        name.push(lastName);
+      }
+
+      if (_.isObject(msg.payload)) {
+        var stringifiedMessage = this.toString(msg);
+        if (!_.isEmpty(stringifiedMessage)) {
+          logString = chatId + ' '
+            + (!_.isEmpty(name) ? '[' + name.join(' ') + '] ' : '')
+            + (inbound ? '> ' : '< ')
+            + (transport != null ? '[' + transport.toUpperCase() + '] ' : '')
+            + moment().toString() + ' - ' + stringifiedMessage;
+        }
+      }
+
+      return logString;
+    }
+  };
+
+  return self;
+};