vantiv.io 1.0.0

package/src/classes/Managers/PermissionManager.js

@@ -0,0 +1,288 @@
+const fs = require('fs').promises;
+const path = require('path');
+
+class PermissionManager {
+    constructor(bot, utils, options = {}) {
+        this.bot = bot;
+        this.logger = utils?.logger || console;
+        
+        this.config = {
+            dataDir: options.dataDir || './data',
+            filename: options.filename || 'permissions.json',
+            webapiSyncInterval: options.webapiSyncInterval || 300000,
+            fileSaveInterval: options.fileSaveInterval || 180000,
+            autoLoad: options.autoLoad !== false,
+            customRoles: options.customRoles || [],
+            ...options
+        };
+        
+        this.roles = new Map();
+        this.webapiModerators = new Set();
+        this.webapiDesigners = new Set();
+        
+        this.initialized = false;
+        this.syncInProgress = false;
+        this.saveQueued = false;
+        
+        if (this.config.autoLoad) {
+            this._initialize();
+        }
+    }
+    
+    async _initialize() {
+        try {
+            await fs.mkdir(this.config.dataDir, { recursive: true });
+            await this.loadFromFile();
+            this._createCustomRoles();
+            this._startWebApiSync();
+            this._startAutoSave();
+            this.initialized = true;
+            this.logger.success('PermissionManager', '✅ Ready! Auto-syncing every 5 minutes.');
+        } catch (error) {
+            this.logger.error('PermissionManager', 'Setup failed', error);
+            this._createCustomRoles();
+            this.initialized = true;
+        }
+    }
+    
+    _createCustomRoles() {
+        if (this.config.customRoles && Array.isArray(this.config.customRoles)) {
+            for (const roleName of this.config.customRoles) {
+                if (!this.roles.has(roleName)) {
+                    this.roles.set(roleName, new Set());
+                }
+            }
+        }
+    }
+    
+    async syncWithWebApi() {
+        if (this.syncInProgress) return false;
+        this.syncInProgress = true;
+        
+        try {
+            const currentRoom = await this.bot.webapi.room.getCurrentRoom();
+            if (!currentRoom) return false;
+            
+            const oldModerators = new Set(this.webapiModerators);
+            const oldDesigners = new Set(this.webapiDesigners);
+            
+            this.webapiModerators = new Set(currentRoom.moderatorIds || []);
+            this.webapiDesigners = new Set(currentRoom.designerIds || []);
+            
+            if (!this.roles.has('moderator')) this.roles.set('moderator', new Set());
+            if (!this.roles.has('designer')) this.roles.set('designer', new Set());
+            
+            const moderatorRole = this.roles.get('moderator');
+            const designerRole = this.roles.get('designer');
+            
+            for (const modId of this.webapiModerators) moderatorRole.add(modId);
+            for (const designerId of this.webapiDesigners) designerRole.add(designerId);
+            
+            const newMods = Array.from(this.webapiModerators).filter(id => !oldModerators.has(id));
+            const removedMods = Array.from(oldModerators).filter(id => !this.webapiModerators.has(id));
+            
+            if (newMods.length > 0 || removedMods.length > 0) {
+                this.logger.info('PermissionManager', `Web API sync: +${newMods.length} -${removedMods.length} moderators`);
+            }
+            
+            this.queueSave();
+            return true;
+            
+        } catch (error) {
+            this.logger.error('PermissionManager', `Web API sync failed ${error.message}`, error);
+            return false;
+        } finally {
+            this.syncInProgress = false;
+        }
+    }
+    
+    _startWebApiSync() {
+        setTimeout(() => this.syncWithWebApi(), 5000);
+        setInterval(() => this.syncWithWebApi(), this.config.webapiSyncInterval);
+    }
+    
+    createRole(roleName) {
+        if (this.roles.has(roleName)) return false;
+        this.roles.set(roleName, new Set());
+        this.queueSave();
+        return true;
+    }
+    
+    addToRole(roleName, userId) {
+        if (!this.roles.has(roleName)) this.createRole(roleName);
+        const added = this.roles.get(roleName).add(userId);
+        if (added) this.queueSave();
+        return added;
+    }
+    
+    removeFromRole(roleName, userId) {
+        if (!this.roles.has(roleName)) return false;
+        const removed = this.roles.get(roleName).delete(userId);
+        if (removed) this.queueSave();
+        return removed;
+    }
+    
+    hasRole(roleName, userId) {
+        if (!this.roles.has(roleName)) return false;
+        return this.roles.get(roleName).has(userId);
+    }
+    
+    hasAnyRole(roleNames, userId) {
+        for (const roleName of roleNames) {
+            if (this.hasRole(roleName, userId)) return true;
+        }
+        return false;
+    }
+    
+    getUserRoles(userId) {
+        const userRoles = [];
+        for (const [roleName, userSet] of this.roles) {
+            if (userSet.has(userId)) userRoles.push(roleName);
+        }
+        return userRoles;
+    }
+    
+    getUsersInRole(roleName) {
+        if (!this.roles.has(roleName)) return [];
+        return Array.from(this.roles.get(roleName));
+    }
+    
+    getAllRoles() {
+        return Array.from(this.roles.keys());
+    }
+    
+    deleteRole(roleName) {
+        const deleted = this.roles.delete(roleName);
+        if (deleted) this.queueSave();
+        return deleted;
+    }
+    
+    renameRole(oldName, newName) {
+        if (!this.roles.has(oldName) || this.roles.has(newName)) return false;
+        const userSet = this.roles.get(oldName);
+        this.roles.set(newName, userSet);
+        this.roles.delete(oldName);
+        this.queueSave();
+        return true;
+    }
+    
+    async loadFromFile() {
+        try {
+            const filePath = path.join(this.config.dataDir, this.config.filename);
+            try { await fs.access(filePath); } catch { return false; }
+            
+            const data = await fs.readFile(filePath, 'utf8');
+            const saved = JSON.parse(data);
+            
+            for (const [roleName, userIds] of Object.entries(saved)) {
+                if (roleName !== '_meta') this.roles.set(roleName, new Set(userIds));
+            }
+            
+            this.logger.success('PermissionManager', `Loaded ${this.roles.size} roles from file`);
+            return true;
+            
+        } catch (error) {
+            this.logger.error('PermissionManager', 'Failed to load roles', error);
+            return false;
+        }
+    }
+    
+    async saveToFile() {
+        if (this.saveQueued) return;
+        this.saveQueued = true;
+        
+        setTimeout(async () => {
+            try {
+                const filePath = path.join(this.config.dataDir, this.config.filename);
+                const tempPath = filePath + '.tmp';
+                
+                const data = {};
+                for (const [roleName, userSet] of this.roles) {
+                    data[roleName] = Array.from(userSet);
+                }
+                
+                data._meta = {
+                    savedAt: new Date().toISOString(),
+                    totalRoles: this.roles.size,
+                    totalUsers: Array.from(this.roles.values()).reduce((sum, set) => sum + set.size, 0)
+                };
+                
+                await fs.writeFile(tempPath, JSON.stringify(data, null, 2), 'utf8');
+                await fs.rename(tempPath, filePath);
+                                
+            } catch (error) {
+                this.logger.error('PermissionManager', 'Failed to save roles', error);
+            } finally {
+                this.saveQueued = false;
+            }
+        }, 1000);
+    }
+    
+    queueSave() {
+        if (!this.saveQueued) this.saveToFile();
+    }
+    
+    _startAutoSave() {
+        setInterval(() => this.queueSave(), this.config.fileSaveInterval);
+    }
+    
+    isOwner(userId) {
+        return this.hasRole('owner', userId);
+    }
+    
+    isModerator(userId) {
+        return this.hasRole('moderator', userId) || this.webapiModerators.has(userId);
+    }
+    
+    isDesigner(userId) {
+        return this.hasRole('designer', userId) || this.webapiDesigners.has(userId);
+    }
+    
+    getAllModerators() {
+        const moderators = new Set();
+        if (this.roles.has('moderator')) {
+            for (const userId of this.roles.get('moderator')) moderators.add(userId);
+        }
+        for (const userId of this.webapiModerators) moderators.add(userId);
+        return Array.from(moderators);
+    }
+    
+    getAllDesigners() {
+        const designers = new Set();
+        if (this.roles.has('designer')) {
+            for (const userId of this.roles.get('designer')) designers.add(userId);
+        }
+        for (const userId of this.webapiDesigners) designers.add(userId);
+        return Array.from(designers);
+    }
+    
+    async forceSync() {
+        await this.syncWithWebApi();
+        await this.saveToFile();
+    }
+    
+    exportToObject() {
+        const obj = {};
+        for (const [roleName, userSet] of this.roles) {
+            obj[roleName] = Array.from(userSet);
+        }
+        return obj;
+    }
+    
+    importFromObject(obj) {
+        for (const [roleName, userIds] of Object.entries(obj)) {
+            if (Array.isArray(userIds)) this.roles.set(roleName, new Set(userIds));
+        }
+        this.queueSave();
+        return true;
+    }
+    
+    clearAll() {
+        this.queueSave();
+        this.roles.clear();
+        this.webapiModerators.clear();
+        this.webapiDesigners.clear();
+    }
+}
+
+module.exports = PermissionManager;

package/src/classes/WebApi/Category/Grab.js

@@ -0,0 +1,98 @@
+
+class GrabCategory {
+    constructor(webapi, AxiosError) {
+        this.webapi = webapi;
+        this.logger = webapi.logger;
+        this.base = webapi.base;
+        this.AxiosErrorHandler = AxiosError
+    }
+
+    async get(grabId) {
+        const method = 'bot.webapi.grab.get'
+
+        try {
+            if (!grabId || typeof grabId !== 'string') {
+                throw new TypeError('grabId must be a non-empty string');
+            }
+
+            const response = await this.base.get(`/grabs/${grabId}`);
+            if (response.status === 200 && response.data?.grab) {
+                return this._formatGrab(response.data.grab);
+            }
+            return null;
+        } catch (error) {
+            if (error instanceof TypeError) {
+                this.logger.error(method, `TypeError: ${error.message}`, { grabId }, error);
+            } else {
+                return this.AxiosErrorHandler.handle(error, this.logger, method, { grabId });
+            }
+        }
+    }
+
+    _formatGrab(grabData) {
+        return {
+            id: grabData.grab_id,
+            title: grabData.title,
+            description: grabData.description,
+            bannerImgUrl: grabData.banner_img_url,
+            startsAt: grabData.starts_at,
+            expiresAt: grabData.expires_at,
+            rewards: Array.isArray(grabData.rewards) ? grabData.rewards.map(reward => this._formatGrabReward(reward)) : [],
+            costs: Array.isArray(grabData.costs) ? grabData.costs.map(cost => this._formatGrabCost(cost)) : [],
+            kompuRewards: Array.isArray(grabData.kompu_rewards) ? grabData.kompu_rewards.map(reward => this._formatGrabReward(reward)) : [],
+            limitedTimeKompu: grabData.limited_time_kompu ? this._formatLimitedKompu(grabData.limited_time_kompu) : null,
+            progressReward: grabData.progress_reward ? this._formatProgressReward(grabData.progress_reward) : null
+        };
+    }
+
+    _formatGrabReward(reward) {
+        return {
+            amount: reward.amount,
+            rewardId: reward.reward_id,
+            itemId: reward.item_id,
+            accountBound: reward.account_bound || false,
+            metadata: reward.metadata,
+            nfiMetadata: reward.nfi_metadata,
+            itemNumber: reward.item_number,
+            stackId: reward.stack_id,
+            nfiTemplateMetadata: reward.nfi_template_metadata,
+            totalAmount: reward.total_amount,
+            bannerItem: reward.banner_item || false,
+            primaryImgUrl: reward.primary_img_url,
+            secondaryImgUrl: reward.secondary_img_url,
+            isTradable: reward.is_tradable || false
+        };
+    }
+
+    _formatGrabCost(cost) {
+        return {
+            amount: cost.amount,
+            rewardId: cost.reward_id,
+            itemId: cost.item_id,
+            accountBound: cost.account_bound || false,
+            metadata: cost.metadata,
+            nfiMetadata: cost.nfi_metadata,
+            itemNumber: cost.item_number,
+            stackId: cost.stack_id,
+            nfiTemplateMetadata: cost.nfi_template_metadata,
+            totalAmount: cost.total_amount,
+            bannerItem: cost.banner_item || false
+        };
+    }
+
+    _formatLimitedKompu(limitedKompu) {
+        return {
+            expiresAt: limitedKompu.expires_at,
+            rewards: Array.isArray(limitedKompu.rewards) ? limitedKompu.rewards.map(reward => this._formatGrabReward(reward)) : []
+        };
+    }
+
+    _formatProgressReward(progressReward) {
+        return {
+            rewardsAt: progressReward.rewards_at,
+            rewards: Array.isArray(progressReward.rewards) ? progressReward.rewards.map(reward => this._formatGrabReward(reward)) : []
+        };
+    }
+}
+
+module.exports = GrabCategory