vantiv.io 1.0.0

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

@@ -0,0 +1,347 @@
+class ItemCategory {
+    constructor(webapi, AxiosError) {
+        this.webapi = webapi;
+        this.logger = webapi.logger;
+        this.base = webapi.base;
+        this.AxiosErrorHandler = AxiosError
+    }
+
+    async get(itemId) {
+        const method = 'bot.webapi.item.get'
+
+        try {
+            if (!itemId || typeof itemId !== 'string') {
+                throw new TypeError('itemId must be a non-empty string');
+            }
+
+            const response = await this.base.get(`/items/${itemId}`);
+            if (response.status === 200 && response.data?.item) {
+                return this._formatItemDetail(response.data.item);
+            }
+            return null;
+        } catch (error) {
+            if (error instanceof TypeError) {
+                this.logger.error(method, `TypeError: ${error.message}`, { itemId }, error);
+            } else {
+                return this.AxiosErrorHandler.handle(error, this.logger, method, { itemId });
+            }
+        }
+    }
+
+    async list(params = {}) {
+        const method = 'bot.webapi.item.list'
+
+        const validatedParams = {
+            limit: Math.min(params.limit || 20, 100),
+            sort_order: params.sort_order || 'desc',
+            rarity: params.rarity,
+            item_name: params.item_name,
+            category: params.category,
+            starts_after: params.starts_after,
+            ends_before: params.ends_before
+        };
+
+        const AllowedSortOrder = ['asc', 'desc'];
+        const AllowedRarities = ['common', 'uncommon', 'rare', 'epic', 'legendary', 'none_'];
+        const AllowedCategories = [
+            'bag', 'blush', 'body', 'dress', 'earrings', 'emote', 'eye', 'eyebrow',
+            'face_hair', 'fishing_rod', 'freckle', 'glasses', 'gloves', 'hair_back',
+            'hair_front', 'handbag', 'hat', 'jacket', 'lashes', 'mole', 'mouth',
+            'necklace', 'nose', 'pants', 'shirt', 'shoes', 'shorts', 'skirt',
+            'watch', 'fullsuit', 'sock', 'tattoo', 'rod', 'aura'
+        ];
+
+        try {
+            if (typeof params !== 'object') {
+                throw new TypeError('params must be an object');
+            }
+
+            if (validatedParams.limit <= 0 || validatedParams.limit > 100) {
+                throw new TypeError('limit must be between 1 and 100');
+            }
+
+            if (!AllowedSortOrder.includes(validatedParams.sort_order)) {
+                throw new TypeError(`sort_order must be one of: ${AllowedSortOrder.join(', ')}`);
+            }
+
+            if (validatedParams.rarity && !AllowedRarities.includes(validatedParams.rarity)) {
+                throw new TypeError(`rarity must be one of: ${AllowedRarities.join(', ')}`);
+            }
+
+            if (validatedParams.category && !AllowedCategories.includes(validatedParams.category)) {
+                throw new TypeError(`category must be one of: ${AllowedCategories.join(', ')}`);
+            }
+
+            const response = await this.base.get('/items', {
+                params: validatedParams
+            });
+
+            if (response.status === 200 && response.data?.items) {
+                return this._formatItemsList(response.data);
+            }
+
+            return null;
+
+        } catch (error) {
+            if (error instanceof TypeError) {
+                this.logger.error(method, `TypeError: ${error.message}`, { params }, error);
+                throw error;
+            } else {
+                return this.AxiosErrorHandler.handle(error, this.logger, method, { params });
+            }
+        }
+    }
+
+    async search(params = {}) {
+        const method = 'bot.webapi.item.search'
+
+        const validatedParams = {
+            limit: Math.min(params.limit || 20, 100),
+            skip: Math.max(params.skip || 0, 0),
+            query: params.query || ''
+        };
+
+        try {
+            if (typeof params !== 'object') {
+                throw new TypeError('params must be an object');
+            }
+
+            if (validatedParams.limit <= 0 || validatedParams.limit > 100) {
+                throw new TypeError('limit must be between 1 and 100');
+            }
+
+            if (typeof validatedParams.query !== 'string') {
+                throw new TypeError('query must be a string');
+            }
+
+            if (validatedParams.skip < 0) {
+                throw new TypeError('skip cannot be negative');
+            }
+
+            const response = await this.base.get('/items/search', {
+                params: validatedParams
+            });
+
+            if (response.status === 200 && response.data?.items) {
+                return this._formatItemsSearch(response.data);
+            }
+
+            return null;
+
+        } catch (error) {
+            if (error instanceof TypeError) {
+                this.logger.error(method, `TypeError: ${error.message}`, { params }, error);
+                throw error;
+            } else {
+                return this.AxiosErrorHandler.handle(error, this.logger, method, { params });
+            }
+        }
+    }
+
+    async searchByName(name, limit = 20) {
+        return this.search({ query: name, limit });
+    }
+
+    async getByCategory(category, limit = 20) {
+        return this.list({ category, limit });
+    }
+
+    async getByRarity(rarity, limit = 20) {
+        return this.list({ rarity, limit });
+    }
+
+    async getByName(name, limit = 20) {
+        return this.list({ item_name: name, limit });
+    }
+
+    async getRecent(limit = 20) {
+        return this.list({ limit, sort_order: 'desc' });
+    }
+
+    async getPurchasable(query = '', limit = 20) {
+        const result = await this.search({ query, limit });
+        if (result) {
+            return {
+                ...result,
+                items: result.items.filter(item => item.properties.isPurchasable)
+            };
+        }
+        return null;
+    }
+
+    async getTradable(query = '', limit = 20) {
+        const result = await this.search({ query, limit });
+        if (result) {
+            return {
+                ...result,
+                items: result.items.filter(item => item.properties.isTradable)
+            };
+        }
+        return null;
+    }
+
+    async getPurchasableByCategory(category, limit = 20) {
+        const result = await this.list({ category, limit });
+        if (result) {
+            return {
+                ...result,
+                items: result.items.filter(item => item.properties.isPurchasable)
+            };
+        }
+        return null;
+    }
+
+    async getTradableByCategory(category, limit = 20) {
+        const result = await this.list({ category, limit });
+        if (result) {
+            return {
+                ...result,
+                items: result.items.filter(item => item.properties.isTradable)
+            };
+        }
+        return null;
+    }
+
+    _formatItemsList(apiResponse) {
+        return {
+            items: apiResponse.items.map(item => this._formatItem(item)),
+            pagination: {
+                total: apiResponse.total,
+                firstId: apiResponse.first_id,
+                lastId: apiResponse.last_id,
+                hasMore: apiResponse.items.length > 0
+            }
+        };
+    }
+
+    _formatItemsSearch(apiResponse) {
+        return {
+            items: apiResponse.items.map(item => this._formatItem(item)),
+            pagination: {
+                total: apiResponse.total,
+                hasMore: apiResponse.items.length > 0,
+                skip: apiResponse.skip || 0
+            }
+        };
+    }
+
+    _formatItem(itemData) {
+        return {
+            id: itemData.item_id,
+            name: itemData.item_name,
+            category: itemData.category,
+            colorLinkedCategories: itemData.color_linked_categories,
+            colorPalettes: itemData.color_palettes,
+            createdAt: itemData.created_at,
+            description: itemData.description_key,
+            pricing: {
+                gems: itemData.gems_sale_price,
+                pops: itemData.pops_sale_price
+            },
+            properties: {
+                isPurchasable: itemData.is_purchasable || false,
+                isTradable: itemData.is_tradable || false
+            },
+            images: {
+                main: itemData.image_url,
+                icon: itemData.icon_url
+            },
+            links: {
+                linkIds: Array.isArray(itemData.link_ids) ? itemData.link_ids : [],
+                inspiredBy: itemData.inspired_by
+            },
+            skinParts: {
+                front: Array.isArray(itemData.m_front_skin_part_list)
+                    ? itemData.m_front_skin_part_list.map(part => this._formatSkinPart(part))
+                    : [],
+                back: Array.isArray(itemData.m_back_skin_part_list)
+                    ? itemData.m_back_skin_part_list.map(part => this._formatSkinPart(part))
+                    : []
+            },
+            metadata: {
+                dependentColors: itemData.m_dependent_colors,
+                releaseDate: itemData.release_date,
+                keywords: itemData.keywords
+            }
+        };
+    }
+
+    _formatItemDetail(itemData) {
+        return {
+            ...this._formatItem(itemData),
+            acquisition: {
+                cost: itemData.acquisition_cost,
+                amount: itemData.acquisition_amount,
+                currency: itemData.acquisition_currency
+            },
+            relatedItems: itemData.related_items ? this._formatRelatedItems(itemData.related_items) : null,
+            affiliations: Array.isArray(itemData.affiliations) ? itemData.affiliations.map(affil => this._formatAffiliation(affil)) : [],
+            storefrontListings: itemData.storefront_listings ? this._formatStorefrontListings(itemData.storefront_listings) : null
+        };
+    }
+
+    _formatSkinPart(skinPart) {
+        return {
+            bone: skinPart.bone,
+            slot: skinPart.slot,
+            imageFile: skinPart.image_file,
+            attachmentName: skinPart.attachment_name,
+            hasRemoteRenderLayer: skinPart.has_remote_render_layer || false
+        };
+    }
+
+    _formatRelatedItems(relatedItems) {
+        return {
+            items: Array.isArray(relatedItems.items) ? relatedItems.items.map(item => ({
+                id: item.item_id,
+                name: item.disp_name
+            })) : []
+        };
+    }
+
+    _formatAffiliation(affiliation) {
+        return {
+            id: affiliation.id,
+            title: affiliation.title,
+            type: affiliation.type,
+            eventType: affiliation.event_type
+        };
+    }
+
+    _formatStorefrontListings(storefront) {
+        return {
+            sellers: Array.isArray(storefront.sellers) ? storefront.sellers.map(seller => this._formatSeller(seller)) : [],
+            pages: storefront.pages || 0,
+            total: storefront.total || 0
+        };
+    }
+
+    _formatSeller(seller) {
+        return {
+            userId: seller.user_id,
+            username: seller.username,
+            outfit: Array.isArray(seller.outfit) ? seller.outfit.map(item => this._formatOutfitItem(item)) : [],
+            lastConnectedAt: seller.last_connected_at
+        };
+    }
+
+    _formatOutfitItem(outfitItem) {
+        return {
+            itemId: outfitItem.item_id,
+            name: outfitItem.name,
+            rarity: outfitItem.rarity,
+            activePalette: outfitItem.active_palette,
+            parts: outfitItem.parts,
+            colors: outfitItem.colors ? this._formatOutfitItemColors(outfitItem.colors) : null,
+            linkedColors: outfitItem.linked_colors
+        };
+    }
+
+    _formatOutfitItemColors(colors) {
+        return {
+            linkedColors: colors.linked_colors
+        };
+    }
+}
+
+module.exports = ItemCategory

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

@@ -0,0 +1,154 @@
+class PostCategory {
+    constructor(webapi, AxiosError) {
+        this.webapi = webapi;
+        this.logger = webapi.logger;
+        this.base = webapi.base;
+        this.AxiosErrorHandler = AxiosError
+    }
+
+    async get(postId) {
+        const method = 'bot.webapi.post.get'
+
+        try {
+            if (!postId || typeof postId !== 'string') {
+                throw new TypeError('postId must be a non-empty string');
+            }
+
+            const response = await this.base.get(`/posts/${postId}`);
+            if (response.status === 200 && response.data?.post) {
+                return this._formatPostDetail(response.data.post);
+            }
+            return null;
+        } catch (error) {
+            if (error instanceof TypeError) {
+                this.logger.error(method, `TypeError: ${error.message}`, { postId }, error);
+            } else {
+                return this.AxiosErrorHandler.handle(error, this.logger, method, { postId });
+            }
+        }
+    }
+
+    async list(params = {}) {
+        const method = 'bot.webapi.post.list'
+
+        const validatedParams = {
+            limit: Math.min(params.limit || 20, 100),
+            sort_order: params.sort_order || 'desc',
+            author_id: params.author_id,
+            starts_after: params.starts_after,
+            ends_before: params.ends_before
+        };
+
+        const AllowedSortOrder = ['asc', 'desc'];
+
+        try {
+            if (typeof params !== 'object') {
+                throw new TypeError('params must be an object');
+            }
+
+            if (validatedParams.limit <= 0 || validatedParams.limit > 100) {
+                throw new TypeError('limit must be between 1 and 100');
+            }
+
+            if (!AllowedSortOrder.includes(validatedParams.sort_order)) {
+                throw new TypeError(`sort_order must be one of: ${AllowedSortOrder.join(', ')}`);
+            }
+
+            const response = await this.base.get('/posts', {
+                params: validatedParams
+            });
+
+            if (response.status === 200 && response.data?.posts) {
+                return this._formatPostsList(response.data);
+            }
+
+            return null;
+
+        } catch (error) {
+            if (error instanceof TypeError) {
+                this.logger.error(method, `TypeError: ${error.message}`, { params }, error);
+                throw error;
+            } else {
+                return this.AxiosErrorHandler.handle(error, this.logger, method, { params });
+            }
+        }
+    }
+
+    async getByAuthor(authorId, limit = 20) {
+        return this.list({ author_id: authorId, limit });
+    }
+
+    async getRecent(limit = 20) {
+        return this.list({ limit, sort_order: 'desc' });
+    }
+
+    _formatPostsList(apiResponse) {
+        return {
+            posts: apiResponse.posts.map(post => this._formatPostBasic(post)),
+            pagination: {
+                total: apiResponse.total,
+                firstId: apiResponse.first_id,
+                lastId: apiResponse.last_id,
+                hasMore: apiResponse.posts.length > 0
+            }
+        };
+    }
+
+    _formatPostBasic(postData) {
+        return {
+            id: postData.post_id,
+            authorId: postData.author_id,
+            createdAt: this.webapi._formatDate(postData.created_at),
+            type: postData.type,
+            visibility: postData.visibility,
+
+            stats: {
+                comments: postData.num_comments || 0,
+                likes: postData.num_likes || 0,
+                reposts: postData.num_reposts || 0
+            },
+
+            content: {
+                text: postData.text || '',
+                hasBody: !!postData.body,
+                caption: postData.caption
+            },
+
+            fileKey: postData.file_key,
+
+            featuredUserIds: Array.isArray(postData.featured_user_ids) ? postData.featured_user_ids : [],
+
+            inventory: postData.inventory ? this.webapi._formatInventory(postData.inventory) : null,
+
+            body: postData.body ? this._formatPostBody(postData.body) : null
+        };
+    }
+
+    _formatPostDetail(postData) {
+        return {
+            ...this._formatPostBasic(postData),
+            comments: Array.isArray(postData.comments) ? postData.comments.map(comment => this._formatComment(comment)) : []
+        };
+    }
+
+    _formatPostBody(body) {
+        if (!body) return null;
+        return {
+            text: body.text || '',
+            inventory: body.inventory ? this.webapi._formatInventory(body.inventory) : null
+        };
+    }
+
+    _formatComment(comment) {
+        return {
+            id: comment.id,
+            content: comment.content,
+            postId: comment.post_id,
+            authorId: comment.author_id,
+            authorName: comment.author_name,
+            likes: comment.num_likes || 0
+        };
+    }
+}
+
+module.exports = PostCategory

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

@@ -0,0 +1,137 @@
+class RoomCategory {
+    constructor(webapi, AxiosError) {
+        this.webapi = webapi;
+        this.logger = webapi.logger;
+        this.base = webapi.base;
+        this.AxiosErrorHandler = AxiosError
+    }
+
+    async get(roomId) {
+        const method = 'bot.webapi.room.get'
+
+        try {
+            if (!roomId || typeof roomId !== 'string') {
+                throw new TypeError('roomId must be a non-empty string');
+            }
+
+            const response = await this.base.get(`/rooms/${roomId}`);
+            if (response.status === 200 && response.data?.room) {
+                return this._formatRoomDetail(response.data.room);
+            }
+
+            return null;
+        } catch (error) {
+            console.log(error)
+            if (error instanceof TypeError) {
+                this.logger.error(method, `TypeError: ${error.message}`, { roomId }, error);
+            } else {
+                return this.AxiosErrorHandler.handle(error, this.logger, method, { roomId });
+            }
+        }
+    }
+
+    async list(params = {}) {
+        const method = 'bot.webapi.room.list'
+
+        const validatedParams = {
+            limit: Math.min(params.limit || 20, 100),
+            sort_order: params.sort_order || 'desc',
+            room_name: params.room_name,
+            owner_id: params.owner_id,
+            starts_after: params.starts_after,
+            ends_before: params.ends_before
+        };
+
+        const AllowedSortOrder = ['asc', 'desc'];
+
+        try {
+            if (typeof params !== 'object') {
+                throw new TypeError('params must be an object');
+            }
+
+            if (validatedParams.limit <= 0 || validatedParams.limit > 100) {
+                throw new TypeError('limit must be between 1 and 100');
+            }
+
+            if (!AllowedSortOrder.includes(validatedParams.sort_order)) {
+                throw new TypeError(`sort_order must be one of: ${AllowedSortOrder.join(', ')}`);
+            }
+
+            const response = await this.base.get('/rooms', {
+                params: validatedParams
+            });
+
+            if (response.status === 200 && response.data?.rooms) {
+                return this._formatRoomsList(response.data);
+            }
+
+            return null;
+
+        } catch (error) {
+            if (error instanceof TypeError) {
+                this.logger.error(method, `TypeError: ${error.message}`, { params }, error);
+                throw error;
+            } else {
+                return this.AxiosErrorHandler.handle(error, this.logger, method, { params });
+            }
+        }
+    }
+
+    async getCurrentRoom() {
+        const room = await this.get(this.webapi.bot.info.room.id)
+        return room
+    }
+
+    async searchByName(name, limit = 20) {
+        return this.list({ room_name: name, limit });
+    }
+
+    async getByOwner(ownerId, limit = 20) {
+        return this.list({ owner_id: ownerId, limit });
+    }
+
+    async getRecent(limit = 20) {
+        return this.list({ limit, sort_order: 'desc' });
+    }
+
+    _formatRoomsList(apiResponse) {
+        return {
+            rooms: apiResponse.rooms.map(room => this._formatRoomBasic(room)),
+            pagination: {
+                total: apiResponse.total,
+                firstId: apiResponse.first_id,
+                lastId: apiResponse.last_id,
+                hasMore: apiResponse.rooms.length > 0
+            }
+        };
+    }
+
+    _formatRoomBasic(roomData) {
+        return {
+            id: roomData.room_id,
+            name: roomData.disp_name,
+            description: roomData.description,
+            category: roomData.category,
+            createdAt: this.webapi._formatDate(roomData.created_at),
+            accessPolicy: roomData.access_policy,
+            ownerId: roomData.owner_id,
+            languages: Array.isArray(roomData.locale) ? roomData.locale : [roomData.locale],
+            isHomeRoom: roomData.is_home_room,
+            designerIds: Array.isArray(roomData.designer_ids) ? roomData.designer_ids : [],
+            moderatorIds: Array.isArray(roomData.moderator_ids) ? roomData.moderator_ids : []
+        };
+    }
+
+    _formatRoomDetail(roomData) {
+        return {
+            ...this._formatRoomBasic(roomData),
+            connectedUsers: roomData.num_connected || 0,
+            thumbnail: roomData.thumbnail_url,
+            banner: roomData.banner_url,
+            crewId: roomData.crew_id,
+            bots: roomData.bots ? JSON.parse(roomData.bots) : [],
+        };
+    }
+}
+
+module.exports = RoomCategory