vantiv.io 1.0.0

package/src/classes/Actions/Inventory.js

@@ -0,0 +1,156 @@
+const { payment_methods, default_skin } = require("highrise-core/src/constants/TypesConstants");
+
+class InventoryClass {
+    constructor(bot) {
+        this.bot = bot;
+        this.logger = this.bot.logger
+    }
+
+    async get() {
+        const method = 'bot.inventory.get'
+
+        try {
+            const payload = {
+                _type: 'GetInventoryRequest'
+            }
+
+            const response = await this.bot._requestResponse.send(payload)
+            return response.items
+        } catch (error) {
+            this.logger.error(method, `Failed to get bot inventory: ${error.message}`, error);
+            return []
+        }
+    }
+
+    outfit = {
+        set: async (outfit = default_skin) => {
+            const method = 'bot.inventory.outfit.set'
+
+            try {
+                if (!outfit || !Array.isArray(outfit)) throw new TypeError('outfit must be an array')
+
+                const payload = {
+                    _type: 'SetOutfitRequest',
+                    outfit: outfit
+                }
+
+                const response = await this.bot._fireAndForget.send(payload)
+                return response.success;
+            } catch (error) {
+                if (error instanceof TypeError) {
+                    this.logger.error(method, `TypeError: ${error.message}`, error);
+                } else {
+                    this.logger.error(method, `Failed to set outfit: ${error.message}`, error);
+                    return false
+                }
+            }
+        }
+    }
+
+    wallet = {
+        get: async () => {
+            const method = 'bot.inventory.wallet.get'
+
+            try {
+                const payload = {
+                    _type: 'GetWalletRequest'
+                }
+
+                const response = await this.bot._requestResponse.send(payload)
+
+                const walletData = response.content.reduce((acc, item) => {
+                    acc[item.type] = item.amount;
+                    return acc;
+                }, {});
+
+                return {
+                    gold: walletData.gold || 0,
+                    boost_tokens: walletData.room_boost_tokens || 0,
+                    voice_tokens: walletData.room_voice_tokens || 0,
+                };
+            } catch (error) {
+                this.logger.error(method, `Failed to get bot wallet: ${error.message}`, error);
+            }
+        }
+    }
+
+    boost = {
+        buy: async (payment_method = 'bot_wallet_only', amount = 1) => {
+            const method = 'bot.inventory.boost.buy'
+            try {
+                if (!payment_method || typeof payment_method !== 'string' || !payment_methods.includes(payment_method)) {
+                    throw new TypeError(`payment_method must be a string and a vaild payment method`)
+                }
+
+                if (!amount || typeof amount !== 'number' || amount <= 0) throw new TypeError('amount must be a positive number')
+
+                const payload = {
+                    _type: 'BuyRoomBoostRequest',
+                    payment_method: payment_method,
+                    amount: amount
+                }
+
+                const response = await this.bot._requestResponse.send(payload)
+                return response.result
+            } catch (error) {
+                if (error instanceof TypeError) {
+                    this.logger.error(method, `TypeError: ${error.message}`, { payment_method, amount }, error);
+                } else {
+                    this.logger.error(method, `Failed to buy boost token: ${error.message}`, { payment_method, amount }, error);
+                }
+            }
+        }
+    }
+
+    voice = {
+        buy: async (payment_method = 'bot_wallet_only') => {
+            const method = 'bot.inventory.voice.buy'
+            try {
+                if (!payment_method || typeof payment_method !== 'string' || !payment_methods.includes(payment_method)) {
+                    throw new TypeError(`payment_method must be a string and a vaild payment method\nValid payment methods: ${payment_methods.join(', ')}`)
+                }
+
+                const payload = {
+                    _type: 'BuyVoiceTimeRequest',
+                    payment_method: payment_method
+                }
+
+                const response = await this.bot._requestResponse.send(payload)
+                return response.result
+            } catch (error) {
+                if (error instanceof TypeError) {
+                    this.logger.error(method, `TypeError: ${error.message}`, { payment_method }, error);
+                } else {
+                    this.logger.error(method, `Failed to buy voice token: ${error.message}`, { payment_method }, error);
+                }
+            }
+        }
+    }
+
+    item = {
+        buy: async (item_id) => {
+            const method = 'bot.inventory.item.buy'
+            try {
+                if (!item_id || typeof item_id !== 'string') {
+                    throw new TypeError(`item_id must be a string`)
+                }
+
+                const payload = {
+                    _type: 'BuyItemRequest',
+                    item_id: item_id
+                }
+
+                const response = await this.bot._requestResponse.send(payload)
+                return response.result
+            } catch (error) {
+                if (error instanceof TypeError) {
+                    this.logger.error(method, `TypeError: ${error.message}`, { item_id }, error);
+                } else {
+                    this.logger.error(method, `Failed to buy item: ${error.message}`, { item_id }, error);
+                }
+            }
+        }
+    }
+}
+
+module.exports = { InventoryClass }

package/src/classes/Actions/Music.js

@@ -0,0 +1,278 @@
+const { IcecastStreamer, IcecastQueue, Track, YouTubeExtractor, IcecastServer } = require('./lib/AudioStreaming.js');
+const EventEmitter = require('events')
+
+class MusicClass extends EventEmitter {
+    constructor(bot, config = {}) {
+        super()
+        this.bot = bot;
+        this.config = {
+            enabled: config.enabled || false,
+            icecast: config.icecast || {},
+            queue: config.queue || {},
+            autoStartServer: config.autoStartServer || true,
+            serverPort: config.serverPort || 3000,
+            maxQueueSize: config.maxQueueSize || 100,
+            defaultVolume: config.defaultVolume || 80,
+            allowedFormats: config.allowedFormats || ['youtube', 'direct']
+        };
+
+        if (!this.config.enabled) {
+            console.log('Music module is disabled. Enable it in config to use music features.');
+            return;
+        }
+
+        this.initializeStreamer();
+        this.setupEventHandlers();
+        
+        if (this.config.autoStartServer) {
+            this.startWebServer();
+        }
+        
+    }
+
+    initializeStreamer() {
+        try {
+            this.streamer = new IcecastStreamer(this.config.icecast);
+            this.queue = new IcecastQueue(this.streamer, this.config.queue);
+            
+            this.streamer.on('playbackStart', (track) => {
+                this.emit('playbackStart', track);
+            });
+            
+            this.streamer.on('playbackEnd', (track) => {
+                this.emit('playbackEnd', track);
+            });
+            
+            this.streamer.on('progress', (data) => {
+                this.emit('progress', data);
+            });
+            
+            this.streamer.on('error', (error) => {
+                this.emit('error', error);
+            });
+            
+            this.streamer.on('streamStopped', () => {
+                this.emit('streamStopped');
+            });
+            
+        } catch (error) {
+            console.error('Failed to initialize Icecast streamer:', error);
+            throw error;
+        }
+    }
+
+    setupEventHandlers() {
+        this.bot.on('Ready', () => {
+            this.emit('Ready');
+        });
+
+        this.bot.on('error', (error) => {
+            this.emit('error', error);
+        });
+    }
+
+    async play(query, metadata = {}) {
+        try {
+            if (!this.streamer) {
+                throw new Error('Streamer not initialized');
+            }
+
+            let trackInfo;
+            let source = 'direct';
+            
+            if (this.isValidUrl(query)) {
+                if (query.includes('youtube.com') || query.includes('youtu.be')) {
+                    trackInfo = await YouTubeExtractor.getStreamUrl(query);
+                    source = 'youtube';
+                } else {
+                    trackInfo = {
+                        url: query,
+                        title: metadata.title || 'Unknown Track',
+                        duration: metadata.duration || 0,
+                        thumbnail: metadata.thumbnail || null
+                    };
+                }
+            } else {
+                trackInfo = await YouTubeExtractor.searchTrack(query);
+                source = 'youtube';
+            }
+
+            if (!trackInfo) {
+                return {
+                    success: false,
+                    error: 'Could not find or play the requested track'
+                };
+            }
+
+            const track = new Track({
+                url: trackInfo.url,
+                title: trackInfo.title || metadata.title || 'Unknown Track',
+                duration: trackInfo.duration || metadata.duration || 0,
+                requester: metadata.requester || 'System',
+                requesterId: metadata.requesterId || 'system',
+                thumbnail: trackInfo.thumbnail || metadata.thumbnail,
+                source: source
+            });
+
+            const result = await this.queue.add(track);
+            
+            return {
+                success: true,
+                track: {
+                    title: track.title,
+                    duration: track.duration,
+                    formattedDuration: track.getFormattedDuration(),
+                    requester: track.requester,
+                    thumbnail: track.thumbnail
+                },
+                position: result.position,
+                isNowPlaying: result.isNowPlaying || false
+            };
+            
+        } catch (error) {
+            console.error('Error playing track:', error);
+            return {
+                success: false,
+                error: error.message
+            };
+        }
+    }
+
+    async skip() {
+        try {
+            const result = await this.queue.skip();
+            
+            let upcoming = null;
+            if (this.queue.queue.length > 0) {
+                const nextTrack = this.queue.queue[0];
+                upcoming = {
+                    title: nextTrack.title,
+                    duration: nextTrack.duration,
+                    formattedDuration: nextTrack.getFormattedDuration()
+                };
+            }
+            
+            return {
+                success: result,
+                upcoming: upcoming
+            };
+        } catch (error) {
+            console.error('Error skipping track:', error);
+            return {
+                success: false,
+                error: error.message
+            };
+        }
+    }
+
+    getNowPlaying() {
+        const np = this.streamer.getNowPlaying();
+        if (!np || !np.track) {
+            return null;
+        }
+
+        return {
+            track: np.track,
+            position: np.position || 0,
+            duration: np.duration || 0,
+            progress: np.progress || 0,
+            remaining: np.remaining || 0,
+            formattedPosition: this.formatDuration(np.position || 0),
+            formattedDuration: np.track.getFormattedDuration(),
+            formattedRemaining: this.formatDuration(np.remaining || 0)
+        };
+    }
+
+    getQueue() {
+        return {
+            queue: this.queue?.getQueue(),
+            upcoming: this.queue?.getQueue().slice(0, 10),
+            loopMode: this.queue.loopMode,
+            length: this.queue.queue.length
+        };
+    }
+
+    toggleLoop() {
+        const modes = ['off', 'track', 'queue'];
+        const currentIndex = modes.indexOf(this.queue.loopMode);
+        const nextIndex = (currentIndex + 1) % modes.length;
+        this.queue.loopMode = modes[nextIndex];
+        
+        return {
+            success: true,
+            newMode: this.queue.loopMode
+        };
+    }
+
+    shuffle() {
+        if (this.queue.queue.length === 0) {
+            return {
+                success: false,
+                error: 'Queue is empty'
+            };
+        }
+
+        for (let i = this.queue.queue.length - 1; i > 0; i--) {
+            const j = Math.floor(Math.random() * (i + 1));
+            [this.queue.queue[i], this.queue.queue[j]] = [this.queue.queue[j], this.queue.queue[i]];
+        }
+
+        return {
+            success: true,
+            queue: this.getQueue()
+        };
+    }
+
+    isValidUrl(string) {
+        try {
+            new URL(string);
+            return true;
+        } catch (_) {
+            return false;
+        }
+    }
+
+    formatDuration(seconds) {
+        if (!seconds) return '0:00';
+        
+        const hours = Math.floor(seconds / 3600);
+        const minutes = Math.floor((seconds % 3600) / 60);
+        const secondsRemaining = Math.floor(seconds % 60);
+        
+        if (hours > 0) {
+            return `${hours}:${minutes.toString().padStart(2, '0')}:${secondsRemaining.toString().padStart(2, '0')}`;
+        }
+        return `${minutes}:${secondsRemaining.toString().padStart(2, '0')}`;
+    }
+
+    startWebServer() {
+        try {
+            this.webServer = new IcecastServer({
+                port: this.config.serverPort,
+                publicStreamUrl: this.streamer.publicStreamUrl,
+                logger: this.bot.utils.logger
+            });
+            
+            this.webServer.start();
+            return true;
+        } catch (error) {
+            console.error('Failed to start web server:', error);
+            return false;
+        }
+    }
+
+    destroy() {
+        try {
+            if (this.streamer) {
+                this.streamer.stop();
+            }
+            
+            return true;
+        } catch (error) {
+            console.error('Error destroying music class:', error);
+            return false;
+        }
+    }
+}
+
+module.exports = MusicClass;