messenger-codes

#!/usr/bin/env node
const axios = require("axios");
const crypto = require("crypto");
const fs = require("fs");
const path = require("path");

const inquirer = require('inquirer');
const program = require('commander');
const git = require('simple-git');
const currentDir = process.cwd();
const repo = git(currentDir);

const isNull = (v) => (v === undefined) || (v === null);
const isNonNull = (v) => !isNull(v);

let cmdValue, envValue, env2Value;


program
.version('0.1.0')
.description('Manage messenger short codes with source control')
.usage(`mcodes provides simple functions to manage Facebook Messenger codes
with a configuration driven CLI allowing you to manage your codes with source
control.

Read More:
https://developers.facebook.com/docs/messenger-platform/discovery/messenger-codes


init [options] <file ...>
Intializes a folder, config file and manifest file for your messenger application

create <ref> <description>
Creates a new messenger code with a ref and description, and places it in the mcodes directory

sync
Commits and syncs your local mcodes to the remote repository`)
.arguments('<cmd> [arg1] [arg2] [arg3]')
.action(function (cmd, arg1, arg2) {
    cmdValue = cmd;
    envValue = arg1;
    env2Value = arg2;
})
.option('-d, --debug', 'Debug')
.option('-f, --force', 'Force')
.option('-a, --auth-token [value]', 'Facebook page auth token')

program.parse(process.argv);
if (typeof cmdValue !== 'undefined') {

    switch (cmdValue) {

        case 'sync':
            console.log('Syncing with git repo...');
            syncRepo();
            break;

        case 'create':
            createCodeRequested(envValue, env2Value);
            break;

        case 'init':
            initialize()
            break;
    
        default:
            break;
    }

} else {
    console.log( program.helpInformation() );
    process.exit(0);
}

async function initialize() {

    if (fs.existsSync(path.join(currentDir, 'mcodes.config.json'))) {
        console.log('mcodes already initialized');
        return;
    }

    repo.checkIsRepo((err, result) => {
        if (isNonNull(err) || result === false) {
            console.log('Must be a git repo');
            throw err;
        } else {

            const questions = [
                {
                    type: 'input',
                    name: 'pageName',
                    message: "Page Name"
                },
                {
                    type: 'input',
                    name: 'pageAccessToken',
                    message: "Page Access token"
                },
                {
                    type: 'input',
                    name: 'appId',
                    message: "App ID"
                },
                {
                    type: 'input',
                    name: 'folder',
                    message: "folder",
                    default: 'messenger-codes'
                },
            ];
        
            inquirer.prompt(questions).then(async (answers) => {
        
                const pageName = answers.pageName;
                const pageAccessToken = answers.pageAccessToken;
                const appId = answers.appId;
                const folder = answers.folder;

                if (fs.existsSync(answers.folder) === true) {
                    console.log("Folder already exists.");
                } else {
                    fs.mkdirSync(answers.folder);
                }
                
                fs.writeFileSync(path.join(currentDir, 'mcodes.config.json'), JSON.stringify({
                    name: pageName,
                    appId,
                    pageAccessToken,
                    folder: answers.folder
                }, null, "\t"));

                fs.mkdirSync(path.join(folder, 'img'));

                fs.writeFileSync(path.join(folder, 'manifest.json'), JSON.stringify({}, null, "\t"));

                const gitIgnore = path.join(currentDir, '.gitignore');
                if (gitIgnore) {
                    fs.appendFileSync(gitIgnore, '\nmcodes.config.json\n');
                } else {
                    fs.writeFileSync(gitIgnore, 'mcodes.config.json\n')
                }

                console.log('mcodes initialized');
            });
        }
    })
    
}

async function createCode(ref, pageAccessToken, imageSize) {
    if (isNull(ref) || isNull(pageAccessToken)) {
        console.log("ref and pageAccesToken must be defined");
        return;
    }

    const size = imageSize || 2000;
    const url = "https://graph.facebook.com/v2.6/me/messenger_codes?access_token=" + pageAccessToken;
    const method = "POST";
    const id = crypto.randomBytes(4).toString('hex');
    const data = { 
        type: "standard",
        data: { ref: id },
        image_size: size
    };
    try {
        const response = await axios.post(url, data);
        return Object.assign({ id: id }, response.data);
    } catch (err) {
        throw new Error("There was an error resolving the request to Facebook");
    }
}


async function createCodeRequested(ref, description) {

    if (isNull(ref) || ref.length === 0 || isNull(description) || description.length === 0) {
        console.warn('Bad arguments');
    }
    const newObjJson = { ref, description  };
    const questions = [
        {
            type: 'confirm',
            name: 'createCode',
            message: `Does this look right? \n${JSON.stringify(newObjJson, null, '  ')}`,
            default: false
        }
    ];


    inquirer.prompt(questions).then(async (answers) => {

        const accessToken = require(path.join(currentDir, 'mcodes.config.json'))['pageAccessToken'] || answers['auth-token'];
        const size = 2000;
    
        if (answers.createCode === true) {
            result = await createCode(ref, accessToken, size);
            await saveCode(result.uri, result.id, ref, description);
            await syncRepo();
        }
    });

}

async function saveCode(uri, id, ref, description) {
    if (isNull(uri) || isNull(ref)) {
        return;
    }
    const config = require(path.join(process.cwd(), 'mcodes.config.json'));
    const manifest = require(path.join(process.cwd(), config.folder, 'manifest.json'))
    const response = await axios.get(uri, { responseType: 'arraybuffer'});
    const fileBuffer = new Buffer(response.data, "binary");
    fs.writeFileSync(path.join(config.folder, 'img', id + '.png'), fileBuffer);
    manifest[id] = { uri, ref, description }
    fs.writeFileSync(path.join(config.folder, 'manifest.json'), `${JSON.stringify(manifest, null, "\t")}\n`);
}

async function syncRepo() {
    const config = require(path.join(process.cwd(), 'mcodes.config.json'));
    const commitMessage = `Automated commit by ${require("os").userInfo().username}`
    repo.pull('origin', 'master')
        .add([`${config.folder}/img/*`, `${config.folder}/manifest.json`])
        .commit(commitMessage)
        .push('origin', 'master');

    console.log('Sync complete.');
};