index.js

var acronymicon = require("./acronymicon").default;
var jira_matcher = require("./jira_matcher/jira_matcher.js");
var offhours = require("./offhours/offhours.js");
var moment = require('moment-timezone')

function numberWithCommas(x) {
    return x.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",");
}

function shuffle(array) {
  var currentIndex = array.length,
    temporaryValue,
    randomIndex;

  while (0 !== currentIndex) {
    randomIndex = Math.floor(Math.random() * currentIndex);
    currentIndex -= 1;
    temporaryValue = array[currentIndex];
    array[currentIndex] = array[randomIndex];
    array[randomIndex] = temporaryValue;
  }

  return array;
}

function qppfc_standup_list() {
  var arr = [
    "scott f","dale", "curt", "tim", "wes", "ruth", "nic", "scott h", "charlie", "jon", "wilson", "aj", "chris", "john k", "jesse", "manoj", "clyde", "david", "andrew", "peter"
  ];
  arr = shuffle(arr);
  console.log(arr.join(","));
  return arr.join(", ");
}

function hcqis_standup() {
  var arr1 = [
     "chris b", "chris l", "jesse", "james", "john", "sampat", "tom s"
  ];
  var arr2 = [
    "tom w", "andrew", "manoj"
  ];
  arr1 = shuffle(arr1); 
  var arr = arr1.concat(arr2);
  console.log(arr.join(","));
  return arr.join(", ");
}

function iqies_standup() {
  var arr1 = [
     "chris l", "james", "john", "prabha", "tim"
  ];
  var arr2 = [
    "tom w", "ryan", "bryon"
  ];
  arr1 = shuffle(arr1); 
  var arr = arr1.concat(arr2);
  console.log(arr.join(","));
  return arr.join(", ");
}

function onInstallation(bot, installer) {
  if (installer) {
    bot.startPrivateConversation({ user: installer }, function(err, convo) {
      if (err) {
        console.log(err);
      } else {
        convo.say("I am a bot that has just joined your team");
        convo.say(
          "You must now /invite me to a channel so that I can be of use!"
        );
      }
    });
  }
}

/// @function pagerduty_message
/// @brief returns the PagerDuty response as a string
/// @param {String} line_separator the character used to separate lines
/// @returns {String} Flexibot's response
function pagerduty_message(line_separator) {

  if (typeof (line_separator) === 'undefined') {
    line_separator = "\n";
  }

  var response_lines = [
    "https://media.giphy.com/media/p9bj7nrUPAypq/giphy.gif",
    "DON'T PANIC!!",
    "Managing Response to Incidents: https://confluence.cms.gov/display/QPPGUIDE/Managing+Response+to+Incidents",
    "Incident Response Teams: https://confluence.cms.gov/display/QPPGUIDE/Incident+Response+Teams",
    "PagerDuty - Escalation Policies: https://confluence.cms.gov/display/QPPGUIDE/PagerDuty+-+Escalation+Policies"
  ];

  return response_lines.join (line_separator);
}


/// @function pagerduty_offline
/// @brief returns the PagerDuty response if called off-hours
/// @returns {String} Flexibot's response
function pagerduty_offhours(line_separator) {

  if (typeof (line_separator) === 'undefined') {
    line_separator = "\n";
  }

  if (offhours.is_offhours (new Date())) {
    return pagerduty_message (line_separator);
  }

  return false;

}

/**
 * Configure the persistence options
 */

var config = {};
if (process.env.MONGOLAB_URI) {
  var BotkitStorage = require("botkit-storage-mongo");
  config = {
    storage: BotkitStorage({ mongoUri: process.env.MONGOLAB_URI })
  };
} else {
  config = {
    json_file_store: process.env.TOKEN
      ? "./db_slack_bot_ci/"
      : "./db_slack_bot_a/" //use a different name if an app or CI
  };
}

/**
 * Are being run as an app or a custom integration? The initialization will differ, depending
 */

if (process.env.TOKEN || process.env.SLACK_TOKEN) {
  //Treat this as a custom integration
  var customIntegration = require("./lib/custom_integrations");
  var token = process.env.TOKEN ? process.env.TOKEN : process.env.SLACK_TOKEN;
  var controller = customIntegration.configure(token, config, onInstallation);
} else if (
  process.env.CLIENT_ID &&
  process.env.CLIENT_SECRET &&
  process.env.PORT
) {
  console.log(process.env.CLIENT_ID);
  //Treat this as an app
  var app = require("./lib/apps");
  var controller = app.configure(
    process.env.PORT,
    process.env.CLIENT_ID,
    process.env.CLIENT_SECRET,
    config,
    onInstallation
  );
} else {
  console.log(
    "Error: If this is a custom integration, please specify TOKEN in the environment. If this is an app, please specify CLIENTID, CLIENTSECRET, and PORT in the environment"
  );
  process.exit(1);
}

/**
 * A demonstration for how to handle websocket events. In this case, just log when we have and have not
 * been disconnected from the websocket. In the future, it would be super awesome to be able to specify
 * a reconnect policy, and do reconnections automatically. In the meantime, we aren't going to attempt reconnects,
 * WHICH IS A B0RKED WAY TO HANDLE BEING DISCONNECTED. So we need to fix this.
 *
 * TODO: fixed b0rked reconnect behavior
 */
// Handle events related to the websocket connection to Slack
controller.on("rtm_open", function(bot) {
  console.log("** The RTM api just connected!");
});

controller.on("rtm_close", function(bot) {
  console.log("** The RTM api just closed");
  // you may want to attempt to re-open
});

/**
 * Core bot logic goes here!
 */
// BEGIN EDITING HERE!

controller.on("bot_channel_join", function(bot, message) {
  bot.reply(message, "I'm here!");
});

controller.hears("hello", "direct_message", function(bot, message) {
  bot.reply(message, "Hello!");
});

controller.hears("weekend", "ambient", function(bot, message) {
  bot.reply(message, "WEEKEND!!!! YEAH!!! :taco: and :beer:");
});

controller.hears("monday", "ambient", function(bot, message) {
  bot.reply(message, "Mondays are horrible, so have some more :Coffee:!");
});

controller.hears("tuesday", "ambient", function(bot, message) {
  bot.reply(message, ":taco::taco::taco::taco::taco::taco::taco::taco::taco:");
});

controller.hears("Vacation", "ambient", function(bot, message) {
  bot.reply(message, "Flexibot never goes on vacation...");
});

controller.hears("Flexion", "ambient", function(bot, message) {
  bot.reply(message, "Flexion, Value Forward!");
});

controller.hears(
  ["Merry Christmas"],
  ["direct_mention", "mention", "direct_message"],
  function(bot, message) {
    bot.reply(
      message,
      "https://ic.pics.livejournal.com/aedit/60452602/124812/124812_original.gif"
    );
  }
);

controller.hears(
  ["hello", "hi", "greetings"],
  ["direct_mention", "mention", "direct_message"],
  function(bot, message) {
    bot.reply(message, "Hello!");
  }
);

controller.hears(["global pandemic"], ["ambient"], function(bot, message) {
      const request = require('request')
      request('https://corona.lmao.ninja/v2/all', function (error, response, body) {
      //console.error('error:', error); // Print the error if one occurred
      //console.log('statusCode:', response && response.statusCode); // Print the response status code if a response was received
      //console.log('body:', body); // Print the HTML for the Google homepage.

      const parseJsonAsync = (jsonString) => {
        return new Promise(resolve => {
          setTimeout(() => {
            resolve(JSON.parse(jsonString))
          })
        })
      }

      parseJsonAsync(body).then(jsonData => console.log(jsonData))
      //console.log(JSON.stringify(body))

      const results = JSON.parse(body);
      const updatedAt = moment.utc(results.updated).tz("America/New_York").format('MMMM Do YYYY, h:mm:ss a z');
      const formattedResults = `\n*Global COVID-19 stats as of ${updatedAt}:*\n
      *Cases:* ${numberWithCommas(results.cases)}\n
      *Deaths:* ${numberWithCommas(results.deaths)}\n
      *Recovered:* ${numberWithCommas(results.recovered)}\n`;

      bot.reply(message, formattedResults);
    });
  });

controller.hears(["usa pandemic"], ["ambient"], function(bot, message) {
    const request = require('request')
    request('https://corona.lmao.ninja/v2/countries', function (error, response, body) {
    //console.error('error:', error); // Print the error if one occurred
    //console.log('statusCode:', response && response.statusCode); // Print the response status code if a response was received
    //console.log('body:', body); // Print the HTML for the Google homepage.

    const parseJsonAsync = (jsonString) => {
      return new Promise(resolve => {
        setTimeout(() => {
          resolve(JSON.parse(jsonString))
        })
      })
    }

    parseJsonAsync(body).then(jsonData => console.log(jsonData))
    //console.log(JSON.stringify(body))
    const results = JSON.parse(body);
    let usaResults;
    Object.keys(results).some(key => {
      const countryData = results[key];
      if (countryData.country === 'USA') {
        usaResults = countryData;
        return true;
      }
    })

    const formattedResults = `\n*COVID-19 stats for USA:*\n
      *Cases:* ${numberWithCommas(usaResults.cases)}\n
      *TodaysCases:* ${numberWithCommas(usaResults.todayCases)}\n
      *Deaths:* ${numberWithCommas(usaResults.deaths)}\n
      *Recovered:* ${numberWithCommas(usaResults.recovered)}\n
      *Active:* ${numberWithCommas(usaResults.active)}\n
      *Critical:* ${numberWithCommas(usaResults.critical)}\n
      *Cases Per One Million:* ${numberWithCommas(usaResults.casesPerOneMillion)}\n`;
      bot.reply(message, formattedResults);
 })
});

controller.hears(["canada pandemic"], ["ambient"], function(bot, message) {
    const request = require('request')
    request('https://corona.lmao.ninja/v2/countries', function (error, response, body) {
    //console.error('error:', error); // Print the error if one occurred
    //console.log('statusCode:', response && response.statusCode); // Print the response status code if a response was received
    //console.log('body:', body); // Print the HTML for the Google homepage.

    const parseJsonAsync = (jsonString) => {
      return new Promise(resolve => {
        setTimeout(() => {
          resolve(JSON.parse(jsonString))
        })
      })
    }

    parseJsonAsync(body).then(jsonData => console.log(jsonData))
    //console.log(JSON.stringify(body))
    const results = JSON.parse(body);
    let canResults;
    Object.keys(results).some(key => {
      const countryData = results[key];
      if (countryData.country === 'Canada') {
        canResults = countryData;
        return true;
      }
    })

    const formattedResults = `\n*COVID-19 stats for Canada:*\n
      *Cases:* ${numberWithCommas(canResults.cases)}\n
      *TodaysCases:* ${numberWithCommas(canResults.todayCases)}\n
      *Deaths:* ${numberWithCommas(canResults.deaths)}\n
      *Recovered:* ${numberWithCommas(canResults.recovered)}\n
      *Active:* ${numberWithCommas(canResults.active)}\n
      *Critical:* ${numberWithCommas(canResults.critical)}\n
      *Cases Per One Million:* ${numberWithCommas(canResults.casesPerOneMillion)}\n`;
      bot.reply(message, formattedResults);
 })
});



controller.hears(["egypt pandemic"], ["ambient"], function(bot, message) {
  const request = require('request')
  request('https://corona.lmao.ninja/v2/countries', function (error, response, body) {
  //console.error('error:', error); // Print the error if one occurred
  //console.log('statusCode:', response && response.statusCode); // Print the response status code if a response was received
  //console.log('body:', body); // Print the HTML for the Google homepage.

  const parseJsonAsync = (jsonString) => {
    return new Promise(resolve => {
      setTimeout(() => {
        resolve(JSON.parse(jsonString))
      })
    })
  }

  parseJsonAsync(body).then(jsonData => console.log(jsonData))
  //console.log(JSON.stringify(body))
  const results = JSON.parse(body);
  let usaResults;
  Object.keys(results).some(key => {
    const countryData = results[key];
    if (countryData.country === 'Egypt') {
      usaResults = countryData;
      return true;
    }
  })

  const formattedResults = `\n*COVID-19 stats for Egypt:*\n
    *Cases:* ${numberWithCommas(usaResults.cases)}\n
    *TodaysCases:* ${numberWithCommas(usaResults.todayCases)}\n
    *Deaths:* ${numberWithCommas(usaResults.deaths)}\n
    *Recovered:* ${numberWithCommas(usaResults.recovered)}\n
    *Active:* ${numberWithCommas(usaResults.active)}\n
    *Critical:* ${numberWithCommas(usaResults.critical)}\n
    *Cases Per One Million:* ${numberWithCommas(usaResults.casesPerOneMillion)}\n`;
    bot.reply(message, formattedResults);
})
});


controller.hears(
  ["flexibot weather"],
  ["direct_mention", "ambient", "direct_message"],
  function(bot, message) {
    var ta = message.text.split(" ");
    if (ta[2]) {
      var location = ta[2];
      console.log("Weather location is " + location);
      var weather = require("weather-js");
      weather.find({ search: location, degreeType: "F" }, function(
        err,
        result
      ) {
        if (err) console.log(err);
        console.log(JSON.stringify(result, null, 2));
        bot.reply(message, JSON.stringify(result));
      });
    } else {
      var my_weather = "Please provide a zipcode of a town,state with no spaces";
      bot.reply(message, my_weather);
    }
  }
);

// GUILDS
controller.hears(
  ["guilds list"],
  ["direct_mention", "ambient", "direct_message"],
  function (bot, message) {
    bot.api.conversations.list({ exclude_archived: true, limit: 999 }, function (err, response) {
      const allChannels = response.channels;
      const channelsList = allChannels.filter((channel) => /^g-.*$/.test(channel.name)).map((channel) => channel.id);
      // to get the channel purpose: channel.purpose.value

      let formattedResults = `\n*Guilds:*\n`;
      channelsList.forEach((channel) => {
        formattedResults += `<#${channel}>\n`;
      });
      bot.reply(message, formattedResults);
    })
  }
);
// END GUILDS

controller.hears(["qppfc_standup_list"], ["ambient"], function(bot, message) {
  var list = qppfc_standup_list();
  console.log(list);
  bot.reply(message, list);
});

controller.hears(["hcqis_standup"], ["ambient"], function(bot, message) {
  var list = hcqis_standup();
  console.log(list);
  bot.reply(message, list);
});

controller.hears(["iqies_standup"], ["ambient"], function(bot, message) {
  var list = iqies_standup();
  console.log(list);
  bot.reply(message, list);
});

controller.hears(["tableflip"], ["ambient"], function(bot, message) {
  bot.reply(message, "http://gph.is/1a5Y3KD");
});

controller.hears(["oh no"], ["ambient"], function(bot, message) {
  bot.reply(message, "https://i.redd.it/y45cjik5n2b21.jpg");
});

controller.hears(["great scott"], ["ambient"], function(bot, message) {
  bot.reply(message, "https://imgur.com/HHEBL5Y");
});

controller.hears(["captain"], ["ambient"], function(bot, message) {
  bot.reply(message, "https://gph.is/1UwGeco");
});

controller.hears(["goodnews", "good news"], ["ambient"], function(bot, message) {
  bot.reply(message, "https://media.giphy.com/media/3zFcbgHoIXzykQc7vU/giphy.gif");
});

controller.hears(["shame"], ["ambient"], function(bot, message) {
  bot.reply(message, "https://media.giphy.com/media/vX9WcCiWwUF7G/200w_d.gif");
});

controller.hears(["timesheets"], ["ambient"], function(bot, message) {
  bot.reply(
    message,
    "https://media.giphy.com/media/3ornjXizVZDbngmjRK/giphy.gif"
  );
});

controller.hears(["facepalm"], ["ambient"], function(bot, message) {
  bot.reply(message, "http://gph.is/HuXm07");
});

controller.hears(["fistbump"], ["ambient"], function(bot, message) {
  bot.reply(message, "https://gph.is/2aYNzSb");
});

controller.hears(["love coffee"], ["ambient"], function(bot, message) {
  bot.reply(message, "https://gph.is/19womaE");
});

controller.hears(["taco"], ["ambient"], function(bot, message) {
  bot.reply(message, "http://gph.is/2961YfG");
});

controller.hears(["cowbell"], ["ambient"], function(bot, message) {
  bot.reply(message, "http://gph.is/1a6B565");
});

controller.hears(["beer"], ["ambient"], function(bot, message) {
  bot.reply(message, "https://gph.is/XKR6Yn");
});

controller.hears(["makeitso", "make it so"], ["ambient"], function(
  bot,
  message
) {
  bot.reply(message, "http://gph.is/2b6YjxW");
});

controller.hears(["thundercats ho"], ["ambient"], function(bot, message) {
  bot.reply(message, "https://gph.is/180SLfX");
});

controller.hears(["rimshot"], ["ambient"], function(bot, message) {
  bot.reply(message, "https://tenor.com/575K.gif");
});

controller.hears(["awesome"], ["ambient"], function(bot, message) {
  bot.reply(
    message,
    "Team Awesome Sauce, brought to you by :coffee: and :beer:"
  );
});

controller.hears(["free bird", "freebird"], ["ambient"], function(
  bot,
  message
) {
  bot.reply(message, "AND THIS :bird: YOU CANNOT CHANGE!!!! ");
});

controller.hears(["Friday", "friday"], ["ambient"], function(bot, message) {
  var day_of_week = new Date().getDay();
  switch (day_of_week) {
    case 6:
    case 0:
    case 1:
      bot.reply(message, "Friday was too far away...");
      break;
    case 2:
    case 3:
      bot.reply(
        message,
        `Only ${5 - day_of_week} days until Friday! :rockon:  `
      );
      break;
    case 4:
      bot.reply(message, "Only 1 day until Friday! :rockon:  ");
      break;
    case 5:
      bot.reply(message, "TGIF!!! :rockon:  ");
      break;
  }
});

controller.hears(["flexibot help"], ["ambient"], function(bot, message) {
  bot.reply(
    message,
    "to save type 'flexibot save urls name url', to list urls type 'flexibot list urls'  "
  );
});

controller.hears(["roll"], ["ambient"], function(bot, message) {
  var roll_var = message.text.split(" ");
  var dice = roll_var[1];
  var Roll = require("roll"),
    roll = new Roll();
  var Die = roll.roll(dice);
  var res = Die.result;
  bot.reply(message, "Result: " + res);
});

controller.hears(["flexibot save"], ["ambient"], function(bot, message) {
  var ta = message.text.split(" ");
  var type = ta[2];
  var name = ta[3];
  var item = ta[4];
  console.log(
    "logging info type:" + type + ", item:" + item + ", name: " + name
  );
  var json_to_store = '{ "item": "' + item + '" , "name": "' + name + '"}';
  var MongoClient = require("mongodb").MongoClient;
  var url = "mongodb://localhost:27017/";
  MongoClient.connect(
    url,
    { useNewUrlParser: true },
    function(err, db) {
      console.log("Connected correctly to server");
      if (err) throw err;
      var dbo = db.db("flexibot");
      dbo
        .collection(type)
        .insertOne(JSON.parse(json_to_store), function(err, res) {
          if (err) throw err;
          console.log("1 document inserted");
          db.close();
        });
    }
  );
  console.log("JSON: " + json_to_store);
  bot.reply(message, "Flexibot has stored item of type: " + type);
});

controller.hears(["flexibot list"], ["ambient"], function(bot, message) {
  var ta = message.text.split(" ");
  var type = ta[2];
  console.log("type is " + type);
  var MongoClient = require("mongodb").MongoClient;
  assert = require("assert");
  var url = "mongodb://localhost:27017/";
  MongoClient.connect(
    url,
    { useNewUrlParser: true },
    function(err, db) {
      console.log("Connected correctly to server");
      if (err) throw err;
      var dbo = db.db("flexibot");
      dbo
        .collection(type)
        .find()
        .toArray(function(err, results) {
          assert.equal(err, null);
          assert.notEqual(results.length, 0);
          var response = "";
          results.forEach(function(result) {
            console.log(result.name + "," + result.item);
            response += "url: " + result.item + ", name: " + result.name + "\n";
          });
          bot.reply(message, response);
        });
    }
  );
});

controller.hears(["flexibot whois"], ["ambient"], function(bot, message) {
  var ta = message.text.split(" ");
  if (ta[2]) {
    var first_name = ta[2];
    var last_name = ta[3];
    var url = "";
    var confl_url =
      "https://confluence.cms.gov/dosearchsite.action?cql=siteSearch+~+";
    if (ta[3]) {
      console.log("name to look up is " + first_name + last_name);
      url =
        confl_url +
        "%22" +
        first_name +
        "+" +
        last_name +
        "%22&queryString=" +
        first_name +
        "+" +
        last_name;
    } else {
      console.log("name to look up is " + first_name);
      url = confl_url + "%22" + first_name + "%22&queryString=" + first_name;
    }
    bot.reply(message, url);
  } else {
    bot.reply(
      message,
      "usage: flexibot whois <first_name> {optional: <last_name>}"
    );
  }
});

controller.hears(["flexibot dbtest"], ["ambient"], function(bot, message) {
  var MongoClient = require("mongodb").MongoClient;
  var url = "mongodb://localhost:27017/";
  MongoClient.connect(
    url,
    { useNewUrlParser: true },
    function(err, db) {
      console.log("Connected correctly to server");
      bot.reply(message, "Connected to DB");
    }
  );
});

controller.hears(["flexibot remind me"], ["ambient"], function(bot, message) {
  var ta = message.text.split(" ");
  var type = ta[3];
  var name = ta[4];
  var MongoClient = require("mongodb").MongoClient;
  assert = require("assert");
  var url = "mongodb://localhost:27017/";
  MongoClient.connect(
    url,
    { useNewUrlParser: true },
    function(err, db) {
      console.log("Connected correctly to server");
      if (err) throw err;
      var dbo = db.db("flexibot");
      var query = ' { "name": "' + name + '"} ';
      var fields = '{ "name": true }';
      console.log(query);
      dbo
        .collection(type)
        .find(JSON.parse(query), [fields])
        .toArray(function(err, results) {
          assert.equal(err, null);
          assert.notEqual(results.length, 0);
          results.forEach(function(result) {
            console.log(result.name + "," + result.item);
            bot.reply(message, result.item);
          });
        });
    }
  );
});

controller.hears(
  [
    "flexibot what is",
    "flexibot what's",
    "flexibot whats",
    "wth is",
    "wtf is",
    "whodat",
    "who's that pokemon"
  ],
  ["ambient"],
  acronymicon
);

controller.hears (
  [
    "time"
  ],
  [
    "direct_mention", "mention", "direct_message"
  ],
  function (bot, message) {
    var right_now = new Date();
    var now_string = right_now.toString();
    bot.reply (message, now_string);
  }
);


controller.hears (
  [
  "pagerduty",
  "pager duty"
  ],
  [
    ["direct_mention", "mention", "direct_message"],
  ],
  function(bot, message) {
    bot.reply(message, pagerduty_message());
  }
);


controller.hears (
  [
  "pagerduty",
  "pager duty"
  ],
  [
    "ambient",
  ],
  function(bot, message) {
    bot.reply(message, pagerduty_offhours());
  }
);

controller.hears (
  new RegExp(/[A-Za-z]{3,8}-[0-9]{1,5}/),
  [ "ambient" ],
  function (bot, message) {

  var response_string = "";

  //response_string + = "Yo dawg, I heard you like Jira tickets...\n";

  response_string += jira_matcher.add_ticket_urls (message).toString();

  //response_string += "I hope that helps.\n";

  bot.reply(message, response_string);

});

/**
 * AN example of what could be:
 * Any un-handled direct mention gets a reaction and a pat response!
 */
controller.on("direct_message,mention,direct_mention", function(bot, message) {
  bot.api.reactions.add(
    {
      timestamp: message.ts,
      channel: message.channel,
      name: "robot_face"
    },
    function(err) {
      if (err) {
        console.log(err);
      }
      bot.reply(
        message,
        "Flexibot is a product of Kungfulinux, Inc. Please contact djacobs@flexion.us for changes.  He accepts Pull Requests"
      );
    }
  );
});

controller.middleware.receive.use(function(bot, message, next) {
  console.log("RECEIVED: ", message);
  message.logged = true;
  next();
});
controller.middleware.send.use(function(bot, message, next) {
  console.log("SENT: ", message);
  message.logged = true;
  next();
});