vantiv.io 1.0.0

package/src/classes/Actions/Room.js

@@ -0,0 +1,333 @@
+class RoomClass {
+    constructor(bot) {
+        this.bot = bot
+        this.logger = this.bot.logger
+    }
+
+    privilege = {
+        get: async (user_id) => {
+            const method = 'bot.room.privilege.get'
+
+            try {
+                if (!user_id || typeof user_id !== 'string') throw new TypeError('user_id must be a non-empty string');
+
+                const payload = {
+                    _type: 'GetRoomPrivilegeRequest',
+                    user_id: user_id
+                }
+
+                const response = await this.bot._requestResponse.send(payload)
+                return response.content
+            } catch (error) {
+                if (error instanceof TypeError) {
+                    this.logger.error(method, `TypeError: ${error.message}`, { user_id }, error);
+                } else {
+                    this.logger.error(method, `Failed to get user room privilege: ${error.message}`, { user_id }, error);
+                    return {}
+                }
+            }
+        },
+
+        isModerator: async (user_id) => {
+            const method = 'bot.room.privilege.isModerator'
+
+            try {
+                if (!user_id || typeof user_id !== 'string') throw new TypeError('user_id must be a non-empty string');
+
+                const payload = {
+                    _type: 'GetRoomPrivilegeRequest',
+                    user_id: user_id
+                }
+
+                const response = await this.bot._requestResponse.send(payload)
+                return response.content.moderator === true
+            } catch (error) {
+                if (error instanceof TypeError) {
+                    this.logger.error(method, `TypeError: ${error.message}`, { user_id }, error);
+                } else {
+                    this.logger.error(method, `Failed to check moderator status: ${error.message}`, { user_id }, error);
+                }
+            }
+        },
+
+        isDesigner: async (user_id) => {
+            const method = 'bot.room.privilege.isDesigner'
+
+            try {
+                if (!user_id || typeof user_id !== 'string') throw new TypeError('user_id must be a non-empty string');
+
+                const payload = {
+                    _type: 'GetRoomPrivilegeRequest',
+                    user_id: user_id
+                }
+
+                const response = await this.bot._requestResponse.send(payload)
+                return response.content.designer === true
+            } catch (error) {
+                if (error instanceof TypeError) {
+                    this.logger.error(method, `TypeError: ${error.message}`, { user_id }, error);
+                } else {
+                    this.logger.error(method, `Failed to check designer status: ${error.message}`, { user_id }, error);
+                }
+            }
+        }
+    }
+
+    designer = {
+        add: async (user_id) => {
+            const method = 'bot.room.designer.add'
+
+            try {
+                if (!user_id || typeof user_id !== 'string') throw new TypeError('user_id must be a non-empty string');
+
+
+                const payload = {
+                    _type: 'ChangeRoomPrivilegeRequest',
+                    user_id: user_id,
+                    permissions: { designer: true }
+                }
+
+                const response = await this.bot._fireAndForget.send(payload)
+                return response.success
+            } catch (error) {
+                if (error instanceof TypeError) {
+                    this.logger.error(method, `TypeError: ${error.message}`, { user_id }, error);
+                } else {
+                    this.logger.error(method, `Failed to add user as designer: ${error.message}`, { user_id }, error);
+                    return false
+                }
+            }
+        },
+
+        remove: async (user_id) => {
+            const method = 'bot.room.designer.remove'
+
+            try {
+                if (!user_id || typeof user_id !== 'string') throw new TypeError('user_id must be a non-empty string');
+
+
+                const payload = {
+                    _type: 'ChangeRoomPrivilegeRequest',
+                    user_id: user_id,
+                    permissions: { designer: false }
+                }
+
+                const response = await this.bot._fireAndForget.send(payload)
+                return response.success
+            } catch (error) {
+                if (error instanceof TypeError) {
+                    this.logger.error(method, `TypeError: ${error.message}`, { user_id }, error);
+                } else {
+                    this.logger.error(method, `Failed to remove designer privilege: ${error.message}`, { user_id }, error);
+                    return false
+                }
+            }
+        }
+    }
+
+    moderator = {
+        add: async (user_id) => {
+            const method = 'bot.room.moderator.add'
+
+            try {
+                if (!user_id || typeof user_id !== 'string') throw new TypeError('user_id must be a non-empty string');
+
+
+                const payload = {
+                    _type: 'ChangeRoomPrivilegeRequest',
+                    user_id: user_id,
+                    permissions: { moderator: true }
+                }
+
+                const response = await this.bot._fireAndForget.send(payload)
+                return response.success
+            } catch (error) {
+                if (error instanceof TypeError) {
+                    this.logger.error(method, `TypeError: ${error.message}`, { user_id }, error);
+                } else {
+                    this.logger.error(method, `Failed to add user as moderator: ${error.message}`, { user_id }, error);
+                    return false
+                }
+            }
+        },
+
+        remove: async (user_id) => {
+            const method = 'bot.room.moderator.remove'
+
+            try {
+                if (!user_id || typeof user_id !== 'string') throw new TypeError('user_id must be a non-empty string');
+
+
+                const payload = {
+                    _type: 'ChangeRoomPrivilegeRequest',
+                    user_id: user_id,
+                    permissions: { moderator: false }
+                }
+
+                const response = await this.bot._fireAndForget.send(payload)
+                return response.success
+            } catch (error) {
+                if (error instanceof TypeError) {
+                    this.logger.error(method, `TypeError: ${error.message}`, { user_id }, error);
+                } else {
+                    this.logger.error(method, `Failed to remove moderator privilege: ${error.message}`, { user_id }, error);
+                    return false
+                }
+            }
+        }
+    }
+
+    users = {
+        get: async () => {
+            const method = 'bot.room.users.get'
+
+            try {
+                const payload = {
+                    _type: 'GetRoomUsersRequest'
+                }
+
+                const response = await this.bot._requestResponse.send(payload)
+                return response.content
+            } catch (error) {
+                this.logger.error(method, `Failed to get room users: ${error.message}`);
+                return []
+            }
+        },
+
+        id: async (username) => {
+            const method = 'bot.room.users.id'
+
+            try {
+                if (!username || typeof username !== 'string') throw new TypeError('username must be a non-empty string');
+
+                const users = await this.users.get()
+                const user = users.find(u => u[0].username === username)
+                if (!user) throw new Error(`User with username '${username}' not in room`)
+
+                return user[0].id
+            } catch (error) {
+                if (error instanceof TypeError) {
+                    this.logger.error(method, `TypeError: ${error.message}`, { username }, error);
+                } else {
+                    this.logger.error(method, `Failed to get user ID: ${error.message}`, { username }, error);
+                }
+            }
+        },
+
+        username: async (id) => {
+            const method = 'bot.room.users.username'
+
+            try {
+                if (!id || typeof id !== 'string') throw new TypeError('id must be a non-empty string');
+
+                const users = await this.users.get()
+                const user = users.find(u => u[0].id === id)
+                if (!user) throw new Error(`User with ID '${id}' not in room`)
+
+                return user[0].username
+            } catch (error) {
+                if (error instanceof TypeError) {
+                    this.logger.error(method, `TypeError: ${error.message}`, { id }, error);
+                } else {
+                    this.logger.error(method, `Failed to get username: ${error.message}`, { id }, error);
+                }
+            }
+        },
+
+        position: async (identifier) => {
+            const method = 'bot.room.users.position'
+
+            try {
+                if (!identifier || typeof identifier !== 'string') throw new TypeError('identifier must be a non-empty string');
+
+                const users = await this.users.get()
+                const user = users.find(u => u[0].id === identifier || u[0].username === identifier)
+                if (!user) throw new Error(`User '${identifier}' not in room`)
+
+                return user[1]
+            } catch (error) {
+                if (error instanceof TypeError) {
+                    this.logger.error(method, `TypeError: ${error.message}`, { identifier }, error);
+                } else {
+                    this.logger.error(method, `Failed to get user position: ${error.message}`, { identifier }, error);
+                }
+            }
+        }
+    }
+
+    voice = {
+        check: async () => {
+            const method = 'bot.room.voice.check'
+            let result = {}
+
+            try {
+                const payload = {
+                    _type: 'CheckVoiceChatRequest'
+                }
+
+                const response = await this.bot._requestResponse.send(payload)
+
+                if (response.seconds_left) {
+                    result.secondsLeft = response.seconds_left
+                    result.autoSpeakersId = response.auto_speakers
+                    result.users = response.users
+                } else {
+                    result.message = response.message
+                }
+
+                return result
+            } catch (error) {
+                this.logger.error(method, `Failed to check room voice status: ${error.message}`);
+            }
+        },
+
+        invite: async (user_id) => {
+            const method = 'bot.room.voice.invite'
+
+            try {
+                if (!user_id || typeof user_id !== 'string') throw new TypeError('user_id must be a non-empty string');
+
+                const payload = {
+                    _type: 'InviteSpeakerRequest',
+                    user_id
+                }
+
+                const response = await this.bot._fireAndForget.send(payload)
+                return response.success
+            } catch (error) {
+                if (error instanceof TypeError) {
+                    this.logger.error(method, `TypeError: ${error.message}`, { user_id }, error);
+                } else {
+                    this.logger.error(method, `Failed to invite user to voice: ${error.message}`, { user_id }, error);
+                    return false
+                }
+            }
+        },
+
+        remove: async (user_id) => {
+            const method = 'bot.room.voice.remove'
+
+            try {
+                if (!user_id || typeof user_id !== 'string') throw new TypeError('user_id must be a non-empty string');
+
+                const payload = {
+                    _type: 'RemoveSpeakerRequest',
+                    user_id
+                }
+
+                const response = await this.bot._fireAndForget.send(payload)
+                return response.success
+            } catch (error) {
+                if (error instanceof TypeError) {
+                    this.logger.error(method, `TypeError: ${error.message}`, { user_id }, error);
+                } else {
+                    this.logger.error(method, `Failed to remove user from voice: ${error.message}`, { user_id }, error);
+                    return false
+                }
+            }
+        }
+    }
+
+}
+
+module.exports = { RoomClass }

package/src/classes/Actions/Utils.js

@@ -0,0 +1,29 @@
+const PermissionManager = require("highrise-core/src/classes/Managers/PermissionManager");
+const CooldownManager = require("highrise-core/src/classes/Managers/Networking/CooldownManager");
+const DanceFloor = require("highrise-core/src/classes/Managers/DanceFloorManagers");
+const { Logger } = require("highrise-core/src/classes/Managers/Helpers/LoggerManager")
+
+class Utils {
+    constructor(bot, options) {
+        this.bot = bot
+        this.logger = new Logger(this, options)
+        this.DanceFloor = new DanceFloor(this.bot)
+        this.cooldown = new CooldownManager()
+
+        this.permissions = new PermissionManager(bot, this, {
+            dataDir: './data/permissions',
+            filename: 'roles.json',
+            customRoles: options.customRoles || []
+        });
+    }
+
+    async sleep(ms) {
+        if (ms < 0) {
+            this.logger.warn('bot.utils.sleep', 'Negative delay provided, using 0ms');
+            ms = 0;
+        }
+        return new Promise(resolve => setTimeout(resolve, ms))
+    }
+}
+
+module.exports = Utils