polyv-live-cli/dist/services/channel.service.sdk.js

CLI tool for managing PolyV live streaming services.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.ChannelServiceSdk = void 0;
const errors_1 = require("../utils/errors");
const sdk_1 = require("../sdk");
class ChannelServiceSdk {
    constructor(authConfig, serviceConfig) {
        this.authConfig = authConfig;
        this.config = serviceConfig;
    }
    async createChannel(request) {
        try {
            this.validateCreateRequest(request);
            const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
            const createParams = {
                name: request.name,
                newScene: request.newScene || 'topclass',
                template: request.template || 'ppt',
                channelPasswd: request.channelPasswd,
                linkMicLimit: request.linkMicLimit,
                startTime: request.startTime,
                endTime: request.endTime,
            };
            const result = await client.v4Channel.create(createParams);
            return {
                channelId: String(result.channelId),
                name: request.name,
                userId: result.userId || this.authConfig.userId || '',
                channelPasswd: request.channelPasswd || '',
                newScene: request.newScene,
                template: request.template,
                status: 'waiting',
                createdAt: new Date(),
            };
        }
        catch (error) {
            throw this.handleError(error, 'createChannel');
        }
    }
    async listChannels(request = {}) {
        try {
            this.validateListRequest(request);
            const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
            const pageNumber = request.page ?? 1;
            const pageSize = request.limit ?? 20;
            const result = await client.v4Channel.channelDetailList({
                pageNumber,
                pageSize,
            });
            if (!result?.contents || result.contents.length === 0) {
                return [];
            }
            let channels = result.contents;
            if (request.keyword) {
                channels = channels.filter((ch) => ch.name?.toLowerCase().includes(request.keyword.toLowerCase()));
            }
            return channels.map((channel) => ({
                channelId: String(channel.channelId),
                name: channel.name,
                status: this.mapWatchStatus(channel.watchStatus),
                createdAt: new Date(channel.startTime || Date.now()),
                scene: channel.newScene || channel.scene,
                template: channel.template,
                description: '',
                ...(channel.maxViewer && channel.maxViewer > 0 && { maxViewers: channel.maxViewer }),
            }));
        }
        catch (error) {
            throw this.handleError(error, 'listChannels');
        }
    }
    async getChannelDetail(request) {
        try {
            this.validateChannelDetailRequest(request);
            const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
            const result = await client.v4Channel.getChannel({
                channelId: request.channelId,
            });
            return result;
        }
        catch (error) {
            throw this.handleError(error, 'getChannelDetail');
        }
    }
    async updateChannel(request) {
        try {
            this.validateChannelUpdateRequest(request);
            const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
            if (request.basicSetting) {
                await client.channel.updateChannel(request.channelId, this.mapBasicSetting(request.basicSetting));
            }
            return {
                code: 200,
                status: 'success',
                success: true,
                data: null,
            };
        }
        catch (error) {
            throw this.handleError(error, 'updateChannel');
        }
    }
    async deleteChannel(channelId) {
        try {
            this.validateChannelId(channelId);
            const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
            await client.channel.batchDeleteChannels([channelId]);
            return {
                code: 200,
                status: 'success',
                data: true,
            };
        }
        catch (error) {
            throw this.handleError(error, 'deleteChannel');
        }
    }
    async batchDeleteChannels(request) {
        try {
            this.validateBatchDeleteRequest(request);
            const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
            await client.channel.batchDeleteChannels(request.channelIds);
            return {
                code: 200,
                status: 'success',
                data: true,
            };
        }
        catch (error) {
            throw this.handleError(error, 'batchDeleteChannels');
        }
    }
    async checkChannelStatusValid(params) {
        try {
            const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
            return await client.other.checkChannelStatusValid(params);
        }
        catch (error) {
            throw this.handleError(error, 'checkChannelStatusValid');
        }
    }
    async resetCcbFocus(params) {
        try {
            const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
            return await client.other.resetCcbFocus(params);
        }
        catch (error) {
            throw this.handleError(error, 'resetCcbFocus');
        }
    }
    async listChannelViewerGroups(params) {
        try {
            const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
            return await client.channel.listChannelViewerGroups(params);
        }
        catch (error) {
            throw this.handleError(error, 'listChannelViewerGroups');
        }
    }
    async createChannelViewerGroup(params) {
        try {
            const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
            return await client.channel.createChannelViewerGroup(params);
        }
        catch (error) {
            throw this.handleError(error, 'createChannelViewerGroup');
        }
    }
    async updateChannelViewerGroup(params) {
        try {
            const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
            return await client.channel.updateChannelViewerGroup(params);
        }
        catch (error) {
            throw this.handleError(error, 'updateChannelViewerGroup');
        }
    }
    async deleteChannelViewerGroup(params) {
        try {
            const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
            return await client.channel.deleteChannelViewerGroup(params);
        }
        catch (error) {
            throw this.handleError(error, 'deleteChannelViewerGroup');
        }
    }
    async getChannelViewerGroupSetting(params) {
        try {
            const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
            return await client.channel.getChannelViewerGroupSetting(params);
        }
        catch (error) {
            throw this.handleError(error, 'getChannelViewerGroupSetting');
        }
    }
    async updateChannelViewerGroupSetting(params) {
        try {
            const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
            return await client.channel.updateChannelViewerGroupSetting(params);
        }
        catch (error) {
            throw this.handleError(error, 'updateChannelViewerGroupSetting');
        }
    }
    async listChannelViewers(params) {
        try {
            const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
            return await client.channel.listChannelViewers(params);
        }
        catch (error) {
            throw this.handleError(error, 'listChannelViewers');
        }
    }
    async exportChannelViewers(params) {
        try {
            const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
            return await client.channel.exportChannelViewers(params);
        }
        catch (error) {
            throw this.handleError(error, 'exportChannelViewers');
        }
    }
    async addChannelViewers(params) {
        try {
            const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
            return await client.channel.addChannelViewers(params);
        }
        catch (error) {
            throw this.handleError(error, 'addChannelViewers');
        }
    }
    async deleteChannelViewers(params) {
        try {
            const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
            return await client.channel.deleteChannelViewers(params);
        }
        catch (error) {
            throw this.handleError(error, 'deleteChannelViewers');
        }
    }
    async transferChannelViewers(params) {
        try {
            const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
            return await client.channel.transferChannelViewers(params);
        }
        catch (error) {
            throw this.handleError(error, 'transferChannelViewers');
        }
    }
    async importChannelViewers(params) {
        try {
            const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
            return await client.channel.importChannelViewers(params);
        }
        catch (error) {
            throw this.handleError(error, 'importChannelViewers');
        }
    }
    async listUnrelatedChannelViewers(params) {
        try {
            const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
            return await client.channel.listUnrelatedChannelViewers(params);
        }
        catch (error) {
            throw this.handleError(error, 'listUnrelatedChannelViewers');
        }
    }
    async getAccount(channelId, account) {
        try {
            const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
            return await client.channel.getAccount(channelId, account);
        }
        catch (error) {
            throw this.handleError(error, 'getAccount');
        }
    }
    async getAccounts(channelId) {
        try {
            const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
            return await client.channel.getAccounts(channelId);
        }
        catch (error) {
            throw this.handleError(error, 'getAccounts');
        }
    }
    async deleteAccount(channelId, account) {
        try {
            const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
            return await client.channel.deleteAccount(channelId, account);
        }
        catch (error) {
            throw this.handleError(error, 'deleteAccount');
        }
    }
    async batchCreateAccounts(channelId, accounts) {
        try {
            const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
            return await client.channel.batchCreateAccounts(channelId, accounts);
        }
        catch (error) {
            throw this.handleError(error, 'batchCreateAccounts');
        }
    }
    async getChannelAdverts(channelId) {
        try {
            const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
            return await client.channel.getChannelAdverts(channelId);
        }
        catch (error) {
            throw this.handleError(error, 'getChannelAdverts');
        }
    }
    async getCallbackSetting(channelId) {
        try {
            const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
            return await client.channel.getCallbackSetting(channelId);
        }
        catch (error) {
            throw this.handleError(error, 'getCallbackSetting');
        }
    }
    async updateCallbackSetting(channelId, options) {
        try {
            const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
            return await client.channel.updateCallbackSetting(channelId, options);
        }
        catch (error) {
            throw this.handleError(error, 'updateCallbackSetting');
        }
    }
    async getPptRecordSetting(channelId) {
        try {
            const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
            return await client.channel.getPptRecordSetting(channelId);
        }
        catch (error) {
            throw this.handleError(error, 'getPptRecordSetting');
        }
    }
    async listPptRecordTasks(params) {
        try {
            const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
            return await client.channel.listPptRecordTasks(params);
        }
        catch (error) {
            throw this.handleError(error, 'listPptRecordTasks');
        }
    }
    async addPptRecordTask(params) {
        try {
            const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
            return await client.channel.addPptRecordTask(params);
        }
        catch (error) {
            throw this.handleError(error, 'addPptRecordTask');
        }
    }
    async updatePptRecordSetting(params) {
        try {
            const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
            return await client.channel.updatePptRecordSetting(params);
        }
        catch (error) {
            throw this.handleError(error, 'updatePptRecordSetting');
        }
    }
    async deletePptRecord(params) {
        try {
            const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
            return await client.channel.deletePptRecord(params);
        }
        catch (error) {
            throw this.handleError(error, 'deletePptRecord');
        }
    }
    async copyChannel(channelId, options) {
        try {
            const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
            return await client.channel.copyChannel(channelId, options);
        }
        catch (error) {
            throw this.handleError(error, 'copyChannel');
        }
    }
    async getUserChildrenChannels(params) {
        try {
            const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
            return await client.channel.getUserChildrenChannels(params);
        }
        catch (error) {
            throw this.handleError(error, 'getUserChildrenChannels');
        }
    }
    async getWatchApiToken(params) {
        try {
            const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
            return await client.channel.getWatchApiToken(params);
        }
        catch (error) {
            throw this.handleError(error, 'getWatchApiToken');
        }
    }
    async getApiToken(params) {
        try {
            const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
            return await client.channel.getApiToken(params);
        }
        catch (error) {
            throw this.handleError(error, 'getApiToken');
        }
    }
    async getTokenLoginUrl(params) {
        try {
            const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
            return await client.channel.getTokenLoginUrl(params);
        }
        catch (error) {
            throw this.handleError(error, 'getTokenLoginUrl');
        }
    }
    async getChatToken(params) {
        try {
            const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
            return await client.channel.getChatToken(params);
        }
        catch (error) {
            throw this.handleError(error, 'getChatToken');
        }
    }
    async listChannelsFollow(params) {
        try {
            const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
            return await client.channel.listChannelsFollow(params);
        }
        catch (error) {
            throw this.handleError(error, 'listChannelsFollow');
        }
    }
    async updateChannelsFollow(params) {
        try {
            const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
            return await client.channel.updateChannelsFollow(params);
        }
        catch (error) {
            throw this.handleError(error, 'updateChannelsFollow');
        }
    }
    async batchAddSubmeeting(params) {
        try {
            const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
            return await client.channel.batchAddSubmeeting(params);
        }
        catch (error) {
            throw this.handleError(error, 'batchAddSubmeeting');
        }
    }
    async channelsStopQuestionnaire(params) {
        try {
            const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
            return await client.channel.channelsStopQuestionnaire(params);
        }
        catch (error) {
            throw this.handleError(error, 'channelsStopQuestionnaire');
        }
    }
    async batchUpdateDanmu(params) {
        try {
            const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
            return await client.channel.batchUpdateDanmu(params);
        }
        catch (error) {
            throw this.handleError(error, 'batchUpdateDanmu');
        }
    }
    async setChannelToken(params) {
        try {
            const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
            return await client.channel.setChannelToken(params);
        }
        catch (error) {
            throw this.handleError(error, 'setChannelToken');
        }
    }
    async setAccountToken(params) {
        try {
            const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
            return await client.channel.setAccountToken(params);
        }
        catch (error) {
            throw this.handleError(error, 'setAccountToken');
        }
    }
    async setMaxViewer(channelId, userId, maxViewer) {
        try {
            const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
            return await client.channel.setMaxViewer(channelId, userId, maxViewer);
        }
        catch (error) {
            throw this.handleError(error, 'setMaxViewer');
        }
    }
    async updateChannelPassword(userId, passwd, channelId) {
        try {
            const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
            return await client.channel.updateChannelPassword(userId, passwd, channelId);
        }
        catch (error) {
            throw this.handleError(error, 'updateChannelPassword');
        }
    }
    async setDiyUrlMarquee(params) {
        try {
            const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
            return await client.channel.setDiyUrlMarquee(params);
        }
        catch (error) {
            throw this.handleError(error, 'setDiyUrlMarquee');
        }
    }
    async listAllChannelBasic(params = {}) {
        const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
        return client.v4Channel.listAllChannelBasic(params);
    }
    async listChannelSimple(params = {}) {
        const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
        return client.v4Channel.listChannelSimple(params);
    }
    async listLiveStatus(params) {
        const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
        return client.v4Channel.listLiveStatus(params);
    }
    async getAccountViewerConfig(params) {
        const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
        return client.v4Channel.getAccountViewerConfig(params);
    }
    async updateAccountViewerConfig(params) {
        const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
        return client.v4Channel.updateAccountViewerConfig(params);
    }
    async getByRole(params) {
        const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
        return client.v4Channel.getByRole(params);
    }
    async updateByRole(params) {
        const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
        return client.v4Channel.updateByRole(params);
    }
    async createAccount(params) {
        const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
        return client.v4Channel.createAccount(params);
    }
    async updateAccountInfo(params) {
        const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
        return client.v4Channel.updateAccountInfo(params);
    }
    async deleteAccountsBatch(params) {
        const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
        return client.v4Channel.deleteAccountsBatch(params);
    }
    async teacherList(params) {
        const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
        return client.v4Channel.teacherList(params);
    }
    async getSubtitleConfig(params) {
        const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
        return client.v4Channel.getSubtitleConfig(params);
    }
    async updateSubtitleConfig(params) {
        const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
        return client.v4Channel.updateSubtitleConfig(params);
    }
    async listSubtitleLanguages() {
        const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
        return client.v4Channel.listSubtitleLanguages();
    }
    async distributeList(params) {
        const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
        return client.v4Channel.distributeList(params);
    }
    async distributeCreateBatch(params) {
        const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
        return client.v4Channel.distributeCreateBatch(params);
    }
    async distributeUpdateBatch(params) {
        const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
        return client.v4Channel.distributeUpdateBatch(params);
    }
    async distributeDeleteBatch(params) {
        const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
        return client.v4Channel.distributeDeleteBatch(params);
    }
    async getDistributeStatistic(params) {
        const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
        return client.v4Channel.getDistributeStatistic(params);
    }
    async updateMasterSwitch(params) {
        const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
        return client.v4Channel.updateMasterSwitch(params);
    }
    async updateSwitch(params) {
        const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
        return client.v4Channel.updateSwitch(params);
    }
    async createInit(params) {
        const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
        return client.v4Channel.createInit(params);
    }
    async createMrChannel(params) {
        const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
        return client.v4Channel.createMrChannel(params);
    }
    async setPullBitrate(params) {
        const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
        return client.v4Channel.setPullBitrate(params);
    }
    async updateTemplate(params) {
        const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
        return client.v4Channel.updateTemplate(params);
    }
    async getChannelApiAccessToken(params) {
        const { channelId, ...options } = params;
        const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
        return client.channel.getChannelApiAccessToken(channelId, this.compactOptions(options));
    }
    async getTestModeToken(params) {
        const { channelId, ...options } = params;
        const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
        return client.channel.getTestModeToken(channelId, this.compactOptions(options));
    }
    async createBatch(params) {
        const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
        return client.v4Channel.createBatch(params);
    }
    async updateV4(params) {
        const client = (0, sdk_1.createSdkClient)(this.authConfig, this.config.baseUrl);
        return client.v4Channel.update(params);
    }
    validateCreateRequest(request) {
        const errors = [];
        if (!request.name || typeof request.name !== 'string') {
            errors.push('Channel name is required and must be a string');
        }
        else if (request.name.length === 0) {
            errors.push('Channel name cannot be empty');
        }
        else if (request.name.length > 100) {
            errors.push('Channel name cannot exceed 100 characters');
        }
        if (!request.newScene || !['topclass', 'alone', 'seminar', 'train', 'double', 'guide'].includes(request.newScene)) {
            errors.push('newScene must be one of: topclass, alone, seminar, train, double, guide');
        }
        if (!request.template || !['ppt', 'portrait_ppt', 'alone', 'portrait_alone', 'topclass', 'portrait_topclass', 'seminar'].includes(request.template)) {
            errors.push('template must be one of: ppt, portrait_ppt, alone, portrait_alone, topclass, portrait_topclass, seminar');
        }
        if (errors.length > 0) {
            throw new errors_1.PolyVValidationError(`Channel creation request validation failed: ${errors.join(', ')}`, 'request', request, 'validation_failed');
        }
    }
    validateListRequest(request) {
        const errors = [];
        if (request.page !== undefined && (typeof request.page !== 'number' || request.page < 1)) {
            errors.push('page must be a positive integer (minimum 1)');
        }
        if (request.limit !== undefined && (typeof request.limit !== 'number' || request.limit < 1 || request.limit > 100)) {
            errors.push('limit must be an integer between 1 and 100');
        }
        if (errors.length > 0) {
            throw new errors_1.PolyVValidationError(`Channel list request validation failed: ${errors.join(', ')}`, 'request', request, 'validation_failed');
        }
    }
    validateChannelDetailRequest(request) {
        if (!request.channelId || typeof request.channelId !== 'string') {
            throw new errors_1.PolyVValidationError('channelId is required and must be a string', 'channelId', request, 'validation_failed');
        }
    }
    validateChannelUpdateRequest(request) {
        const errors = [];
        if (!request.channelId || typeof request.channelId !== 'string') {
            errors.push('channelId is required and must be a string');
        }
        if (!request.basicSetting && !request.authSettings) {
            errors.push('at least one update field must be provided');
        }
        if (errors.length > 0) {
            throw new errors_1.PolyVValidationError(`Channel update request validation failed: ${errors.join(', ')}`, 'request', request, 'validation_failed');
        }
    }
    validateChannelId(channelId) {
        if (!channelId || typeof channelId !== 'string') {
            throw new errors_1.PolyVValidationError('channelId is required and must be a string', 'channelId', channelId, 'validation_failed');
        }
    }
    validateBatchDeleteRequest(request) {
        if (!request.channelIds || !Array.isArray(request.channelIds) || request.channelIds.length === 0) {
            throw new errors_1.PolyVValidationError('channelIds is required and must be a non-empty array', 'channelIds', request, 'validation_failed');
        }
    }
    mapWatchStatus(status) {
        const statusMap = {
            'waiting': 'waiting',
            'living': 'live',
            'live': 'live',
            'end': 'end',
            'ended': 'end',
            'unStart': 'unStart',
        };
        return statusMap[status] || 'waiting';
    }
    mapBasicSetting(setting) {
        const result = {};
        if ('name' in setting && setting.name !== undefined)
            result['name'] = setting['name'];
        if ('channelPasswd' in setting && setting['channelPasswd'] !== undefined)
            result['channelPasswd'] = setting['channelPasswd'];
        if ('publisher' in setting && setting['publisher'] !== undefined)
            result['publisher'] = setting['publisher'];
        if ('desc' in setting && setting['desc'] !== undefined)
            result['desc'] = setting['desc'];
        if ('startTime' in setting && setting['startTime'] !== undefined)
            result['startTime'] = setting['startTime'];
        if ('endTime' in setting && setting['endTime'] !== undefined)
            result['endTime'] = setting['endTime'];
        if ('pageView' in setting && setting['pageView'] !== undefined)
            result['pageView'] = setting['pageView'];
        if ('likes' in setting && setting['likes'] !== undefined)
            result['likes'] = setting['likes'];
        if ('coverImg' in setting && setting['coverImg'] !== undefined)
            result['coverImg'] = setting['coverImg'];
        if ('splashImg' in setting && setting['splashImg'] !== undefined)
            result['splashImg'] = setting['splashImg'];
        if ('maxViewer' in setting && setting['maxViewer'] !== undefined)
            result['maxViewer'] = setting['maxViewer'];
        if ('maxViewerRestrict' in setting && setting['maxViewerRestrict'] !== undefined)
            result['maxViewerRestrict'] = setting['maxViewerRestrict'];
        return result;
    }
    compactOptions(params) {
        return Object.fromEntries(Object.entries(params).filter(([, value]) => value !== undefined && value !== ''));
    }
    handleError(error, operation) {
        if (this.config.debug) {
            console.error(`[ChannelServiceSdk] Error in ${operation}:`, error);
        }
        if (error instanceof errors_1.PolyVError || error instanceof errors_1.PolyVAPIError || error instanceof errors_1.PolyVValidationError) {
            return error;
        }
        if (error instanceof Error) {
            const anyError = error;
            if (anyError.polyvCode || anyError.code) {
                return new errors_1.PolyVAPIError(error.message, anyError.code || 'API_ERROR', anyError.status || 500, {
                    polyvCode: anyError.polyvCode,
                    polyvMessage: anyError.polyvMessage || error.message,
                });
            }
            return new errors_1.PolyVError(`Failed to ${operation}: ${error.message}`, 'CHANNEL_SERVICE_ERROR', 500, { originalError: error.message });
        }
        return new errors_1.PolyVError(`Failed to ${operation}: Unknown error`, 'UNKNOWN_ERROR', 500, { originalError: String(error) });
    }
}
exports.ChannelServiceSdk = ChannelServiceSdk;
//# sourceMappingURL=channel.service.sdk.js.map