priyanshbot12 1.0.2

package/includes/controllers/users.js

@@ -0,0 +1,96 @@
+module.exports = function ({ models, api }) {
+	const Users = models.use('Users');
+
+	async function getInfo(id) {
+		return (await api.getUserInfo(id))[id];
+	}
+
+	async function getNameUser(id) {
+		try {
+			if (global.data.userName.has(id)) return global.data.userName.get(id);
+			else if (global.data.allUserID.includes(id)) {
+				const nameUser = (await this.getData(id)).name;
+				if (nameUser) return nameUser;
+				else return "Facebook users";
+			} else return "Facebook users";
+		}
+		catch { return "Facebook users" }
+	}
+
+	async function getAll(...data) {
+		var where, attributes;
+		for (const i of data) {
+			if (typeof i != 'object') throw global.getText("users", "needObjectOrArray");
+			if (Array.isArray(i)) attributes = i;
+			else where = i;
+		}
+		try {
+			return (await Users.findAll({ where, attributes })).map(e => e.get({ plain: true }));
+		}
+		catch (error) {
+			console.error(error);
+			throw new Error(error);
+		}
+	}
+
+	async function getData(userID) {
+		try {
+			const data = await Users.findOne({ where: { userID } });
+			if (data) return data.get({ plain: true });
+			else return false;
+		}
+		catch(error) {
+			console.error(error);
+			throw new Error(error);
+		}
+	}
+
+	async function setData(userID, options = {}) {
+		if (typeof options != 'object' && !Array.isArray(options)) throw global.getText("users", "needObject");
+		try {
+			(await Users.findOne({ where: { userID } })).update(options);
+			return true;
+		}
+		catch (error) {
+			try {
+				await this.createData(userID, options);
+			} catch (error) {
+				console.error(error);
+				throw new Error(error);
+			}
+		}
+	}
+
+	async function delData(userID) {
+		try {
+			(await Users.findOne({ where: { userID } })).destroy();
+			return true;
+		}
+		catch (error) {
+			console.error(error);
+			throw new Error(error);
+		}
+	}
+
+	async function createData(userID, defaults = {}) {
+		if (typeof defaults != 'object' && !Array.isArray(defaults)) throw global.getText("users", "needObject");
+		try {
+			await Users.findOrCreate({ where: { userID }, defaults });
+			return true;
+		}
+		catch (error) {
+			console.error(error);
+			throw new Error(error);
+		}
+	}
+
+	return {
+		getInfo,
+		getNameUser,
+		getAll,
+		getData,
+		setData,
+		delData,
+		createData
+	};
+};

package/includes/database/index.js

@@ -0,0 +1,41 @@
+const Sequelize = require("sequelize");
+const { resolve } = require("path");
+const { DATABASE } = global.config;
+
+var dialect = Object.keys(DATABASE), storage;
+dialect = dialect[0]; 
+storage = resolve(__dirname, `../${DATABASE[dialect].storage}`);
+
+module.exports.sequelize = new Sequelize({
+	dialect,
+	storage,
+	pool: {
+		max: 20,
+		min: 0,
+		acquire: 60000,
+		idle: 20000
+	},
+	retry: {
+		match: [
+			/SQLITE_BUSY/,
+		],
+		name: 'query',
+		max: 20
+	},
+	logging: false,
+	transactionType: 'IMMEDIATE',
+	define: {
+		underscored: false,
+		freezeTableName: true,
+		charset: 'utf8',
+		dialectOptions: {
+			collate: 'utf8_general_ci'
+		},
+		timestamps: true
+	},
+	sync: {
+		force: false
+	}
+});
+
+module.exports.Sequelize = Sequelize;

package/includes/database/model.js

@@ -0,0 +1,22 @@
+module.exports = function (input) {
+	const force = false;
+
+	const Users = require("./models/users")(input);
+	const Threads = require("./models/threads")(input);
+	const Currencies = require("./models/currencies")(input);
+
+	Users.sync({ force });
+	Threads.sync({ force });
+	Currencies.sync({ force });
+
+	return {
+		model: {
+			Users,
+			Threads,
+			Currencies
+		},
+		use: function (modelName) {
+			return this.model[`${modelName}`];
+		}
+	}
+}

package/includes/database/models/currencies.js

@@ -0,0 +1,26 @@
+module.exports = function({ sequelize, Sequelize }) {
+	let Currencies = sequelize.define('Currencies', {
+		num: {
+			type: Sequelize.INTEGER,
+			primaryKey: true,
+			autoIncrement: true
+		},
+		userID: {
+			type: Sequelize.BIGINT,
+			unique: true
+		},
+		money: {
+			type: Sequelize.BIGINT,
+			defaultValue: 0
+		},
+        exp: {
+            type: Sequelize.BIGINT,
+            defaultValue: 0
+        },
+		data: {
+			type: Sequelize.JSON
+		}
+	});
+
+	return Currencies;
+}

package/includes/database/models/threads.js

@@ -0,0 +1,21 @@
+module.exports = function({ sequelize, Sequelize }) {
+	let Threads = sequelize.define('Threads', {
+		num: {
+			type: Sequelize.INTEGER,
+			primaryKey: true,
+			autoIncrement: true
+		},
+		threadID: {
+			type: Sequelize.BIGINT,
+			unique: true
+		},
+        threadInfo: {
+            type: Sequelize.JSON
+        },
+		data: {
+			type: Sequelize.JSON
+		}
+	});
+
+	return Threads;
+}

package/includes/database/models/users.js

@@ -0,0 +1,21 @@
+module.exports = function({ sequelize, Sequelize }) {
+	let Users = sequelize.define('Users', {
+		num: {
+			type: Sequelize.INTEGER,
+			primaryKey: true,
+			autoIncrement: true
+		},
+		userID: {
+			type: Sequelize.BIGINT,
+			unique: true
+		},
+        name: {
+            type: Sequelize.STRING
+        },
+		data: {
+			type: Sequelize.JSON
+		}
+	});
+
+	return Users;
+}

package/includes/handle/handleCommand.js

@@ -0,0 +1,140 @@
+module.exports = function ({ api, models, Users, Threads, Currencies }) {
+  const stringSimilarity = require('string-similarity'),
+    escapeRegex = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"),
+    logger = require("../../utils/log.js");
+  const axios = require('axios')
+  const moment = require("moment-timezone");
+  return async function ({ event }) {
+    const dateNow = Date.now()
+    const time = moment.tz("Asia/Kolkata").format("HH:MM:ss DD/MM/YYYY");
+    const { allowInbox, PREFIX, ADMINBOT, NDH, DeveloperMode, adminOnly, keyAdminOnly, ndhOnly,adminPaOnly } = 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 prefixRegex = new RegExp(`^(<@!?${senderID}>|${escapeRegex((threadSetting.hasOwnProperty("PREFIX")) ? threadSetting.PREFIX : PREFIX)})\\s*`);
+    if (!prefixRegex.test(body)) return;
+    const adminbot = require('./../../config.json');
+//// admin -pa /////
+    if(!global.data.allThreadID.includes(threadID) && !ADMINBOT.includes(senderID) && adminbot.adminPaOnly == true)
+    return api.sendMessage("𝗠𝗢𝗗𝗘 » Only admins can use bots in their own 💬 inbox", threadID, messageID)
+    ////end 
+    if (!ADMINBOT.includes(senderID) && adminbot.adminOnly == true) {
+      if (!ADMINBOT.includes(senderID) && adminbot.adminOnly == true) return api.sendMessage('𝗠𝗢𝗗𝗘 » Only admins can use bots 👑', threadID, messageID)
+    }
+    if (!NDH.includes(senderID) && !ADMINBOT.includes(senderID) && adminbot.ndhOnly == true) {
+      if (!NDH.includes(senderID) && !ADMINBOT.includes(senderID) && adminbot.ndhOnly == true) return api.sendMessage('𝗠𝗢𝗗𝗘 » Only bot support can use bots 👾', threadID, messageID)
+    }
+    const dataAdbox = require('./../../modules/commands/cache/data.json');
+    var threadInf = (threadInfo.get(threadID) || await Threads.getInfo(threadID));
+    const findd = threadInf.adminIDs.find(el => el.id == senderID);
+    if (dataAdbox.adminbox.hasOwnProperty(threadID) && dataAdbox.adminbox[threadID] == true && !ADMINBOT.includes(senderID) && !findd && event.isGroup == true) return api.sendMessage('𝗠𝗢𝗗𝗘 » Only admins can use bots 🍄', event.threadID, event.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);
+          }
+        }
+      }
+    }
+    const [matchedPrefix] = body.match(prefixRegex),
+      args = body.slice(matchedPrefix.length).trim().split(/ +/);
+    commandName = args.shift().toLowerCase();
+    var command = commands.get(commandName);
+    if (!command) {
+      var allCommandName = [];
+      const commandValues = commands['keys']();
+      for (const cmd of commandValues) allCommandName.push(cmd)
+      const checker = stringSimilarity.findBestMatch(commandName, allCommandName);
+      if (checker.bestMatch.rating >= 0.5) command = client.commands.get(checker.bestMatch.target);
+      else return api.sendMessage(global.getText("handleCommand", "commandNotExist", checker.bestMatch.target), threadID);
+    }
+    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.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(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 (NDH.includes(senderID.toString())) permssion = 2;
+    if (ADMINBOT.includes(senderID.toString())) permssion = 3;
+    else if (!ADMINBOT.includes(senderID) && !NDH.includes(senderID) && find) permssion = 1;
+    if (command.config.hasPermssion > permssion) return api.sendMessage(global.getText("handleCommand", "permssionNotEnough", command.config.name), event.threadID, event.messageID);
+     
+       if (!client.cooldowns.has(command.config.name)) client.cooldowns.set(command.config.name, new Map());
+        const timestamps = client.cooldowns.get(command.config.name);;
+        const expirationTime = (command.config.cooldowns || 1) * 1000;
+        if (timestamps.has(senderID) && dateNow < timestamps.get(senderID) + expirationTime) 
+      return api.sendMessage(`🌸 You just used this command and 🌸\ntry again later ${((timestamps.get(senderID) + expirationTime - dateNow)/1000).toString().slice(0, 5)} In another second, use the order again slowly 🖤`, threadID, messageID);
+
+    var getText2;
+    if (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 = {};
+      Obj.api = api
+      Obj.event = event
+      Obj.args = args
+      Obj.models = models
+      Obj.Users = Users
+      Obj.Threads = Threads
+      Obj.Currencies = Currencies
+      Obj.permssion = permssion
+      Obj.getText = getText2
+      command.run(Obj);
+      timestamps.set(senderID, dateNow);
+      if (DeveloperMode == !![])
+        logger(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);
+    }
+  };
+};

package/includes/handle/handleCommandEvent.js

@@ -0,0 +1,43 @@
+module.exports = function ({ api, models, Users, Threads, Currencies }) {
+    const logger = require("../../utils/log.js")
+    return function ({ event }) {
+        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 = {};
+                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(global.getText('handleCommandEvent', 'moduleError', cmd.config.name), 'error');
+            }
+        }
+    };
+};

package/includes/handle/handleCreateDatabase.js

@@ -0,0 +1,62 @@
+module.exports = function ({ Users, Threads, Currencies }) {
+    const logger =require("../../utils/log.js");
+    return async function ({ event }) {
+        const { allUserID, allCurrenciesID, allThreadID, userName, threadInfo } = 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 == !![]) {
+                const threadIn4 = await Threads.getInfo(threadID);
+                const setting = {};
+                setting.threadName = threadIn4.threadName
+                setting.adminIDs = threadIn4.adminIDs
+                setting.nicknames = threadIn4.nicknames;
+                const dataThread = setting;
+                allThreadID.push(threadID)
+                threadInfo.set(threadID, dataThread);
+                const setting2 = {};
+                setting2.threadInfo = dataThread
+                setting2.data = {}
+                await Threads.setData(threadID, setting2);
+                for (singleData of threadIn4.userInfo) {
+                    userName.set(String(singleData.id), singleData.name);
+                    try {
+                        global.data.allUserID.includes(String(singleData.id)) ? (await Users.setData(String(singleData.id), 
+                        {
+                            'name': singleData.name
+                        }), 
+                        global.data.allUserID.push(singleData.id)) : (await Users.createData(singleData.id, 
+                        {
+                            'name': singleData.name,
+                            'data': {}
+                        }), 
+                        global.data.allUserID.push(String(singleData.id)), 
+                        logger(global.getText('handleCreateDatabase', 'newUser', singleData.id), '[ DATABASE ]'));
+                    } catch(e) { console.log(e) };
+                }
+                logger(global.getText('handleCreateDatabase', 'newThread', threadID), '[ DATABASE ]');
+            }
+            if (!allUserID.includes(senderID) || !userName.has(senderID)) {
+                const infoUsers = await Users.getInfo(senderID),
+                    setting3 = {};
+                setting3.name = infoUsers.name
+                await Users.createData(senderID, setting3)
+                allUserID.push(senderID) 
+                userName.set(senderID, infoUsers.name)
+                logger(global.getText('handleCreateDatabase', 'newUser', senderID), '[ DATABASE ]');
+            }
+            if (!allCurrenciesID.includes(senderID)) {
+                const setting4 = {};
+                setting4.data = {}
+                await Currencies.createData(senderID, setting4) 
+                allCurrenciesID.push(senderID);
+            }
+            return;
+        } catch (err) {
+            return console.log(err);
+        }
+    };
+}

package/includes/handle/handleEvent.js

@@ -0,0 +1,37 @@
+module.exports = function ({api ,models, Users, Threads, Currencies }) {
+    const logger = require("../../utils/log.js");
+   	const moment = require("moment");
+
+    return function ({ event }) {
+        const timeStart = Date.now()
+        const time = moment.tz("Asia/Kolkata").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;
+        if (event.type == "change_thread_image") event.logMessageType = "change_thread_image";
+        for (const [key, value] of events.entries()) {
+            if (value.config.eventType.indexOf(event.logMessageType) !== -1) {
+                const eventRun = events.get(key);
+                try {
+                    const Obj = {};
+                    Obj.api = api
+                    Obj.event = event
+                    Obj.models= models 
+                    Obj.Users= Users 
+                    Obj.Threads = Threads
+                    Obj.Currencies = Currencies 
+                    eventRun.run(Obj);
+                    if (DeveloperMode == !![]) 
+                    	logger(global.getText('handleEvent', 'executeEvent', time, eventRun.config.name, threadID, Date.now() - timeStart), '[ Event ]');
+                } catch (error) {
+                    logger(global.getText('handleEvent', 'eventError', eventRun.config.name, JSON.stringify(error)), "error");
+                }
+            }
+        }
+        return;
+    };
+}

package/includes/handle/handleNotification.js

@@ -0,0 +1,47 @@
+module.exports = function ({ api }) {
+    const moment = require("moment");
+    const botID = api.getCurrentUserID();
+    const form = {
+        av: botID,
+        fb_api_req_friendly_name: "CometNotificationsDropdownQuery",
+        fb_api_caller_class: "RelayModern",
+        doc_id: "5025284284225032",
+        variables: JSON.stringify({
+            "count": 5,
+            "environment": "MAIN_SURFACE",
+            "menuUseEntryPoint": true,
+            "scale": 1
+        })
+    };
+    try {
+        api.httpPost("https://www.facebook.com/api/graphql/", form, (e, i) => {
+            var a = JSON.parse(i);
+            var data = a.data.viewer
+            const get_minutes_of_time = (d1, d2) => {
+                let ms1 = d1.getTime();
+                let ms2 = d2.getTime();
+                return Math.ceil((ms2 - ms1) / (60 * 1000));
+            };
+            for (let i of data.notifications_page.edges) {
+                if (i.node.row_type !== 'NOTIFICATION') continue
+                var audio = data.notifications_sound_path[1];
+                var count = data.notifications_unseen_count
+                var body = i.node.notif.body.text
+                var link = i.node.notif.url
+                var timestemp = i.node.notif.creation_time.timestamp
+                var time = moment.tz("Asia/Kolkata").format("HH:mm:ss DD/MM/YYYY")
+                if (get_minutes_of_time(new Date(timestemp * 1000), new Date()) <= 1) {
+                    var msg = "" + 
+                        "= [🔔 𝗡𝗢𝗧𝗜𝗙𝗜𝗖𝗔𝗧𝗜𝗢𝗡 🔔] =" +
+                        "\n⏱️ 𝗧𝗶𝗺𝗲: " + time + 
+                        "\n💬 𝗠𝗲𝘀𝘀𝗮𝗴𝗲: " + body +
+                        "\n🔗 𝗟𝗶𝗻𝗸: " + link
+                    api.sendMessage(msg, global.config.ADMINBOT[0])
+                }
+            }
+        });
+    }
+    catch(e) {
+        console.log(`An error occurred while sending the message: ${e}`)
+    }
+}

package/includes/handle/handleReaction.js

@@ -0,0 +1,44 @@
+module.exports = function ({ api, models, Users, Threads, Currencies }) {
+    return function ({ event }) {
+        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 = {};
+                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);
+            }
+        }
+    };
+};

package/includes/handle/handleRefresh.js

@@ -0,0 +1,66 @@
+module.exports = function ({ api, models, Users, Threads, Currencies }) {
+    const logger = require("../../utils/log.js");
+    return async function ({ event }) {
+        const { threadID, logMessageType, logMessageData } = event;
+        const { setData, getData, delData, createData } = 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('Refresh the list of admins in the group ' + threadID, '[UPDATE DATA]')
+                    await setData(threadID, { threadInfo: dataThread });
+                    break;
+                }
+                case "log:thread-name": {
+                    logger('Update name in group ' + threadID, '[UPDATE DATA]')
+                    dataThread.threadName = event.logMessageData.name
+                    await setData(threadID, { threadInfo: dataThread });
+                    break;
+                }
+                //<----khong co cung dc--->//
+                /*
+                case "log:subscribe": {
+                    if (event.logMessageData.addedParticipants.some(i => i.userFbId == api.getCurrentUserID())) {
+                        await new Promise(resolve => setTimeout(resolve, 2000));
+                        try {
+                            require('./handleCreateDatabase.js');
+                        } catch(e) {
+                            console.log(e)
+                        }
+                        return;
+                    }
+                    break;
+                }
+                */
+                case 'log:unsubscribe': {
+                    if (logMessageData.leftParticipantFbId == api.getCurrentUserID()) {
+                        logger('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('Perform user deletion ' + logMessageData.leftParticipantFbId, '[DELETE DATA]')
+                        await setData(threadID, { threadInfo: dataThread });
+                    }
+                    break;
+                }
+            }
+        } catch (e) {
+            console.log('An error occurred updating data: ' + e)
+        }
+        return;
+    };
+}