Made a lot of things

src/cmd/debug.js

@@ -7,5 +7,12 @@ exports.loadModule = function loadModule () {
   });
   commandH.endpoint('^ping (.*)$', (match, message) => {
     bot.createMessage(message.channel.id, 'Pong : ' + match[1]);
+    let time = new Date();
+    bot.once('messageCreate', (msg) => {
+      let ms = new Date().getTime() - time.getTime();
+      if (msg.channel !== message.channel) return;
+      if (msg.author !== bot.user) return;
+      bot.createMessage(msg.channel.id, ms + ' ms');
+    });
   });
-}
+};

src/cmd/events.js

@@ -0,0 +1,6 @@
+const commandH = require('../commandHandler');
+const bot = require('../botClient').bot;
+
+exports.loadModule = function loadModule () {
+
+};

src/cmd/main.js

@@ -0,0 +1,72 @@
+const commandH = require('../commandHandler');
+const bot = require('../botClient').bot;
+const dbEI = require('../dbEventInterface');
+
+exports.loadModule = function loadModule () {
+  commandH.endpoint('^(?:init|set)serv$', async (match, message) => {
+    if (!message.member.permission.has('administrator')) return;
+    try {
+      await dbEI.initServer(message.channel.guild.id, message.channel.id);
+      bot.createMessage(message.channel.id, 'Server successfully set');
+    }
+    catch(e) {
+      console.log(e);
+      bot.createMessage(message.channel.id, 'An error happened');
+    }
+  });
+  commandH.endpoint('^debugserv$', async (match, message) => {
+    dbEI.debugServer(message.channel.guild.id);
+  });
+  commandH.endpoint('^set-channel(?: <#(.+?)>)?$', async (match, message) => {
+    let channelId = message.channel.id;
+    if (match[1]) {
+      channelId = match[1];
+    }
+    // TODO: Check if the set channel is in this guild
+    dbEI.setFallbackChannel(message.channel.guild.id, channelId);
+    bot.createMessage(message.channel.id, 'Fallback set to that channel, all the event logging will be done there by default. A message will be sent in that channel to make sure it is correct.');
+    bot.createMessage(channelId, `<@${message.author.id}>, this is now the fallback channel.`);
+  });
+  commandH.endpoint('^event(?:-set)? (.+) msg (.+)$', async (match, message) => {
+    dbEI.setEventMsg(message.channel.guild.id, match[1], match[2]);
+    bot.createMessage(message.channel.id, 'Event message set');
+  });
+  commandH.endpoint('^event(?:-set)? (.+) channel(?: (?:<#(.+?)>|(fallback|f)))?$', async (match, message) => {
+    let channelId = message.channel.id;
+    if (match[2]) {
+      channelId = match[2];
+    }
+    else if (match[3]) {
+      channelId = 'f';
+    }
+    dbEI.setEventChannel(message.channel.guild.id, match[1], channelId);
+    if (channelId === 'f') {
+      bot.createMessage(message.channel.id, 'This event\'s channel has been set to the **fallback channel**');
+    }
+    else {
+      bot.createMessage(message.channel.id, `Event channel set to <#${channelId}>. The fallback channel for that even has been overriden. To bind again the event to the fallback channel, execute \`event ${match[1]} channel fallback\``);
+    }
+  });
+  commandH.endpoint('^event(-set)? (.+) (.+)$', async (match, message) => {
+    let newState = true;
+    if (match[3]) {
+      if (match[3] === 'enable' || match[3] === 'true') {
+        newState = true;
+      }
+      else if (match[3] === 'disable' || match[3] === 'false') {
+        newState = false;
+      }
+      else {
+        bot.createMessage(message.channel.id, `Invalid option, the possibilities are : \`event${match[1] ? match[1] : ''} ${match[2]} (enable|true|disable|false)\``);
+        return;
+      }
+    }
+    dbEI.setEventEnable(message.channel.guild.id, match[2], newState);
+    if (newState) {
+      bot.createMessage(message.channel.id, `Event ${match[2]} has been **enabled**`);
+    }
+    else {
+      bot.createMessage(message.channel.id, `Event ${match[2]} has been **disabled**`);
+    }
+  });
+};

src/dbEventInterface.js

@@ -0,0 +1,225 @@
+const level = require('level');
+const zlib = require('zlib');
+
+let db = level('./logoriDB'); // Make that path customizable
+
+function put(key, value) {
+  return new Promise((resolve, reject) => {
+    db.put(key, value, (err) => {
+      if (err) {
+        reject(err);
+        return;
+      }
+      resolve();
+    });
+  });
+}
+
+function get(key) {
+  return new Promise((resolve, reject) => {
+    db.get(key, (err, value) => {
+      if (err) {
+        reject(err);
+        return;
+      }
+      resolve(value);
+    });
+  });
+}
+
+function deflateObj(obj) {
+  let text = JSON.stringify(obj);
+  let compressed = zlib.deflateSync(text).toString('base64');
+  return compressed;
+}
+
+function inflateObj(str) {
+  let bufferCompressed = new Buffer(str, 'base64');
+  let text = zlib.inflateSync(bufferCompressed).toString();
+  return JSON.parse(text);
+}
+
+/*  const eventsInfoDefault = {
+  doChannelCreate: true,
+  channelCreateMsg: '',
+  doChannelDelete: true,
+  channelDeleteMsg: '',
+  doChannelPinUpdate: true,
+  channelPinUpdateMsg: '',
+  doChannelUpdate: true,
+  channelUpdateMsg: '',
+  doGuildBanAdd: true,
+  guildBanAddMsg: '',
+  doGuildBanRemove: true,
+  guildBanRemoveMsg: '',
+  doGuildEmojisUpdate: true,
+  guildEmojisUpdateMsg: '',
+  doGuildMemberAdd: true,
+  guildMemberAddMsg: '',
+  doGuildMemberRemove: true,
+  guildMemberRemoveMsg: '',
+  doGuildMemberUpdate: true,
+  guildMemberUpdateMsg: '',
+  doGuildRoleCreate: true,
+  guildRoleCreateMsg: '',
+};  */
+
+exports.initServer = function initServer(id, cId) {
+  let obj = {
+    fallbackChannelId: cId,
+    eventsInfo: {
+      channelCreate: {
+        d: true,
+        msg: '',
+        c: 'f',
+      },
+      channelDelete: {
+        d: true,
+        msg: '',
+        c: 'f',
+      },
+      channelPinUpdate: {
+        d: true,
+        msg: '',
+        c: 'f',
+      },
+      channelUpdate: {
+        d: true,
+        msg: '',
+        c: 'f',
+      },
+      guildBanAdd: {
+        d: true,
+        msg: '',
+        c: 'f',
+      },
+      guildBanRemove: {
+        d: true,
+        msg: '',
+        c: 'f',
+      },
+      guildEmojisUpdate: {
+        d: true,
+        msg: '',
+        c: 'f',
+      },
+      guildMemberAdd: {
+        d: true,
+        msg: '',
+        c: 'f',
+      },
+      guildMemberRemove: {
+        d: true,
+        msg: '',
+        c: 'f',
+      },
+      guildMemberUpdate: {
+        d: true,
+        msg: '',
+        c: 'f',
+      },
+      guildRoleCreate: {
+        d: true,
+        msg: '',
+        c: 'f',
+      },
+      guildRoleDelete: {
+        d: true,
+        msg: '',
+        c: 'f',
+      },
+      guildRoleUpdate: {
+        d: true,
+        msg: '',
+        c: 'f',
+      },
+      guildUpdate: {
+        d: true,
+        msg: '',
+        c: 'f',
+      },
+      messageDelete: {
+        d: true,
+        msg: '',
+        c: 'f',
+      },
+      messageReactionAdd: {
+        d: true,
+        msg: '',
+        c: 'f',
+      },
+      messageReactionRemove: {
+        d: true,
+        msg: '',
+        c: 'f',
+      },
+      messageUpdate: {
+        d: true,
+        msg: '',
+        c: 'f',
+      },
+      presenceUpdate: {
+        d: true,
+        msg: '',
+        c: 'f',
+      },
+      presenceUpdate: {
+        d: true,
+        msg: '',
+        c: 'f',
+      },
+    },
+  };
+  return put(id, deflateObj(obj));
+};
+
+exports.isAlreadyInitted = async function isAlreadyInitted (id) {
+  try {
+    await get(id);
+    return true;
+  }
+  catch(e) {
+    return false;
+  }
+};
+
+exports.debugServer = async function debugServer (id) {
+  console.log(inflateObj(await get(id)));
+}
+
+exports.getEvent = async function getEvent(id, eventName) {
+  let serverEvents = await get(id);
+  let obj = inflateObj(serverEvents);
+  return {
+    fallbackChannelId: obj.fallbackChannelId,
+    event: obj.eventsInfo[eventName],
+  };
+};
+
+exports.setFallbackChannel = async function setFallbackChannel(id, cId) {
+  let serverEvents = await get(id);
+  let obj = inflateObj(serverEvents);
+  obj.fallbackChannelId = cId;
+  return put(id, deflateObj(obj));
+};
+
+exports.setEventMsg = async function setEventMsg(id, eventName, msg) {
+  let serverEvents = await get(id);
+  let obj = inflateObj(serverEvents);
+  obj.eventsInfo[eventName].msg = msg;
+  return put(id, deflateObj(obj));
+};
+
+exports.setEventChannel = async function setEventChannel(id, eventName, cId) {
+  let serverEvents = await get(id);
+  let obj = inflateObj(serverEvents);
+  obj.eventsInfo[eventName].c = cId;
+  return put(id, deflateObj(obj));
+};
+
+exports.setEventEnable = async function setEventChannel(id, eventName, state) {
+  let serverEvents = await get(id);
+  let obj = inflateObj(serverEvents);
+  obj.eventsInfo[eventName].d = state;
+  return put(id, deflateObj(obj));
+};

src/dbManager.js

@@ -1,24 +0,0 @@
-const sequelize = require('sequelize');
-
-const database = new sequelize('database', 'user', 'password', {
-  operatorsAliases: false,
-  dialect: 'sqlite',
-  logging: false,
-  storage: 'logoriDB.sqlite',
-});
-
-const server = database.define('server', {
-  discordId: {
-    type: sequelize.STRING,
-    unique: true,
-  },
-  logChannelId: sequelize.STRING,
-}, {
-  timestamps: false,
-});
-
-module.exports.sync = function sync(opt) {
-  return database.sync(opt);
-};
-
-module.exports.server = server;