Upload 3 files

includes/database/currencies.js

@@ -0,0 +1,96 @@
+module.exports = function ({ models, Users }) {
+	const { readFileSync, writeFileSync } = require("fs-extra");
+	var path = __dirname + "/data/usersData.json";
+    try {
+        var Currencies = require(path)
+    } catch {
+        writeFileSync(path, "{}", { flag: 'a+' });
+    }
+
+	async function saveData(data) {
+        try {
+            if (!data) throw new Error('Data cannot be left blank');
+            writeFileSync(path, JSON.stringify(data, null, 4))
+            return true
+        } catch (error) {
+            return false
+        }
+    }
+	async function getData(userID) {
+		try {
+			if (!userID) throw new Error("User ID cannot be blank");
+            if (isNaN(userID)) throw new Error("Invalid user ID");
+            if (!userID) throw new Error("userID cannot be empty");
+            if (!Currencies.hasOwnProperty(userID)) console.log(`User ID: ${userID} does not exist in Database`);
+			const data = await Users.getData(userID);
+			return data
+		} 
+		catch (error) {
+			console.log(error)
+			return false
+		};
+	}
+
+	async function setData(userID, options = {}) {
+		try {
+            if (!userID) throw new Error("User ID cannot be blank");
+            if (isNaN(userID)) throw new Error("Invalid user ID");
+            if (!userID) throw new Error("userID cannot be empty");
+            if (!Currencies.hasOwnProperty(userID)) throw new Error(`User ID: ${userID} does not exist in Database`);
+            if (typeof options != 'object') throw new Error("The options parameter passed must be an object");
+            Currencies[userID] = {...Currencies[userID], ...options};
+            await saveData(Currencies);
+            return Currencies[userID];
+        } catch (error) {
+            return false
+        }
+	}
+
+	async function delData(userID, callback) {
+		try {
+            if (!userID) throw new Error("User ID cannot be blank");
+            if (isNaN(userID)) throw new Error("Invalid user ID");
+            if (!usersData.hasOwnProperty(userID)) throw new Error(`User ID: ${userID} does not exist in Database`);
+            usersData[userID].money = 0;
+            await saveData(usersData);
+            if (callback && typeof callback == "function") callback(null, usersData);
+            return usersData;
+        } catch (error) {
+            if (callback && typeof callback == "function") callback(error, null);
+            return false
+        }
+	}
+
+	async function increaseMoney(userID, money) {
+		if (typeof money != 'number') throw global.getText("currencies", "needNumber");
+		try {
+			let balance = (await getData(userID)).money;
+			await setData(userID, { money: balance + money });
+			return true;
+		}
+		catch (error) {
+			console.error(error);
+			throw new Error(error);
+		}
+	}
+
+	async function decreaseMoney(userID, money) {
+		if (typeof money != 'number') throw global.getText("currencies", "needNumber");
+		try {
+			let balance = (await getData(userID)).money;
+			if (balance < money) return false;
+			await setData(userID, { money: balance - money });
+			return true;
+		} catch (error) {
+			throw new Error(error);
+		}
+	}
+
+	return {
+		getData,
+		setData,
+		delData,
+		increaseMoney,
+		decreaseMoney
+	};
+};

includes/database/threads.js

@@ -0,0 +1,161 @@
+module.exports = function ({ api }) {
+    const Users = require("./users")({ api });
+    const logger =require("../../utils/log.js");
+    const { writeFileSync, readFileSync } = require("fs-extra");
+    var path = __dirname + "/data/threadsData.json";
+
+    try {
+        var threadsData = require(path)
+    } catch {
+        writeFileSync(path, "{}", { flag: 'a+' });
+    }
+
+    async function getInfo(threadID) {
+        try {
+            const result = await api.getThreadInfo(threadID);
+            return result;
+        }
+        catch (error) { 
+            throw new Error(error);
+            return false
+        };
+    }
+
+    async function getData(threadID, callback) {
+        try {
+            if (!threadID) throw new Error("threadID cannot be empty");
+            if (isNaN(threadID)) throw new Error("Invalid threadID");
+            if (!threadsData.hasOwnProperty(threadID)) await createData(threadID);
+            const data = threadsData[threadID];
+            if (callback && typeof callback == "function") callback(null, data);
+            return data;
+        } catch (error) {
+            if (callback && typeof callback == "function") callback(error, null);
+            return false
+        }
+    }
+
+    async function saveData(data) {
+        try {
+            if (!data) throw new Error('Data cannot be left blank');
+            writeFileSync(path, JSON.stringify(data, null, 4))
+        } catch (error) {
+            return false
+        }
+    }
+    async function getAll(keys, callback) {
+        try {
+            if (!keys) {
+                if (Object.keys(threadsData).length == 0) return [];
+                else if (Object.keys(threadsData).length > 0) {
+                    var db = [];
+                    for (var i of Object.keys(threadsData)) db.push(threadsData[i]);
+                    return db;
+                }
+            }
+            if (!Array.isArray(keys)) throw new Error("The input parameter must be an array");
+            const data = [];
+            for (var ID in threadsData) {
+                const database = {
+                    ID: ID
+                };
+                const threadData = threadsData[ID];
+                for (var i of keys) database[i] = threadData[i];
+                data.push(database);
+            }
+            if (callback && typeof callback == "function") callback(null, data);
+            return data;
+        } catch (error) {
+            if (callback && typeof callback == "function") callback(error, null);
+            return false
+        }
+    }
+    async function setData(threadID, options, callback) {
+        try {
+            if (!threadID) throw new Error("threadID cannot be empty");
+            if (isNaN(threadID)) throw new Error("Invalid threadID");
+            if (!threadsData.hasOwnProperty(threadID)) throw new Error(`Threads with ID: ${threadID} does not exist in Database`);
+            if (typeof options != 'object') throw new Error("The options parameter passed must be an object");
+            threadsData[threadID] = {
+                ...threadsData[threadID],
+                ...options
+            }
+            await saveData(threadsData);
+            if (callback && typeof callback == "function") callback(null, threadsData[threadID]);
+            return threadsData[threadID];
+        }
+        catch(error) {
+            if (callback && typeof callback == "function") callback(error, null);
+            return false
+        }
+    }
+
+    async function delData(threadID, callback) {
+        try {
+            if (!threadID) throw new Error("threadID cannot be empty");
+            if (isNaN(threadID)) throw new Error("Invalid threadID");
+            if (!threadsData.hasOwnProperty(threadID)) throw new Error(`Threads with ID: ${threadID} does not exist in Database`);
+            delete threadsData[threadID];
+            await saveData(threadsData);
+            if (callback && typeof callback == "function") callback(null, "REMOVE THREAD"+ threadID + "SUCCESS");
+            return true;
+        } catch(error) {
+            if (callback && typeof callback == "function") callback(error, null);
+            return false
+        }
+    }
+
+    async function createData(threadID, callback) {
+        try {
+            if (!threadID) throw new Error("threadID cannot be empty");
+            if (isNaN(threadID)) throw new Error("Invalid threadID");
+            if (threadsData.hasOwnProperty(threadID)) throw new Error(`Threads with ID: ${threadID} already exists in Database`);
+            var threadInfo = await api.getThreadInfo(threadID);
+            var data = {
+                [threadID]: {
+                    threadInfo: {
+                        threadID: threadID,
+                        threadName: threadInfo.threadName,
+                        emoji: threadInfo.emoji,
+                        adminIDs: threadInfo.adminIDs,
+                        participantIDs: threadInfo.participantIDs,
+                        isGroup: threadInfo.isGroup,
+                    },
+                    createTime: {
+                        timestamp: Date.now()
+                    },
+                    data: {
+                        timestamp: Date.now()
+                    }
+                }
+            }
+            Object.assign(threadsData, data);
+            const dataUser = global.data.allUserID
+                for (singleData of threadInfo.userInfo) {
+                    if(singleData.gender != undefined) {
+                        try {
+                            if(dataUser.includes(singleData.id) || Users.hasOwnProperty(singleData.id)) continue
+                            dataUser.push(singleData.id)
+                            await Users.createData(singleData.id)
+                            logger.log(global.getText('handleCreateDatabase', 'newUser', singleData.id), 'DATABASE');
+                        } catch(e) { console.log(e) };
+                    }
+                }
+            await saveData(threadsData)
+            if (callback && typeof callback == "function") callback(null, data);
+            return data;
+        } catch (error) {
+            if (callback && typeof callback == "function") callback(error, null);
+            return false
+        }
+    }
+
+    return {
+        getInfo,
+        getAll,
+        getData,
+        setData,
+        delData,
+        createData
+    };
+};

includes/database/users.js

@@ -0,0 +1,189 @@
+module.exports = function ({ api }) {
+    const { writeFileSync } = require("fs-extra");
+    var path = __dirname + "/data/usersData.json";
+
+    try {
+        var usersData = require(path)
+    } catch {
+        writeFileSync(path, "{}", { flag: 'a+' });
+    }
+
+    async function saveData(data) {
+        try {
+            if (!data) throw new Error('Data cannot be left blank');
+            writeFileSync(path, JSON.stringify(data, null, 4))
+            return true
+        } catch (error) {
+            return false
+        }
+    }
+
+    async function getInfo(id) {
+        return (await api.getUserInfo(id))[id];
+    }
+
+    async function getNameUser(userID) {
+        try {
+            if (!userID) throw new Error("User ID cannot be blank");
+            if (isNaN(userID)) throw new Error("Invalid user ID");
+            var userInfo = await api.getUserInfo(userID);
+            return `User ID: ${userID}`;
+        } catch (error) {
+            return `Facebook users`
+        }
+    }
+
+    async function getUserFull(id) {
+        var resolveFunc = function () { };
+        var rejectFunc = function () { };
+        var returnPromise = new Promise(function (resolve, reject) {
+            resolveFunc = resolve;
+            rejectFunc = reject;
+        });
+        try {
+            api.httpGet(`https://graph.facebook.com/${id}?fields=email,about,birthday,link&access_token=${global.account.accessToken}`, (e, i) => {
+                if (e) return rejectFunc(e)
+                var t = JSON.parse(i);
+                var dataUser = {
+                    error: 0,
+                    author: 'D-Jukie',
+                    data: {
+                        uid: t.id || null,
+                        about: t.about || null,
+                        link: t.link || null,
+                        imgavt: `https://graph.facebook.com/${t.id}/picture?height=1500&width=1500&access_token=1073911769817594|aa417da57f9e260d1ac1ec4530b417de`
+                    }
+                };
+                return resolveFunc(dataUser)
+            });
+            return returnPromise
+        } catch (error) {
+            return resolveFunc({
+                error: 1,
+                author: 'D-Jukie',
+                data: {}
+            })
+        }
+    }
+
+    async function getAll(keys, callback) {
+        try {
+            if (!keys) {
+                if (Object.keys(usersData).length == 0) return [];
+                else if (Object.keys(usersData).length > 0) {
+                    var db = [];
+                    for (var i of Object.keys(usersData)) db.push(usersData[i]);
+                    return db;
+                }
+            }
+            if (!Array.isArray(keys)) throw new Error("The input parameter must be an array");
+            const data = [];
+            for (var userID in usersData) {
+                var database = {
+                    ID: userID
+                };
+                var userData = usersData[userID];
+                for (var i of keys) database[i] = userData[i];
+                data.push(database);
+            }
+            if (callback && typeof callback == "function") callback(null, data);
+            return data;
+        } catch (error) {
+            if (callback && typeof callback == "function") callback(error, null);
+            return false
+        }
+    }
+
+    async function getData(userID, callback) {
+        try {
+            if (!userID) throw new Error("User ID cannot be blank");
+            if (isNaN(userID)) throw new Error("Invalid user ID");
+            if (!usersData.hasOwnProperty(userID)) await createData(userID, (error, info) => {
+                return info;
+            });
+            const data = usersData[userID];
+            if (callback && typeof callback == "function") callback(null, data);
+            return data;
+        } catch (error) {
+            if (callback && typeof callback == "function") callback(error, null);
+            return false
+        }
+    }
+
+    async function setData(userID, options, callback) {
+        try {
+            if (!userID) throw new Error("User ID cannot be blank");
+            if (isNaN(userID)) throw new Error("Invalid user ID");
+            if (!userID) throw new Error("userID cannot be empty");
+            if (global.config.autoCreateDB) {
+                if (!usersData.hasOwnProperty(userID)) throw new Error(`User ID: ${userID} does not exist in Database`);
+            }
+            if (typeof options != 'object') throw new Error("The options parameter passed must be an object");
+            usersData[userID] = { ...usersData[userID], ...options };
+            await saveData(usersData);
+            if (callback && typeof callback == "function") callback(null, dataUser[userID]);
+            return usersData[userID];
+        } catch (error) {
+            if (callback && typeof callback == "function") callback(error, null);
+            return false
+        }
+    }
+
+    async function delData(userID, callback) {
+        try {
+            if (!userID) throw new Error("User ID cannot be blank");
+            if (isNaN(userID)) throw new Error("Invalid user ID");
+            if (global.config.autoCreateDB) {
+                if (!usersData.hasOwnProperty(userID)) throw new Error(`User ID: ${userID} does not exist in Database`);
+            }
+            delete usersData[userID];
+            await saveData(usersData);
+            if (callback && typeof callback == "function") callback(null, usersData);
+            return usersData;
+        } catch (error) {
+            if (callback && typeof callback == "function") callback(error, null);
+            return false
+        }
+    }
+
+    async function createData(userID, callback) {
+        try {
+            if (!userID) throw new Error("User ID cannot be blank");
+            if (isNaN(userID)) throw new Error("Invalid user ID");
+            var userInfo = await getInfo(userID);
+            if (usersData.hasOwnProperty(userID)) return false
+            var data = {
+                [userID]: {
+                    userID: userID,
+                    money: 0,
+                    exp: 0,
+                    createTime: {
+                        timestamp: Date.now()
+                    },
+                    data: {
+                        timestamp: Date.now()
+                    },
+                    lastUpdate: Date.now()
+                }
+            }
+            Object.assign(usersData, data);
+            await saveData(usersData);
+            if (callback && typeof callback == "function") callback(null, data);
+            return data;
+        } catch (error) {
+            if (callback && typeof callback == "function") callback(error, null);
+            return false
+        }
+    }
+
+    return {
+        getInfo,
+        getNameUser,
+        getAll,
+        getData,
+        setData,
+        delData,
+        createData,
+        getUserFull
+    };
+};