FCF-Facebook.js

var _ = require('underscore');
var moment = require('moment');
var ChatLog = require('./lib/chat-log');
var ChatContextStore = require('./lib/chat-context-store');
var helpers = require('./lib/facebook/facebook');
var utils = require('./lib/helpers/utils');
var request = require('request').defaults({
    encoding: null
});
var Bot = require('./lib/facebook/messenger-bot');
var clc = require('cli-color');

var DEBUG = false;
var green = clc.greenBright;
var white = clc.white;
var grey = clc.blackBright;

module.exports = function(RED) { //module.exports開始

    function FacebookBotNode(n) { //FacebookBotNode開始
        RED.nodes.createNode(this, n);

        var self = this;
        this.botname = n.botname;
        this.log = n.log;

        this.usernames = [];
        if (n.usernames) {

            this.usernames = _(n.usernames.split(',')).chain()
                .map(function(userId) {
                    return userId.match(/^[a-zA-Z0-9_]+?$/) ? userId : null
                })
                .compact()
                .value();
        }


        this.handleMessage = function(botMsg) { //handleMessage開始


            var facebookBot = self.bot;

            if (DEBUG) {
                // eslint-disable-next-line no-console
                console.log('START:-------');
                // eslint-disable-next-line no-console
                console.log(botMsg);
                // eslint-disable-next-line no-console
                console.log('END:-------');
            }

            // mark the original message with the platform
            botMsg = _.extend({}, botMsg, {
                transport: 'facebook'
            });

            var userId = botMsg.sender.id;
            var chatId = botMsg.sender.id;
            var messageId = botMsg.message != null ? botMsg.message.mid : null;
            // todo fix this

            var isAuthorized = true;
            var chatContext = ChatContextStore.getOrCreateChatContext(self, chatId);

            var payload = null;
            // decode the message, eventually download stuff
            self.getMessageDetails(botMsg, self.bot)
                .then(function(obj) {
                    payload = obj;
                    return helpers.getOrFetchProfile(userId, self.bot)
                })
                .then(function(profile) {
                    // store some information
                    chatContext.set('chatId', chatId);
                    chatContext.set('messageId', messageId);
                    chatContext.set('userId', userId);
                    chatContext.set('firstName', profile.first_name);
                    chatContext.set('lastName', profile.last_name);
                    chatContext.set('authorized', isAuthorized);
                    chatContext.set('transport', 'facebook');
                    chatContext.set('message', payload.content);

                    var chatLog = new ChatLog(chatContext);
                    return chatLog.log({
                        payload: payload,
                        originalMessage: {
                            transport: 'facebook',
                            chat: {
                                id: chatId
                            }
                        },
                        chat: function() {
                            return ChatContextStore.getChatContext(self, chatId);
                        }
                    }, self.log)
                })
                .then(function(msg) {

                    var currentConversationNode = chatContext.get('currentConversationNode');
                    // if a conversation is going on, go straight to the conversation node, otherwise if authorized
                    // then first pin, if not second pin
                    if (currentConversationNode != null) {
                        // void the current conversation
                        chatContext.set('currentConversationNode', null);
                        // emit message directly the node where the conversation stopped
                        RED.events.emit('node:' + currentConversationNode, msg);
                    } else {
                        facebookBot.emit('relay', msg);
                    }

                })
                .catch(function(error) {
                    facebookBot.emit('relay', null, error);
                });
        }; ////handleMessage結束


        if (this.credentials) { //if的this.credentials開始
            this.token = this.credentials.token;
            this.app_secret = this.credentials.app_secret;
            this.verify_token = this.credentials.verify_token;

            if (this.token) {
                this.token = this.token.trim();

                if (!this.bot) {

                    this.bot = new Bot({
                        token: this.token,
                        verify: this.verify_token,
                        app_secret: this.app_secret
                    });

                    var uiPort = RED.settings.get('uiPort');
                    // eslint-disable-next-line no-console
                    console.log('');
                    // eslint-disable-next-line no-console
                    console.log(grey('------ Facebook Webhook ----------------'));
                    // eslint-disable-next-line no-console
                    console.log(green('Webhook URL: ') + white('http://localhost' + (uiPort != '80' ? ':' + uiPort : '') +
                        '/redbot/facebook'));
                    // eslint-disable-next-line no-console
                    console.log(green('Verify token is: ') + white(this.verify_token));
                    // eslint-disable-next-line no-console
                    console.log('');
                    // mount endpoints on local express
                    this.bot.expressMiddleware(RED.httpNode);

                    this.bot.on('message', this.handleMessage);
                    this.bot.on('postback', this.handleMessage);
                    this.bot.on('account_linking', this.handleMessage);
                }
            }
        } //if的this.credentials結束

        this.on('close', function(done) {
            var endpoints = ['/facebook', '/facebook/_status'];
            // remove middleware for facebook callback
            RED.httpNode._router.stack.forEach(function(route, i, routes) {
                if (route.route && _.contains(endpoints, route.route.path)) {
                    routes.splice(i, 1);
                }
            });
            done();
        });

        this.isAuthorized = function(username, userId) {
            if (self.usernames.length > 0) {
                return self.usernames.indexOf(username) != -1 || self.usernames.indexOf(String(userId)) != -1;
            }
            return true;
        };

        // creates the message details object from the original message
        this.getMessageDetails = function(botMsg) {
            return new Promise(function(resolve, reject) {

                //var userId = botMsg.sender.id;
                var chatId = botMsg.sender.id;
                var messageId = botMsg.message != null ? botMsg.message.mid : null;

                if (!_.isEmpty(botMsg.account_linking)) {
                    resolve({
                        chatId: chatId,
                        messageId: messageId,
                        type: 'account-linking',
                        content: botMsg.account_linking.authorization_code,
                        linkStatus: botMsg.account_linking.status,
                        date: moment(botMsg.timestamp),
                        inbound: true
                    })
                    return;
                }

                if (botMsg.message == null) {
                    reject('Unable to detect inbound message for Facebook');
                }

                var message = botMsg.message;
                if (!_.isEmpty(message.quick_reply)) {
                    resolve({
                        chatId: chatId,
                        messageId: messageId,
                        type: 'message',
                        content: message.quick_reply.payload,
                        date: moment(botMsg.timestamp),
                        inbound: true
                    });
                    return;
                } else if (!_.isEmpty(message.text)) {
                    resolve({
                        chatId: chatId,
                        messageId: messageId,
                        type: 'message',
                        content: message.text,
                        date: moment(botMsg.timestamp),
                        inbound: true
                    });
                    return;
                }

                if (_.isArray(message.attachments) && !_.isEmpty(message.attachments)) {
                    var attachment = message.attachments[0];
                    switch (attachment.type) {
                        case 'image':
                            // download the image into a buffer
                            helpers.downloadFile(attachment.payload.url)
                                .then(function(buffer) {
                                    resolve({
                                        chatId: chatId,
                                        messageId: messageId,
                                        type: 'photo',
                                        content: buffer,
                                        date: moment(botMsg.timestamp),
                                        inbound: true
                                    });
                                })
                                .catch(function() {
                                    reject('Unable to download ' + attachment.payload.url);
                                });
                            break;
                        case 'file':
                            // download the image into a buffer
                            helpers.downloadFile(attachment.payload.url)
                                .then(function(buffer) {
                                    resolve({
                                        chatId: chatId,
                                        messageId: messageId,
                                        type: 'document',
                                        content: buffer,
                                        date: moment(botMsg.timestamp),
                                        inbound: true
                                    });
                                })
                                .catch(function() {
                                    reject('Unable to download ' + attachment.payload.url);
                                });
                            break;
                        case 'location':
                            resolve({
                                chatId: chatId,
                                messageId: messageId,
                                type: 'location',
                                content: {
                                    latitude: attachment.payload.coordinates.lat,
                                    longitude: attachment.payload.coordinates.long
                                },
                                date: moment(botMsg.timestamp),
                                inbound: true
                            });
                            break;
                    }
                } else {
                    reject('Unable to detect inbound message for Facebook Messenger');
                }
            });
        }
    } //FacebookBotNode結束

    RED.nodes.registerType('FCF-facebook-node', FacebookBotNode, {
        credentials: {
            token: {
                type: 'text'
            },
            app_secret: {
                type: 'text'
            },
            verify_token: {
                type: 'text'
            },
            key_pem: {
                type: 'text'
            },
            cert_pem: {
                type: 'text'
            }
        }
    });

    function FacebookInNode(config) {
        RED.nodes.createNode(this, config);
        var node = this;
        this.bot = config.bot;

        this.config = RED.nodes.getNode(this.bot);
        if (this.config) {
            this.status({
                fill: 'red',
                shape: 'ring',
                text: 'disconnected'
            });

            node.bot = this.config.bot;

            if (node.bot) {
                this.status({
                    fill: 'green',
                    shape: 'ring',
                    text: 'connected'
                });

                node.bot.on('relay', function(message, error) {
                    if (error != null) {
                        node.error(error);
                    } else {
                        node.send(message);
                    }
                });

            } else {
                node.warn('Please select a chatbot configuration in Facebook Messenger Receiver');
            }
        } else {
            node.warn('Missing configuration in Facebook Messenger Receiver');
        }
    }
    RED.nodes.registerType('FCF-facebook-receive', FacebookInNode);


    function FacebookOutNode(config) {
        RED.nodes.createNode(this, config);
        var node = this;
        this.bot = config.bot;
        this.track = config.track;

        this.config = RED.nodes.getNode(this.bot);
        if (this.config) {
            this.status({
                fill: 'red',
                shape: 'ring',
                text: 'disconnected'
            });

            node.bot = this.config.bot;

            if (node.bot) {
                this.status({
                    fill: 'green',
                    shape: 'ring',
                    text: 'connected'
                });
            } else {
                node.warn("no bot in config.");
            }
        } else {
            node.warn("no config.");
        }

        function sendMeta(msg) {
            return new Promise(function(resolve, reject) {

                var type = msg.payload.type;
                var bot = node.bot;


                var reportError = function(err) {
                    if (err) {
                        reject(err);
                    } else {
                        resolve()
                    }
                };

                switch (type) {
                    case 'persistent-menu':
                        bot.setPersistentMenu(msg.payload.items, reportError);
                        break;

                    default:
                        reject();
                }

            });
        }

        function sendMessage(msg) {

            return new Promise(function(resolve, reject) {

                var type = msg.payload.type;
                var bot = node.bot;
                var credentials = node.config.credentials;

                var reportError = function(err) {
                    if (err) {
                        reject(err);
                    } else {
                        resolve()
                    }
                };

                switch (type) {
                    case 'action':
                        request({
                            method: 'POST',
                            json: {
                                recipient: {
                                    id: msg.payload.chatId
                                },
                                'sender_action': 'typing_on'
                            },
                            url: 'https://graph.facebook.com/v2.6/me/messages?access_token=' + credentials.token
                        }, reportError);
                        break;

                    case 'request':

                        // todo error if not location
                        // send
                        bot.sendMessage(
                            msg.payload.chatId, {
                                text: msg.payload.content,
                                quick_replies: [{
                                    'content_type': 'location'
                                }]
                            },
                            reportError
                        );
                        break;

                    case 'account-link':
                        var attachment = {
                            'type': 'template',
                            'payload': {
                                'template_type': 'button',
                                'text': msg.payload.content,
                                'buttons': [{
                                    'type': 'account_link',
                                    'url': msg.payload.authUrl
                                }]
                            }
                        };
                        bot.sendMessage(
                            msg.payload.chatId, {
                                attachment: attachment
                            },
                            reportError
                        );
                        break;

                    case 'inline-buttons':
                        var quickReplies = _(msg.payload.buttons).map(function(button) {
                            var quickReply = {
                                content_type: 'text',
                                title: button.label,
                                payload: !_.isEmpty(button.value) ? button.value : button.label
                            };
                            if (!_.isEmpty(button.image_url)) {
                                quickReply.image_url = button.image_url;
                            }
                            return quickReply;
                        });

                        // send
                        bot.sendMessage(
                            msg.payload.chatId, {
                                text: msg.payload.content,
                                quick_replies: quickReplies
                            },
                            reportError
                        );

                        break;

                    case 'message':
                        bot.sendMessage(
                            msg.payload.chatId, {
                                text: msg.payload.content
                            },
                            reportError
                        );
                        break;

                    case 'location':
                        var lat = msg.payload.content.latitude;
                        var lon = msg.payload.content.longitude;

                        var locationAttachment = {
                            'type': 'template',
                            'payload': {
                                'template_type': 'generic',
                                'elements': {
                                    'element': {
                                        'title': !_.isEmpty(msg.payload.place) ? msg.payload.place : 'Position',
                                        'image_url': 'https:\/\/maps.googleapis.com\/maps\/api\/staticmap?size=764x400&center=' +
                                            lat + ',' + lon + '&zoom=16&markers=' + lat + ',' + lon,
                                        'item_url': 'http:\/\/maps.apple.com\/maps?q=' + lat + ',' + lon + '&z=16'
                                    }
                                }
                            }
                        };

                        bot.sendMessage(
                            msg.payload.chatId, {
                                attachment: locationAttachment
                            },
                            reportError
                        );
                        break;

                    case 'audio':
                        var audio = msg.payload.content;
                        helpers.uploadBuffer({
                            recipient: msg.payload.chatId,
                            type: 'audio',
                            buffer: audio,
                            token: credentials.token,
                            filename: msg.payload.filename
                        }).catch(function(err) {
                            reject(err);
                        });
                        break;

                    case 'document':
                        helpers.uploadBuffer({
                            recipient: msg.payload.chatId,
                            type: 'file',
                            buffer: msg.payload.content,
                            token: credentials.token,
                            filename: msg.payload.filename,
                            mimeType: msg.payload.mimeType
                        }).catch(function(err) {
                            reject(err);
                        });
                        break;

                    case 'photo':
                        var image = msg.payload.content;
                        helpers.uploadBuffer({
                            recipient: msg.payload.chatId,
                            type: 'image',
                            buffer: image,
                            token: credentials.token,
                            filename: msg.payload.filename
                        }).catch(function(err) {
                            reject(err);
                        });
                        break;

                    default:
                        reject('Unable to prepare unknown message type');
                }

            });
        }

        // relay message
        var handler = function(msg) {
            node.send(msg);
        };
        RED.events.on('node:' + config.id, handler);

        // cleanup on close
        this.on('close', function() {
            RED.events.removeListener('node:' + config.id, handler);
        });

        this.on('input', function(msg) {

            // check if the message is from facebook
            if (msg.originalMessage != null && msg.originalMessage.transport !== 'facebook') {
                // exit, it's not from facebook
                return;
            }

            // try to send the meta first (those messages that doesn't require a valid payload)
            sendMeta(msg)
                .then(function() {
                    // ok, meta sent, stop here
                }, function(error) {
                    // if here, either there was an error or no met message was sent
                    if (error != null) {
                        node.error(error);
                    } else {
                        // check payload
                        var payloadError = utils.hasValidPayload(msg);
                        if (payloadError != null) {
                            // invalid payload
                            node.error(payloadError);
                        } else {

                            // payload is valid, go on
                            var track = node.track;
                            var chatContext = msg.chat();

                            // check if this node has some wirings in the follow up pin, in that case
                            // the next message should be redirected here
                            if (chatContext != null && track && !_.isEmpty(node.wires[0])) {
                                chatContext.set('currentConversationNode', node.id);
                                chatContext.set('currentConversationNode_at', moment());
                            }

                            var chatLog = new ChatLog(chatContext);

                            chatLog.log(msg, node.config.log)
                                .then(function() {
                                    sendMessage(msg);
                                });

                        } // end valid payload
                    } // end no error
                }); // end then


        });
    }
    RED.nodes.registerType('FCF-facebook-send', FacebookOutNode);

}; //module.exports結束