polyv-live-cli 1.0.2

package/dist/handlers/channel.handler.js

@@ -0,0 +1,690 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelHandler = void 0;
+const base_handler_1 = require("./base.handler");
+const channel_service_1 = require("../services/channel.service");
+const errors_1 = require("../utils/errors");
+class ChannelHandler extends base_handler_1.BaseHandler {
+    constructor(authConfig, serviceConfig) {
+        super();
+        this.channelService = new channel_service_1.ChannelService(authConfig, serviceConfig);
+    }
+    async create(options) {
+        return this.executeWithErrorHandling(async () => {
+            this.validateCreateOptions(options);
+            const request = this.transformToCreateRequest(options);
+            const channel = await this.channelService.createChannel(request);
+            this.displayChannelCreated(channel, options.output);
+        }, 'channel.create');
+    }
+    async listChannels(options = {}) {
+        return this.executeWithErrorHandling(async () => {
+            this.validateListOptions(options);
+            const request = this.transformToListRequest(options);
+            const channels = await this.channelService.listChannels(request);
+            this.displayChannelsList(channels, request, options.output);
+        }, 'channel.list');
+    }
+    async getChannelDetail(options) {
+        return this.executeWithErrorHandling(async () => {
+            this.validateGetOptions(options);
+            const request = this.transformToDetailRequest(options);
+            const channelDetail = await this.channelService.getChannelDetail(request);
+            this.displayChannelDetail(channelDetail, options.output);
+        }, 'channel.get');
+    }
+    async updateChannel(options) {
+        return this.executeWithErrorHandling(async () => {
+            this.validateUpdateOptions(options);
+            const request = this.transformToUpdateRequest(options);
+            await this.channelService.updateChannel(request);
+            this.displayChannelUpdated(options);
+        }, 'channel.update');
+    }
+    async deleteChannel(options) {
+        return this.executeWithErrorHandling(async () => {
+            this.validateSingleDeleteOptions(options);
+            if (!options.force) {
+                const { confirmDeletion } = await Promise.resolve().then(() => __importStar(require('../utils/confirmation')));
+                const confirmed = await confirmDeletion(`Are you sure you want to delete channel '${options.channelId}'? This action cannot be undone.`, 'yes');
+                if (!confirmed) {
+                    this.displayInfo('Channel deletion cancelled by user');
+                    return;
+                }
+            }
+            await this.channelService.deleteChannel(options.channelId);
+            this.displayChannelDeleted(options);
+        }, 'channel.delete');
+    }
+    async deleteChannels(options) {
+        return this.executeWithErrorHandling(async () => {
+            this.validateDeleteOptions(options);
+            const request = this.transformToDeleteRequest(options);
+            await this.channelService.batchDeleteChannels(request);
+            this.displayChannelsDeleted(options);
+        }, 'channel.delete');
+    }
+    validateCreateOptions(options) {
+        const errors = [];
+        if (!options.name || typeof options.name !== 'string') {
+            errors.push('Channel name is required and must be a string');
+        }
+        else if (options.name.trim().length === 0) {
+            errors.push('Channel name cannot be empty');
+        }
+        else if (options.name.length > 100) {
+            errors.push('Channel name cannot exceed 100 characters');
+        }
+        if (options.description !== undefined) {
+            if (typeof options.description !== 'string') {
+                errors.push('Description must be a string');
+            }
+            else if (options.description.length > 500) {
+                errors.push('Description cannot exceed 500 characters');
+            }
+        }
+        if (options.maxViewers !== undefined) {
+            if (typeof options.maxViewers !== 'number' || options.maxViewers < 0) {
+                errors.push('Max viewers must be a non-negative number');
+            }
+            else if (options.maxViewers > 100000) {
+                errors.push('Max viewers cannot exceed 100,000');
+            }
+        }
+        if (options.autoRecord !== undefined && typeof options.autoRecord !== 'boolean') {
+            errors.push('Auto record must be a boolean value');
+        }
+        if (options.output !== undefined && !['table', 'json'].includes(options.output)) {
+            errors.push('Output format must be either "table" or "json"');
+        }
+        if (options.scene !== undefined) {
+            const validScenes = ['topclass', 'cloudclass', 'telecast', 'akt'];
+            if (!validScenes.includes(options.scene)) {
+                errors.push(`Scene must be one of: ${validScenes.join(', ')}`);
+            }
+        }
+        if (options.template !== undefined) {
+            const validTemplates = ['ppt', 'video'];
+            if (!validTemplates.includes(options.template)) {
+                errors.push(`Template must be one of: ${validTemplates.join(', ')}`);
+            }
+        }
+        if (options.password !== undefined) {
+            if (typeof options.password !== 'string') {
+                errors.push('Password must be a string');
+            }
+            else if (options.password.length < 6 || options.password.length > 16) {
+                errors.push('Password must be 6-16 characters long');
+            }
+            else if (!/^[a-zA-Z0-9]+$/.test(options.password)) {
+                errors.push('Password must contain only alphanumeric characters');
+            }
+        }
+        if (errors.length > 0) {
+            throw new errors_1.PolyVValidationError(`Channel creation options validation failed: ${errors.join(', ')}`, 'options', options, 'validation_failed');
+        }
+    }
+    transformToCreateRequest(options) {
+        const request = {
+            name: options.name.trim(),
+            newScene: options.scene || 'topclass',
+            template: options.template || 'ppt'
+        };
+        if (options.password) {
+            request.channelPasswd = options.password;
+        }
+        return request;
+    }
+    displayChannelCreated(channel, format = 'table') {
+        const displayData = {
+            channelId: channel.channelId,
+            name: channel.name,
+            userId: channel.userId,
+            password: channel.channelPasswd ? '***' : '-',
+            scene: channel.newScene,
+            template: channel.template,
+            status: channel.status || 'waiting',
+            created: channel.createdAt ? channel.createdAt.toLocaleString() : 'Just now'
+        };
+        this.displaySuccess('Channel created successfully', displayData, format);
+        if (format === 'table') {
+            this.displayInfo('Channel is ready for streaming configuration');
+            if (channel.channelPasswd) {
+                this.displayWarning('Channel password has been set - remember to provide it to viewers');
+            }
+        }
+    }
+    validateListOptions(options) {
+        const errors = [];
+        if (options.page !== undefined) {
+            if (typeof options.page !== 'number' || !Number.isInteger(options.page) || options.page < 1) {
+                errors.push('Page must be a positive integer (minimum 1)');
+            }
+        }
+        if (options.limit !== undefined) {
+            if (typeof options.limit !== 'number' || !Number.isInteger(options.limit) || options.limit < 1 || options.limit > 100) {
+                errors.push('Limit must be an integer between 1 and 100');
+            }
+        }
+        if (options.output !== undefined && !['table', 'json'].includes(options.output)) {
+            errors.push('Output format must be either "table" or "json"');
+        }
+        if (options.categoryId !== undefined && (typeof options.categoryId !== 'string' || options.categoryId.trim().length === 0)) {
+            errors.push('Category ID must be a non-empty string');
+        }
+        if (options.keyword !== undefined && (typeof options.keyword !== 'string' || options.keyword.trim().length === 0)) {
+            errors.push('Keyword must be a non-empty string');
+        }
+        if (options.labelId !== undefined && (typeof options.labelId !== 'string' || options.labelId.trim().length === 0)) {
+            errors.push('Label ID must be a non-empty string');
+        }
+        if (errors.length > 0) {
+            throw new errors_1.PolyVValidationError(`Channel list options validation failed: ${errors.join(', ')}`, 'options', options, 'validation_failed');
+        }
+    }
+    validateGetOptions(options) {
+        const errors = [];
+        if (!options.channelId) {
+            errors.push('Channel ID is required');
+        }
+        else if (typeof options.channelId !== 'string') {
+            errors.push('Channel ID must be a string');
+        }
+        else if (options.channelId.trim().length === 0) {
+            errors.push('Channel ID cannot be empty');
+        }
+        if (options.output !== undefined && !['table', 'json'].includes(options.output)) {
+            errors.push('Output format must be either "table" or "json"');
+        }
+        if (errors.length > 0) {
+            throw new errors_1.PolyVValidationError(`Channel get options validation failed: ${errors.join(', ')}`, 'options', options, 'validation_failed');
+        }
+    }
+    validateUpdateOptions(options) {
+        const errors = [];
+        if (!options.channelId) {
+            errors.push('Channel ID is required');
+        }
+        else if (typeof options.channelId !== 'string') {
+            errors.push('Channel ID must be a string');
+        }
+        else if (options.channelId.trim().length === 0) {
+            errors.push('Channel ID cannot be empty');
+        }
+        const updateFields = [
+            'name', 'description', 'publisher', 'password', 'maxViewers',
+            'autoRecord', 'startTime', 'endTime', 'pageView', 'likes',
+            'coverImg', 'splashImg'
+        ];
+        const hasUpdateField = updateFields.some(field => options[field] !== undefined);
+        if (!hasUpdateField) {
+            errors.push('At least one update parameter must be provided');
+        }
+        if (options.name !== undefined) {
+            if (typeof options.name !== 'string') {
+                errors.push('Channel name must be a string');
+            }
+            else if (options.name.trim().length === 0) {
+                errors.push('Channel name cannot be empty');
+            }
+            else if (options.name.length > 100) {
+                errors.push('Channel name cannot exceed 100 characters');
+            }
+        }
+        if (options.description !== undefined) {
+            if (typeof options.description !== 'string') {
+                errors.push('Description must be a string');
+            }
+            else if (options.description.length > 500) {
+                errors.push('Description cannot exceed 500 characters');
+            }
+        }
+        if (options.publisher !== undefined) {
+            if (typeof options.publisher !== 'string') {
+                errors.push('Publisher must be a string');
+            }
+        }
+        if (options.password !== undefined) {
+            if (typeof options.password !== 'string') {
+                errors.push('Password must be a string');
+            }
+            else if (options.password.length < 6 || options.password.length > 16) {
+                errors.push('Password must be 6-16 characters long');
+            }
+            else if (!/^[a-zA-Z0-9]+$/.test(options.password)) {
+                errors.push('Password must contain only alphanumeric characters');
+            }
+        }
+        if (options.maxViewers !== undefined) {
+            if (typeof options.maxViewers !== 'number' || options.maxViewers <= 0) {
+                errors.push('Max viewers must be a positive number');
+            }
+        }
+        if (options.autoRecord !== undefined && typeof options.autoRecord !== 'boolean') {
+            errors.push('Auto record must be a boolean value');
+        }
+        if (options.startTime !== undefined) {
+            if (typeof options.startTime !== 'number' || options.startTime < 0) {
+                errors.push('Start time must be a non-negative timestamp');
+            }
+        }
+        if (options.endTime !== undefined) {
+            if (typeof options.endTime !== 'number' || options.endTime < 0) {
+                errors.push('End time must be a non-negative timestamp');
+            }
+            if (options.startTime !== undefined && options.endTime <= options.startTime) {
+                errors.push('End time must be greater than start time');
+            }
+        }
+        if (options.pageView !== undefined) {
+            if (typeof options.pageView !== 'number' || options.pageView < 0) {
+                errors.push('Page view count must be a non-negative number');
+            }
+        }
+        if (options.likes !== undefined) {
+            if (typeof options.likes !== 'number' || options.likes < 0) {
+                errors.push('Likes count must be a non-negative number');
+            }
+        }
+        if (options.coverImg !== undefined && typeof options.coverImg !== 'string') {
+            errors.push('Cover image URL must be a string');
+        }
+        if (options.splashImg !== undefined && typeof options.splashImg !== 'string') {
+            errors.push('Splash image URL must be a string');
+        }
+        if (options.output !== undefined && !['table', 'json'].includes(options.output)) {
+            errors.push('Output format must be either "table" or "json"');
+        }
+        if (errors.length > 0) {
+            throw new errors_1.PolyVValidationError(`Channel update options validation failed: ${errors.join(', ')}`, 'options', options, 'validation_failed');
+        }
+    }
+    transformToUpdateRequest(options) {
+        const request = {
+            channelId: options.channelId.trim()
+        };
+        const basicSetting = {};
+        let hasBasicSetting = false;
+        if (options.name !== undefined) {
+            basicSetting.name = options.name.trim();
+            hasBasicSetting = true;
+        }
+        if (options.description !== undefined) {
+            basicSetting.desc = options.description;
+            hasBasicSetting = true;
+        }
+        if (options.publisher !== undefined) {
+            basicSetting.publisher = options.publisher;
+            hasBasicSetting = true;
+        }
+        if (options.password !== undefined) {
+            basicSetting.channelPasswd = options.password;
+            hasBasicSetting = true;
+        }
+        if (options.maxViewers !== undefined) {
+            basicSetting.maxViewer = options.maxViewers;
+            hasBasicSetting = true;
+        }
+        if (options.startTime !== undefined) {
+            basicSetting.startTime = options.startTime;
+            hasBasicSetting = true;
+        }
+        if (options.endTime !== undefined) {
+            basicSetting.endTime = options.endTime;
+            hasBasicSetting = true;
+        }
+        if (options.pageView !== undefined) {
+            basicSetting.pageView = options.pageView;
+            hasBasicSetting = true;
+        }
+        if (options.likes !== undefined) {
+            basicSetting.likes = options.likes;
+            hasBasicSetting = true;
+        }
+        if (options.coverImg !== undefined) {
+            basicSetting.coverImg = options.coverImg;
+            hasBasicSetting = true;
+        }
+        if (options.splashImg !== undefined) {
+            basicSetting.splashImg = options.splashImg;
+            hasBasicSetting = true;
+        }
+        if (hasBasicSetting) {
+            request.basicSetting = basicSetting;
+        }
+        return request;
+    }
+    displayChannelUpdated(options) {
+        const updateSummary = [];
+        if (options.name !== undefined)
+            updateSummary.push(`Name: ${options.name}`);
+        if (options.description !== undefined)
+            updateSummary.push(`Description: ${options.description}`);
+        if (options.publisher !== undefined)
+            updateSummary.push(`Publisher: ${options.publisher}`);
+        if (options.password !== undefined)
+            updateSummary.push('Password: ***');
+        if (options.maxViewers !== undefined)
+            updateSummary.push(`Max Viewers: ${options.maxViewers}`);
+        if (options.startTime !== undefined)
+            updateSummary.push(`Start Time: ${new Date(options.startTime).toLocaleString()}`);
+        if (options.endTime !== undefined)
+            updateSummary.push(`End Time: ${new Date(options.endTime).toLocaleString()}`);
+        if (options.pageView !== undefined)
+            updateSummary.push(`Page Views: ${options.pageView}`);
+        if (options.likes !== undefined)
+            updateSummary.push(`Likes: ${options.likes}`);
+        if (options.coverImg !== undefined)
+            updateSummary.push(`Cover Image: ${options.coverImg}`);
+        if (options.splashImg !== undefined)
+            updateSummary.push(`Splash Image: ${options.splashImg}`);
+        this.displaySuccess(`Channel ${options.channelId} updated successfully`);
+        if (updateSummary.length > 0) {
+            this.displayInfo('Updated fields:');
+            updateSummary.forEach(summary => this.displayInfo(`  • ${summary}`));
+        }
+        if (options.password) {
+            this.displayWarning('Channel password has been updated - remember to provide it to viewers');
+        }
+    }
+    validateSingleDeleteOptions(options) {
+        const errors = [];
+        if (!options.channelId) {
+            errors.push('Channel ID is required');
+        }
+        else if (typeof options.channelId !== 'string') {
+            errors.push('Channel ID must be a string');
+        }
+        else if (options.channelId.trim().length === 0) {
+            errors.push('Channel ID cannot be empty');
+        }
+        if (options.force !== undefined && typeof options.force !== 'boolean') {
+            errors.push('Force flag must be a boolean value');
+        }
+        if (options.output !== undefined && !['table', 'json'].includes(options.output)) {
+            errors.push('Output format must be either "table" or "json"');
+        }
+        if (errors.length > 0) {
+            throw new errors_1.PolyVValidationError(`Channel delete options validation failed: ${errors.join(', ')}`, 'options', options, 'validation_failed');
+        }
+    }
+    validateDeleteOptions(options) {
+        const errors = [];
+        if (!options.channelIds) {
+            errors.push('Channel IDs are required');
+        }
+        else if (!Array.isArray(options.channelIds)) {
+            errors.push('Channel IDs must be an array');
+        }
+        else if (options.channelIds.length === 0) {
+            errors.push('At least one channel ID must be provided');
+        }
+        else if (options.channelIds.length > 100) {
+            errors.push('Cannot delete more than 100 channels at once');
+        }
+        else {
+            for (let i = 0; i < options.channelIds.length; i++) {
+                const channelId = options.channelIds[i];
+                if (typeof channelId !== 'string') {
+                    errors.push(`Channel ID at position ${i + 1} must be a string`);
+                }
+                else if (channelId.trim().length === 0) {
+                    errors.push(`Channel ID at position ${i + 1} cannot be empty`);
+                }
+            }
+        }
+        if (options.output !== undefined && !['table', 'json'].includes(options.output)) {
+            errors.push('Output format must be either "table" or "json"');
+        }
+        if (errors.length > 0) {
+            throw new errors_1.PolyVValidationError(`Channel delete options validation failed: ${errors.join(', ')}`, 'options', options, 'validation_failed');
+        }
+    }
+    transformToDeleteRequest(options) {
+        return {
+            channelIds: options.channelIds.map((id) => id.trim())
+        };
+    }
+    displayChannelsDeleted(options) {
+        const channelCount = options.channelIds.length;
+        const channelText = channelCount === 1 ? 'channel' : 'channels';
+        this.displaySuccess(`Successfully deleted ${channelCount} ${channelText}`);
+        if (options.output === 'json') {
+            const jsonData = {
+                deleted: true,
+                channelIds: options.channelIds,
+                count: channelCount
+            };
+            this.displayData(jsonData, 'json');
+        }
+        else {
+            this.displayInfo('Deleted channels:');
+            options.channelIds.forEach((channelId) => {
+                this.displayInfo(`  • Channel ${channelId}`);
+            });
+        }
+    }
+    displayChannelDeleted(options) {
+        this.displaySuccess(`Successfully deleted channel ${options.channelId}`);
+        if (options.output === 'json') {
+            const jsonData = {
+                deleted: true,
+                channelId: options.channelId,
+                timestamp: new Date().toISOString()
+            };
+            this.displayData(jsonData, 'json');
+        }
+        else {
+            this.displayInfo(`Channel ${options.channelId} has been permanently deleted`);
+            this.displayWarning('This action cannot be undone');
+        }
+    }
+    transformToListRequest(options) {
+        const request = {};
+        if (options.page !== undefined) {
+            request.page = options.page;
+        }
+        if (options.limit !== undefined) {
+            request.limit = options.limit;
+        }
+        if (options.categoryId) {
+            request.categoryId = options.categoryId.trim();
+        }
+        if (options.keyword) {
+            request.keyword = options.keyword.trim();
+        }
+        if (options.labelId) {
+            request.labelId = options.labelId.trim();
+        }
+        return request;
+    }
+    transformToDetailRequest(options) {
+        return {
+            channelId: options.channelId.trim()
+        };
+    }
+    displayChannelsList(channels, request, format = 'table') {
+        if (channels.length === 0) {
+            this.displayInfo('No channels found');
+            return;
+        }
+        if (format === 'json') {
+            const jsonData = {
+                channels: channels.map(channel => ({
+                    channelId: channel.channelId,
+                    name: channel.name,
+                    status: channel.status,
+                    scene: channel.scene,
+                    template: channel.template,
+                    createdAt: channel.createdAt.toISOString(),
+                    description: channel.description,
+                    maxViewers: channel.maxViewers
+                })),
+                pagination: {
+                    page: request.page ?? 1,
+                    limit: request.limit ?? 20,
+                    total: channels.length
+                }
+            };
+            this.displayData(jsonData, 'json');
+        }
+        else {
+            const tableData = channels.map(channel => ({
+                'Channel ID': channel.channelId,
+                'Name': channel.name,
+                'Status': channel.status,
+                'Scene': channel.scene,
+                'Template': channel.template,
+                'Created': channel.createdAt.toLocaleDateString()
+            }));
+            this.displaySuccess(`Found ${channels.length} channels`, tableData, 'table');
+            const page = request.page ?? 1;
+            const limit = request.limit ?? 20;
+            this.displayInfo(`Page ${page}, showing up to ${limit} channels per page`);
+        }
+    }
+    displayChannelDetail(channelDetail, format = 'table') {
+        if (format === 'json') {
+            const jsonData = {
+                channelId: channelDetail.channelId,
+                name: channelDetail.name,
+                scene: channelDetail.scene,
+                newScene: channelDetail.newScene,
+                template: channelDetail.template,
+                channelPasswd: channelDetail.channelPasswd ? '***masked***' : null,
+                publisher: channelDetail.publisher,
+                startTime: channelDetail.startTime,
+                endTime: channelDetail.endTime,
+                pureRtcEnabled: channelDetail.pureRtcEnabled,
+                pageView: channelDetail.pageView,
+                likes: channelDetail.likes,
+                coverImg: channelDetail.coverImg,
+                splashImg: channelDetail.splashImg,
+                splashEnabled: channelDetail.splashEnabled,
+                bgImg: channelDetail.bgImg,
+                desc: channelDetail.desc,
+                consultingMenuEnabled: channelDetail.consultingMenuEnabled,
+                maxViewerRestrict: channelDetail.maxViewerRestrict,
+                maxViewer: channelDetail.maxViewer,
+                watchStatus: channelDetail.watchStatus,
+                watchStatusText: channelDetail.watchStatusText,
+                userCategory: channelDetail.userCategory,
+                authSettings: channelDetail.authSettings,
+                linkMicLimit: channelDetail.linkMicLimit,
+                createdAccountId: channelDetail.createdAccountId,
+                createdAccountEmail: channelDetail.createdAccountEmail,
+                createdTime: channelDetail.createdTime,
+                labelData: channelDetail.labelData,
+                clientAloneTemplateBackgroundUrl: channelDetail.clientAloneTemplateBackgroundUrl,
+                liveCdnBackgroundUrl: channelDetail.liveCdnBackgroundUrl,
+                pushUrl: channelDetail.pushUrl ? '***masked***' : null,
+                pushSecret: channelDetail.pushSecret ? '***masked***' : null,
+                streamType: channelDetail.streamType,
+                onlyOutEnabled: channelDetail.onlyOutEnabled
+            };
+            this.displayData(jsonData, 'json');
+        }
+        else {
+            this.displaySuccess(`Channel Details: ${channelDetail.name}`, null, 'table');
+            const basicInfo = {
+                'Channel ID': channelDetail.channelId.toString(),
+                'Name': channelDetail.name,
+                'Publisher': channelDetail.publisher || '-',
+                'Description': channelDetail.desc || '-',
+                'Status': `${channelDetail.watchStatus} (${channelDetail.watchStatusText})`,
+                'Scene': channelDetail.newScene !== 'undefined' ? channelDetail.newScene : channelDetail.scene,
+                'Template': channelDetail.template !== 'undefined' ? channelDetail.template : '-'
+            };
+            this.displayInfo('📋 Basic Information');
+            this.displayData(basicInfo, 'table');
+            const configInfo = {
+                'Channel Password': channelDetail.channelPasswd ? 'Set (***masked***)' : 'Not set',
+                'Pure RTC': channelDetail.pureRtcEnabled === 'Y' ? 'Enabled' : 'Disabled',
+                'Max Viewer Restrict': channelDetail.maxViewerRestrict === 'Y' ? 'Enabled' : 'Disabled',
+                'Max Viewers': channelDetail.maxViewer > 0 ? channelDetail.maxViewer.toString() : 'Unlimited',
+                'Link Mic Limit': channelDetail.linkMicLimit.toString(),
+                'Consulting Menu': channelDetail.consultingMenuEnabled === 'Y' ? 'Enabled' : 'Disabled',
+                'Splash Page': channelDetail.splashEnabled === 'Y' ? 'Enabled' : 'Disabled'
+            };
+            this.displayInfo('⚙️ Configuration');
+            this.displayData(configInfo, 'table');
+            const statsInfo = {
+                'Page Views': channelDetail.pageView.toString(),
+                'Likes': channelDetail.likes.toString(),
+                'Start Time': channelDetail.startTime > 0 ? new Date(channelDetail.startTime).toLocaleString() : 'Not set',
+                'End Time': channelDetail.endTime > 0 ? new Date(channelDetail.endTime).toLocaleString() : 'Not set',
+                'Created Time': new Date(channelDetail.createdTime).toLocaleString(),
+                'Created By': channelDetail.createdAccountEmail || channelDetail.createdAccountId
+            };
+            this.displayInfo('📊 Statistics & Timing');
+            this.displayData(statsInfo, 'table');
+            if (channelDetail.userCategory) {
+                const categoryInfo = {
+                    'Category ID': channelDetail.userCategory.categoryId.toString(),
+                    'Category Name': channelDetail.userCategory.categoryName,
+                    'Rank': channelDetail.userCategory.rank.toString()
+                };
+                this.displayInfo('📁 Category Information');
+                this.displayData(categoryInfo, 'table');
+            }
+            if (channelDetail.authSettings && channelDetail.authSettings.length > 0) {
+                const authSummary = channelDetail.authSettings.map((auth) => ({
+                    'Rank': auth.rank.toString(),
+                    'Type': auth.authType,
+                    'Enabled': auth.enabled,
+                    'Global Setting': auth.globalSettingEnabled
+                }));
+                this.displayInfo('🔐 Authentication Settings');
+                this.displayData(authSummary, 'table');
+            }
+            if (channelDetail.labelData && channelDetail.labelData.length > 0) {
+                this.displayInfo(`Labels: ${channelDetail.labelData.join(', ')}`);
+            }
+            const urls = [];
+            if (channelDetail.coverImg)
+                urls.push(`Cover Image: ${channelDetail.coverImg}`);
+            if (channelDetail.splashImg)
+                urls.push(`Splash Image: ${channelDetail.splashImg}`);
+            if (channelDetail.bgImg)
+                urls.push(`Background Image: ${channelDetail.bgImg}`);
+            if (urls.length > 0) {
+                this.displayInfo('Images:\n' + urls.join('\n'));
+            }
+        }
+    }
+}
+exports.ChannelHandler = ChannelHandler;
+//# sourceMappingURL=channel.handler.js.map