Upload 7 files

includes/handle/handleCommand.js

@@ -0,0 +1,311 @@
+let activeCmd = false;
+
+module.exports = function ({ api, models, Users, Threads, Currencies, ...rest }) {
+  const stringSimilarity = require("string-similarity");
+  const moment = require("moment-timezone");
+  const logger = require("../../utils/log");
+
+  return async function ({ event, ...rest2 }) {
+    if (activeCmd) {
+      return;
+    }
+
+    const dateNow = Date.now();
+    const time = moment.tz("Asia/Manila").format("HH:MM:ss DD/MM/YYYY");
+    const { allowInbox, PREFIX, ADMINBOT, DeveloperMode, adminOnly } = global.config;
+    const { userBanned, threadBanned, threadInfo, threadData, commandBanned } = global.data;
+    const { commands, cooldowns } = global.client;
+
+    var { body, senderID, threadID, messageID } = event;
+    var senderID = String(senderID),
+      threadID = String(threadID);
+
+    const threadSetting = threadData.get(threadID) || {};
+    const args = (body || "").trim().split(/ +/);
+    const commandName = args.shift()?.toLowerCase();
+    var command = commands.get(commandName);
+    const replyAD = "[ MODE ] - Only bot admin can use bot";
+
+    if (
+      command &&
+      command.config.name.toLowerCase() === commandName.toLowerCase() &&
+      !ADMINBOT.includes(senderID) &&
+      adminOnly &&
+      senderID !== api.getCurrentUserID()
+    ) {
+      return api.sendMessage(replyAD, threadID, messageID);
+    }
+
+    if (
+      typeof body === "string" &&
+      body.startsWith(PREFIX) &&
+      !ADMINBOT.includes(senderID) &&
+      adminOnly &&
+      senderID !== api.getCurrentUserID()
+    ) {
+      return api.sendMessage(replyAD, threadID, messageID);
+    }
+
+    if (
+      userBanned.has(senderID) ||
+      threadBanned.has(threadID) ||
+      (allowInbox == ![] && senderID == threadID)
+    ) {
+      if (!ADMINBOT.includes(senderID.toString())) {
+        if (userBanned.has(senderID)) {
+          const { reason, dateAdded } = userBanned.get(senderID) || {};
+          return api.sendMessage(
+            global.getText("handleCommand", "userBanned", reason, dateAdded),
+            threadID,
+            async (err, info) => {
+              await new Promise((resolve) => setTimeout(resolve, 5 * 1000));
+              return api.unsendMessage(info.messageID);
+            },
+            messageID,
+          );
+        } else {
+          if (threadBanned.has(threadID)) {
+            const { reason, dateAdded } = threadBanned.get(threadID) || {};
+            return api.sendMessage(
+              global.getText(
+                "handleCommand",
+                "threadBanned",
+                reason,
+                dateAdded,
+              ),
+              threadID,
+              async (err, info) => {
+                await new Promise((resolve) => setTimeout(resolve, 5 * 1000));
+                return api.unsendMessage(info.messageID);
+              },
+              messageID,
+            );
+          }
+        }
+      }
+    }
+
+    if (commandName.startsWith(PREFIX)) {
+      if (!command) {
+        const allCommandName = Array.from(commands.keys());
+        const checker = stringSimilarity.findBestMatch(
+          commandName,
+          allCommandName,
+        );
+        if (checker.bestMatch.rating >= 0.5) {
+          command = commands.get(checker.bestMatch.target);
+        } else {
+          return     api.setMessageReaction("❓", event.messageID, () => {}, true);
+        }
+      }
+    }
+
+    if (commandBanned.get(threadID) || commandBanned.get(senderID)) {
+      if (!ADMINBOT.includes(senderID)) {
+        const banThreads = commandBanned.get(threadID) || [],
+          banUsers = commandBanned.get(senderID) || [];
+        if (banThreads.includes(command.config.name))
+          return api.sendMessage(
+            global.getText(
+              "handleCommand",
+              "commandThreadBanned",
+              command.config.name,
+            ),
+            threadID,
+            async (err, info) => {
+              await new Promise((resolve) => setTimeout(resolve, 5 * 1000));
+              return api.unsendMessage(info.messageID);
+            },
+            messageID,
+          );
+        if (banUsers.includes(command.config.name))
+          return api.sendMessage(
+            global.getText(
+              "handleCommand",
+              "commandUserBanned",
+              command.config.name,
+            ),
+            threadID,
+            async (err, info) => {
+              await new Promise((resolve) => setTimeout(resolve, 5 * 1000));
+              return api.unsendMessage(info.messageID);
+            },
+            messageID,
+          );
+      }
+    }
+
+    if (command && command.config && command.config.usePrefix !== undefined) {
+        command.config.usePrefix = command.config.usePrefix ?? true;
+    }
+
+    if (command && command.config) {
+      if (
+        command.config.usePrefix === false &&
+        commandName.toLowerCase() !== command.config.name.toLowerCase() &&
+        !command.config.allowPrefix
+      ) {
+        api.sendMessage(
+          global.getText("handleCommand", "notMatched", command.config.name),
+          event.threadID,
+          event.messageID,
+        );
+        return;
+      }
+      if (command.config.usePrefix === true && !body.startsWith(PREFIX)) {
+        return;
+      }
+    }
+
+    if (command && command.config) {
+      if (typeof command.config.usePrefix === "undefined") {
+        api.sendMessage(
+          global.getText("handleCommand", "noPrefix", command.config.name),
+          event.threadID,
+          event.messageID,
+        );
+        return;
+      }
+    }
+
+    if (
+      command &&
+      command.config &&
+      command.config.commandCategory &&
+      command.config.commandCategory.toLowerCase() === "nsfw" &&
+      !global.data.threadAllowNSFW.includes(threadID) &&
+      !ADMINBOT.includes(senderID)
+    )
+      return api.sendMessage(
+        global.getText("handleCommand", "threadNotAllowNSFW"),
+        threadID,
+        async (err, info) => {
+          await new Promise((resolve) => setTimeout(resolve, 5 * 1000));
+          return api.unsendMessage(info.messageID);
+        },
+        messageID,
+      );
+
+    var threadInfo2;
+    if (event.isGroup == !![])
+      try {
+        threadInfo2 =
+          threadInfo.get(threadID) || (await Threads.getInfo(threadID));
+        if (Object.keys(threadInfo2).length == 0) throw new Error();
+      } catch (err) {
+        logger.log(
+          global.getText("handleCommand", "cantGetInfoThread", "error"),
+        );
+      }
+
+    var permssion = 0;
+    var threadInfoo =
+      threadInfo.get(threadID) || (await Threads.getInfo(threadID));
+    const find = threadInfoo.adminIDs.find((el) => el.id == senderID);
+    if (ADMINBOT.includes(senderID.toString())) permssion = 2;
+    else if (!ADMINBOT.includes(senderID) && find) permssion = 1;
+    if (
+      command &&
+      command.config &&
+      command.config.hasPermssion &&
+      command.config.hasPermssion > permssion
+    ) {
+      return api.sendMessage(
+        global.getText(
+          "handleCommand",
+          "permissionNotEnough",
+          command.config.name,
+        ),
+        event.threadID,
+        event.messageID,
+      );
+    }
+
+    if (
+      command &&
+      command.config &&
+      !client.cooldowns.has(command.config.name)
+    ) {
+      client.cooldowns.set(command.config.name, new Map());
+    }
+
+    const timestamps =
+      command && command.config
+        ? client.cooldowns.get(command.config.name)
+        : undefined;
+
+    const expirationTime =
+      ((command && command.config && command.config.cooldowns) || 1) * 1000;
+
+    if (
+      timestamps &&
+      timestamps instanceof Map &&
+      timestamps.has(senderID) &&
+      dateNow < timestamps.get(senderID) + expirationTime
+    ) {
+      const cooldowns = ((timestamps.get(senderID) + expirationTime - dateNow) / 1000).toFixed(1);
+      return api.sendMessage(`The command "${command.config.name}" has been cooldown in ${cooldowns} seconds before you can use it again.`, event.threadID, event.messageID);
+    }
+
+    var getText2;
+    if (
+      command &&
+      command.languages &&
+      typeof command.languages === "object" &&
+      command.languages.hasOwnProperty(global.config.language)
+    )
+      getText2 = (...values) => {
+        var lang = command.languages[global.config.language][values[0]] || "";
+        for (var i = values.length; i > 0x2533 + 0x1105 + -0x3638; i--) {
+          const expReg = RegExp("%" + i, "g");
+          lang = lang.replace(expReg, values[i]);
+        }
+        return lang;
+      };
+    else getText2 = () => {};
+
+    try {
+      const Obj = {
+        ...rest,
+        ...rest2,
+        api: api,
+        event: event,
+        args: args,
+        models: models,
+        Users: Users,
+        Threads: Threads,
+        Currencies: Currencies,
+        permssion: permssion,
+        getText: getText2,
+      };
+
+      if (command && typeof command.run === "function") {
+        command.run(Obj);
+        timestamps.set(senderID, dateNow);
+
+        if (DeveloperMode == !![]) {
+          logger.log(
+            global.getText(
+              "handleCommand",
+              "executeCommand",
+              time,
+              commandName,
+              senderID,
+              threadID,
+              args.join(" "),
+              Date.now() - dateNow,
+            ),
+            "DEV MODE",
+          );
+        }
+        return;
+      }
+    } catch (e) {
+      return api.sendMessage(
+        global.getText("handleCommand", "commandError", commandName, e),
+        threadID,
+      );
+    }
+    activeCmd = false;
+  };
+};

includes/handle/handleCommandEvent.js

@@ -0,0 +1,47 @@
+module.exports = function ({ api, models, Users, Threads, Currencies, ...rest }) {
+    const logger = require("../../utils/log.js")
+    return function ({ event, ...rest2 }) {
+        const { allowInbox } = global.config;
+        const { userBanned, threadBanned } = global.data;
+        const { commands, eventRegistered } = global.client;
+        var { senderID, threadID } = event;
+        var senderID = String(senderID);
+        var threadID = String(threadID);
+        if (userBanned.has(senderID) || threadBanned.has(threadID) || allowInbox == !![] && senderID == threadID) return;
+        for (const eventReg of eventRegistered) {
+            const cmd = commands.get(eventReg);
+            var getText2;
+
+            if (cmd.languages && typeof cmd.languages == 'object') 
+                getText2 = (...values) => {
+                const commandModule = cmd.languages || {};
+                if (!commandModule.hasOwnProperty(global.config.language)) 
+                    return api.sendMessage(global.getText('handleCommand','notFoundLanguage', cmd.config.name), threadID, messengeID); 
+                var lang = cmd.languages[global.config.language][values[0]] || '';
+                for (var i = values.length; i > 0x16c0 + -0x303 + -0x1f * 0xa3; i--) {
+                    const expReg = RegExp('%' + i, 'g');
+                    lang = lang.replace(expReg, values[i]);
+                }
+                return lang;
+            };
+            else getText2 = () => {};
+            try {
+                const Obj = {
+                    ...rest,
+                    ...rest2
+                };
+                Obj.event = event 
+                Obj.api = api
+                Obj.models = models
+                Obj.Users = Users
+                Obj.Threads = Threads 
+                Obj.Currencies = Currencies 
+                Obj.getText = getText2;
+                
+                if (cmd) cmd.handleEvent(Obj);
+            } catch (error) {
+                logger.log(global.getText('handleCommandEvent', 'moduleError', cmd.config.name), 'error');
+            }
+        }
+    };
+};

includes/handle/handleCreateDatabase.js

@@ -0,0 +1,38 @@
+module.exports = function ({ Users, Threads }) {
+    const logger =require("../../utils/log.js");
+    const threads = require('../database/data/threadsData.json')
+    const users = require('../database/data/usersData.json')
+    return async function ({ event }) {
+        const { allUserID, allThreadID } = global.data; 
+        const { autoCreateDB } = global.config;
+        if (autoCreateDB == ![]) return;
+        var { senderID, threadID } = event;
+        senderID = String(senderID);
+        var threadID = String(threadID);
+        try {
+            if (!allThreadID.includes(threadID) && event.isGroup == !![] && !threads.hasOwnProperty(threadID)) {
+                allThreadID.push(threadID)
+                await Threads.createData(threadID);
+                logger.log(global.getText('handleCreateDatabase', 'newThread', threadID), 'DATABASE');
+            }
+            if(threads.hasOwnProperty(threadID)) {
+                var data = threads[threadID]
+                if(data) {
+                    if(!data.threadInfo.participantIDs.includes(senderID)) {
+                        data.threadInfo.participantIDs.push(senderID)
+                        logger.log('Perform more group data ' + threadID, 'ADD DATA')
+                        await Threads.setData(threadID, {threadInfo: data.threadInfo})
+                    }
+                }
+            }
+            if (!allUserID.includes(senderID) && !users.hasOwnProperty(senderID)) {
+                allUserID.push(senderID)
+                await Users.createData(senderID)
+                logger.log(global.getText('handleCreateDatabase', 'newUser', senderID), 'DATABASE');
+            }
+            return;
+        } catch (err) {
+            return console.log(err);
+        }
+    };
+}

includes/handle/handleEvent.js

@@ -0,0 +1,38 @@
+module.exports = function ({api ,models, Users, Threads, Currencies, ...rest }) {
+    const logger = require("../../utils/log.js");
+   	const moment = require("moment");
+    return function ({ event, ...rest2 }) {
+        const timeStart = Date.now()
+        const time = moment.tz("Asia/Manila").format("HH:MM:ss L");
+        const { userBanned, threadBanned } = global.data;
+        const { events } = global.client;
+        const { allowInbox, DeveloperMode } = global.config;
+        var { senderID, threadID } = event;
+        senderID = String(senderID);
+        threadID = String(threadID);
+        if (userBanned.has(senderID)|| threadBanned.has(threadID) || allowInbox == ![] && senderID == threadID) return;
+        for (const [key, value] of events.entries()) {
+            if (value.config.eventType.indexOf(event.logMessageType) !== -1) {
+                const eventRun = events.get(key);
+                try {
+                    const Obj = {
+                        ...rest,
+                        ...rest2
+                    };
+                    Obj.api = api
+                    Obj.event = event
+                    Obj.models= models 
+                    Obj.Users= Users 
+                    Obj.Threads = Threads
+                    Obj.Currencies = Currencies 
+                    eventRun.run(Obj);
+                    if (DeveloperMode == !![]) 
+                    	logger.log(global.getText('handleEvent', 'executeEvent', time, eventRun.config.name, threadID, Date.now() - timeStart), 'Event');
+                } catch (error) {
+                    logger.log(global.getText('handleEvent', 'eventError', eventRun.config.name, JSON.stringify(error)), "error");
+                }
+            }
+        }
+        return;
+    };
+}

includes/handle/handleReaction.js

@@ -0,0 +1,47 @@
+module.exports = function ({ api, models, Users, Threads, Currencies, ...rest }) {
+    return function ({ event, ...rest2 }) {
+        const { handleReaction, commands } = global.client;
+        const { messageID, threadID } = event;
+        if (handleReaction.length !== 0) {
+            const indexOfHandle = handleReaction.findIndex(e => e.messageID == messageID);
+            if (indexOfHandle < 0) return;
+            const indexOfMessage = handleReaction[indexOfHandle];
+            const handleNeedExec = commands.get(indexOfMessage.name);
+
+            if (!handleNeedExec) return api.sendMessage(global.getText('handleReaction', 'missingValue'), threadID, messageID);
+            try {
+                var getText2;
+                if (handleNeedExec.languages && typeof handleNeedExec.languages == 'object') 
+                	getText2 = (...value) => {
+                    const react = handleNeedExec.languages || {};
+                    if (!react.hasOwnProperty(global.config.language)) 
+                    	return api.sendMessage(global.getText('handleCommand', 'notFoundLanguage', handleNeedExec.config.name), threadID, messageID);
+                    var lang = handleNeedExec.languages[global.config.language][value[0]] || '';
+                    for (var i = value.length; i > 0x2 * -0xb7d + 0x2111 * 0x1 + -0xa17; i--) {
+                        const expReg = RegExp('%' + i, 'g');
+                        lang = lang.replace(expReg, value[i]);
+                    }
+                    return lang;
+                };
+                else getText2 = () => {};
+                const Obj = {
+                    ...rest,
+                    ...rest2
+                };
+                Obj.api= api 
+                Obj.event = event 
+                Obj.models = models
+                Obj.Users = Users
+                Obj.Threads = Threads
+                Obj.Currencies = Currencies
+                Obj.handleReaction = indexOfMessage
+                Obj.models= models 
+                Obj.getText = getText2
+                handleNeedExec.handleReaction(Obj);
+                return;
+            } catch (error) {
+                return api.sendMessage(global.getText('handleReaction', 'executeError', error), threadID, messageID);
+            }
+        }
+    };
+};

includes/handle/handleRefresh.js

@@ -0,0 +1,66 @@
+/**
+ * @author D-Jukie
+ * @warn Do not edit code or edit credits
+ * @src Disme Project
+ * @bug fixed by @YanMaglinte
+ */
+module.exports = function ({ api, Threads }) {
+    const logger = require("../../utils/log.js");
+    return async function ({ event }) {
+        const { threadID, logMessageType, logMessageData } = event;
+        const { setData, getData, delData } = Threads;
+        try {
+            let dataThread = (await getData(threadID)).threadInfo;
+            switch (logMessageType) {
+                case "log:thread-admins": {
+                    if (logMessageData.ADMIN_EVENT == "add_admin") {
+                        dataThread.adminIDs.push({
+                            id: logMessageData.TARGET_ID
+                        })
+                    } else if (logMessageData.ADMIN_EVENT == "remove_admin") {
+                        dataThread.adminIDs = dataThread.adminIDs.filter(item => item.id != logMessageData.TARGET_ID);
+                    }
+                    logger.log('Refresh the list of admins in the group ' + threadID, 'UPDATE DATA')
+                    await setData(threadID, { threadInfo: dataThread });
+                    break;
+                }
+                case "log:thread-name": {
+                    logger.log('Update name in group ' + threadID, 'UPDATE DATA')
+                    dataThread.threadName = event.logMessageData.name
+                    await setData(threadID, { threadInfo: dataThread });
+                    break;
+                }
+                case "log:subscribe": {
+                    if (event.logMessageData.addedParticipants.some(i => i.userFbId == api.getCurrentUserID())) return
+                    for(let i of event.logMessageData.addedParticipants) {
+                        dataThread.participantIDs.push(i.userFbId)
+                    }
+                    var data = await Threads.setData(event.threadID, {threadInfo: dataThread})
+                    logger.log('Perform more group data ' + threadID, 'ADD DATA')
+                    break;
+                }
+                case 'log:unsubscribe': {
+                    if (logMessageData.leftParticipantFbId == api.getCurrentUserID()) {
+                        logger.log('Perform group data deletion ' + threadID, 'DELETE DATA')
+                        const index = global.data.allThreadID.findIndex(item => item == threadID);
+                        global.data.allThreadID.splice(index, 1);
+                        await delData(threadID);
+                        return
+                    } else {
+                        const index = dataThread.participantIDs.findIndex(item => item == logMessageData.leftParticipantFbId);
+                        dataThread.participantIDs.splice(index, 1);
+                        if (dataThread.adminIDs.find(i => i.id == logMessageData.leftParticipantFbId)) {
+                            dataThread.adminIDs = dataThread.adminIDs.filter(item => item.id != logMessageData.leftParticipantFbId);
+                        }
+                        logger.log('Perform user deletion ' + logMessageData.leftParticipantFbId, 'DELETE DATA')
+                        await setData(threadID, { threadInfo: dataThread });
+                    }
+                    break;
+                }
+            }
+        } catch (e) {
+            console.log('There was an error updating data: ' + e)
+        }
+        return;
+    };
+}

includes/handle/handleReply.js

@@ -0,0 +1,47 @@
+module.exports = function ({ api, models, Users, Threads, Currencies, ...rest }) {
+    return function ({ event, ...rest2 }) {
+        if (!event.messageReply) return;
+        const { handleReply, commands } = global.client
+        const { messageID, threadID, messageReply } = event;
+        if (handleReply.length !== 0) {
+            const indexOfHandle = handleReply.findIndex(e => e.messageID == messageReply.messageID);
+            if (indexOfHandle < 0) return;
+            const indexOfMessage = handleReply[indexOfHandle];
+            const handleNeedExec = commands.get(indexOfMessage.name);
+            if (!handleNeedExec) return api.sendMessage(global.getText('handleReply', 'missingValue'), threadID, messageID);
+            try {
+                var getText2;
+                if (handleNeedExec.languages && typeof handleNeedExec.languages == 'object') 
+                	getText2 = (...value) => {
+                    const reply = handleNeedExec.languages || {};
+                    if (!reply.hasOwnProperty(global.config.language)) 
+                    	return api.sendMessage(global.getText('handleCommand', 'notFoundLanguage', handleNeedExec.config.name), threadID, messageID);
+                    var lang = handleNeedExec.languages[global.config.language][value[0]] || '';
+                    for (var i = value.length; i > -0x4 * 0x4db + 0x6d * 0x55 + -0x597 * 0x3; i--) {
+                        const expReg = RegExp('%' + i, 'g');
+                        lang = lang.replace(expReg, value[i]);
+                    }
+                    return lang;
+                };
+                else getText2 = () => {};
+                const Obj = {
+                    ...rest,
+                    ...rest2
+                };
+                Obj.api = api
+                Obj.event = event 
+                Obj.models = models
+                Obj.Users = Users
+                Obj.Threads = Threads 
+                Obj.Currencies = Currencies
+                Obj.handleReply = indexOfMessage
+                Obj.models = models
+                Obj.getText = getText2
+                handleNeedExec.handleReply(Obj);
+                return;
+            } catch (error) {
+                return api.sendMessage(global.getText('handleReply', 'executeError', error), threadID, messageID);
+            }
+        }
+    };
+}