@memberjunction/actions-bizapps-social 2.61.0

package/src/providers/youtube/actions/get-channel-videos.action.ts

@@ -0,0 +1,286 @@
+import { RegisterClass } from '@memberjunction/global';
+import { YouTubeBaseAction } from '../youtube-base.action';
+import { ActionParam, ActionResultSimple, RunActionParams } from '@memberjunction/actions-base';
+import { SocialPost } from '../../../base/base-social.action';
+
+/**
+ * Action to get videos from a YouTube channel
+ */
+@RegisterClass(YouTubeBaseAction, 'YouTubeGetChannelVideosAction')
+export class YouTubeGetChannelVideosAction extends YouTubeBaseAction {
+    /**
+     * Get videos from a YouTube channel
+     */
+    protected async InternalRunAction(params: RunActionParams): Promise<ActionResultSimple> {
+        const { Params, ContextUser } = params;
+        
+        try {
+            // Initialize OAuth
+            const companyIntegrationId = this.getParamValue(Params, 'CompanyIntegrationID');
+            if (!companyIntegrationId) {
+                throw new Error('CompanyIntegrationID is required');
+            }
+
+            const initialized = await this.initializeOAuth(companyIntegrationId);
+            if (!initialized) {
+                throw new Error('Failed to initialize YouTube OAuth connection');
+            }
+
+            // Extract parameters
+            const channelId = this.getParamValue(Params, 'ChannelID') || this.getCustomAttribute(1);
+            const maxResults = this.getParamValue(Params, 'MaxResults') || 50;
+            const orderBy = this.getParamValue(Params, 'OrderBy') || 'date';
+            const publishedAfter = this.getParamValue(Params, 'PublishedAfter');
+            const publishedBefore = this.getParamValue(Params, 'PublishedBefore');
+            const includePrivate = this.getParamValue(Params, 'IncludePrivate') || false;
+            const videoType = this.getParamValue(Params, 'VideoType') || 'any';
+            const videoDuration = this.getParamValue(Params, 'VideoDuration') || 'any';
+            const pageToken = this.getParamValue(Params, 'PageToken');
+
+            // If no channel ID provided, get the authenticated user's channel
+            let actualChannelId = channelId;
+            if (!actualChannelId) {
+                const channelResponse = await this.makeYouTubeRequest<any>(
+                    '/channels',
+                    'GET',
+                    undefined,
+                    {
+                        part: 'id,snippet',
+                        mine: true
+                    },
+                    ContextUser
+                );
+
+                if (!channelResponse.items || channelResponse.items.length === 0) {
+                    throw new Error('No channel found for authenticated user');
+                }
+                actualChannelId = channelResponse.items[0].id;
+            }
+
+            // Build search parameters
+            const searchParams: any = {
+                part: 'id,snippet',
+                channelId: actualChannelId,
+                type: 'video',
+                maxResults: Math.min(maxResults, 50), // YouTube max is 50
+                order: orderBy
+            };
+
+            // Add date filters
+            if (publishedAfter) {
+                searchParams.publishedAfter = this.formatDate(publishedAfter);
+            }
+            if (publishedBefore) {
+                searchParams.publishedBefore = this.formatDate(publishedBefore);
+            }
+
+            // Add video type filter
+            if (videoType !== 'any') {
+                searchParams.videoType = videoType; // 'episode' or 'movie'
+            }
+
+            // Add duration filter
+            if (videoDuration !== 'any') {
+                searchParams.videoDuration = videoDuration; // 'short', 'medium', 'long'
+            }
+
+            // Add pagination token
+            if (pageToken) {
+                searchParams.pageToken = pageToken;
+            }
+
+            // Search for videos
+            const searchResponse = await this.makeYouTubeRequest<any>(
+                '/search',
+                'GET',
+                undefined,
+                searchParams,
+                ContextUser
+            );
+
+            // Extract video IDs
+            const videoIds = searchResponse.items.map((item: any) => item.id.videoId);
+
+            if (videoIds.length === 0) {
+                // No videos found
+                const outputParams = [...Params];
+                const videosParam = outputParams.find(p => p.Name === 'Videos');
+                if (videosParam) videosParam.Value = [];
+                const summaryParam = outputParams.find(p => p.Name === 'Summary');
+                if (summaryParam) summaryParam.Value = { totalVideos: 0, channelId: actualChannelId };
+
+                return {
+                    Success: true,
+                    ResultCode: 'SUCCESS',
+                    Message: 'No videos found for the specified criteria',
+                    Params: outputParams
+                };
+            }
+
+            // Get detailed video information
+            const videosResponse = await this.makeYouTubeRequest<any>(
+                '/videos',
+                'GET',
+                undefined,
+                {
+                    part: 'snippet,contentDetails,statistics,status',
+                    id: videoIds.join(',')
+                },
+                ContextUser
+            );
+
+            // Filter out private videos if not requested
+            let videos = videosResponse.items;
+            if (!includePrivate) {
+                videos = videos.filter((v: any) => v.status.privacyStatus !== 'private');
+            }
+
+            // Convert to social posts
+            const socialPosts: SocialPost[] = videos.map((video: any) => this.normalizePost(video));
+
+            // Calculate summary statistics
+            const summary = {
+                totalVideos: videos.length,
+                channelId: actualChannelId,
+                totalViews: videos.reduce((sum: number, v: any) => sum + parseInt(v.statistics.viewCount || '0'), 0),
+                totalLikes: videos.reduce((sum: number, v: any) => sum + parseInt(v.statistics.likeCount || '0'), 0),
+                totalComments: videos.reduce((sum: number, v: any) => sum + parseInt(v.statistics.commentCount || '0'), 0),
+                averageViews: Math.round(videos.reduce((sum: number, v: any) => sum + parseInt(v.statistics.viewCount || '0'), 0) / videos.length),
+                dateRange: {
+                    oldest: videos.length > 0 ? videos[videos.length - 1].snippet.publishedAt : null,
+                    newest: videos.length > 0 ? videos[0].snippet.publishedAt : null
+                },
+                privacyBreakdown: this.groupByPrivacy(videos),
+                nextPageToken: searchResponse.nextPageToken,
+                prevPageToken: searchResponse.prevPageToken,
+                quotaCost: this.getQuotaCost('search.list') + this.getQuotaCost('videos.list')
+            };
+
+            // Update output parameters
+            const outputParams = [...Params];
+            const videosParam = outputParams.find(p => p.Name === 'Videos');
+            if (videosParam) videosParam.Value = socialPosts;
+            const summaryParam = outputParams.find(p => p.Name === 'Summary');
+            if (summaryParam) summaryParam.Value = summary;
+            const nextPageTokenParam = outputParams.find(p => p.Name === 'NextPageToken');
+            if (nextPageTokenParam) nextPageTokenParam.Value = searchResponse.nextPageToken;
+
+            return {
+                Success: true,
+                ResultCode: 'SUCCESS',
+                Message: `Retrieved ${videos.length} videos from channel`,
+                Params: outputParams
+            };
+
+        } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            
+            return {
+                Success: false,
+                ResultCode: this.getErrorCode(errorMessage),
+                Message: `Failed to get channel videos: ${errorMessage}`,
+                Params
+            };
+        }
+    }
+
+    /**
+     * Group videos by privacy status
+     */
+    private groupByPrivacy(videos: any[]): Record<string, number> {
+        return videos.reduce((acc, video) => {
+            const privacy = video.status.privacyStatus;
+            acc[privacy] = (acc[privacy] || 0) + 1;
+            return acc;
+        }, {});
+    }
+
+    /**
+     * Get error code from error message
+     */
+    private getErrorCode(message: string): string {
+        if (message.includes('quota')) return 'QUOTA_EXCEEDED';
+        if (message.includes('401') || message.includes('unauthorized')) return 'INVALID_TOKEN';
+        if (message.includes('403') || message.includes('forbidden')) return 'INSUFFICIENT_PERMISSIONS';
+        if (message.includes('404')) return 'NOT_FOUND';
+        if (message.includes('rate limit')) return 'RATE_LIMIT';
+        return 'ERROR';
+    }
+
+    /**
+     * Define the parameters this action expects
+     */
+    public get Params(): ActionParam[] {
+        const baseParams = this.commonSocialParams;
+        const specificParams: ActionParam[] = [
+            {
+                Name: 'ChannelID',
+                Type: 'Input',
+                Value: null
+            },
+            {
+                Name: 'MaxResults',
+                Type: 'Input',
+                Value: 50
+            },
+            {
+                Name: 'OrderBy',
+                Type: 'Input',
+                Value: 'date'
+            },
+            {
+                Name: 'PublishedAfter',
+                Type: 'Input',
+                Value: null
+            },
+            {
+                Name: 'PublishedBefore',
+                Type: 'Input',
+                Value: null
+            },
+            {
+                Name: 'IncludePrivate',
+                Type: 'Input',
+                Value: false
+            },
+            {
+                Name: 'VideoType',
+                Type: 'Input',
+                Value: 'any'
+            },
+            {
+                Name: 'VideoDuration',
+                Type: 'Input',
+                Value: 'any'
+            },
+            {
+                Name: 'PageToken',
+                Type: 'Input',
+                Value: null
+            },
+            {
+                Name: 'Videos',
+                Type: 'Output',
+                Value: null
+            },
+            {
+                Name: 'Summary',
+                Type: 'Output',
+                Value: null
+            },
+            {
+                Name: 'NextPageToken',
+                Type: 'Output',
+                Value: null
+            }
+        ];
+        return [...baseParams, ...specificParams];
+    }
+
+    /**
+     * Metadata about this action
+     */
+    public get Description(): string {
+        return 'Gets videos from a YouTube channel with filtering and pagination support';
+    }
+}

package/src/providers/youtube/actions/get-comments.action.ts

@@ -0,0 +1,411 @@
+import { RegisterClass } from '@memberjunction/global';
+import { YouTubeBaseAction } from '../youtube-base.action';
+import { ActionParam, ActionResultSimple, RunActionParams } from '@memberjunction/actions-base';
+
+/**
+ * Action to get comments from YouTube videos
+ */
+@RegisterClass(YouTubeBaseAction, 'YouTubeGetCommentsAction')
+export class YouTubeGetCommentsAction extends YouTubeBaseAction {
+    /**
+     * Get comments from YouTube videos
+     */
+    protected async InternalRunAction(params: RunActionParams): Promise<ActionResultSimple> {
+        const { Params, ContextUser } = params;
+        
+        try {
+            // Initialize OAuth
+            const companyIntegrationId = this.getParamValue(Params, 'CompanyIntegrationID');
+            if (!companyIntegrationId) {
+                throw new Error('CompanyIntegrationID is required');
+            }
+
+            const initialized = await this.initializeOAuth(companyIntegrationId);
+            if (!initialized) {
+                throw new Error('Failed to initialize YouTube OAuth connection');
+            }
+
+            // Extract parameters
+            const videoId = this.getParamValue(Params, 'VideoID');
+            const channelId = this.getParamValue(Params, 'ChannelID');
+            const maxResults = this.getParamValue(Params, 'MaxResults') || 100;
+            const orderBy = this.getParamValue(Params, 'OrderBy') || 'time';
+            const searchTerms = this.getParamValue(Params, 'SearchTerms');
+            const includeReplies = this.getParamValue(Params, 'IncludeReplies') ?? true;
+            const textFormat = this.getParamValue(Params, 'TextFormat') || 'plainText';
+            const pageToken = this.getParamValue(Params, 'PageToken');
+
+            // Validate parameters - need either videoId or channelId
+            if (!videoId && !channelId) {
+                throw new Error('Either VideoID or ChannelID is required');
+            }
+
+            // Build request parameters
+            const requestParams: any = {
+                part: 'snippet,replies',
+                maxResults: Math.min(maxResults, 100), // YouTube max is 100
+                order: orderBy,
+                textFormat: textFormat
+            };
+
+            if (videoId) {
+                requestParams.videoId = videoId;
+            } else if (channelId) {
+                requestParams.allThreadsRelatedToChannelId = channelId;
+            }
+
+            if (searchTerms) {
+                requestParams.searchTerms = searchTerms;
+            }
+
+            if (pageToken) {
+                requestParams.pageToken = pageToken;
+            }
+
+            // Get comment threads
+            const commentsResponse = await this.makeYouTubeRequest<any>(
+                '/commentThreads',
+                'GET',
+                undefined,
+                requestParams,
+                ContextUser
+            );
+
+            // Process comments
+            const comments = this.processComments(commentsResponse.items || [], includeReplies);
+
+            // Get video details if videoId provided
+            let videoDetails = null;
+            if (videoId) {
+                const videoResponse = await this.makeYouTubeRequest<any>(
+                    '/videos',
+                    'GET',
+                    undefined,
+                    {
+                        part: 'snippet,statistics',
+                        id: videoId
+                    },
+                    ContextUser
+                );
+                if (videoResponse.items && videoResponse.items.length > 0) {
+                    videoDetails = videoResponse.items[0];
+                }
+            }
+
+            // Calculate statistics
+            const stats = this.calculateCommentStats(comments);
+
+            // Prepare summary
+            const summary = {
+                totalComments: comments.length,
+                totalThreads: commentsResponse.items?.length || 0,
+                statistics: stats,
+                videoDetails: videoDetails ? {
+                    id: videoDetails.id,
+                    title: videoDetails.snippet.title,
+                    channelId: videoDetails.snippet.channelId,
+                    channelTitle: videoDetails.snippet.channelTitle,
+                    viewCount: parseInt(videoDetails.statistics.viewCount || '0'),
+                    commentCount: parseInt(videoDetails.statistics.commentCount || '0')
+                } : null,
+                sentiment: this.analyzeSentiment(comments),
+                topCommenters: this.getTopCommenters(comments),
+                nextPageToken: commentsResponse.nextPageToken,
+                prevPageToken: commentsResponse.prevPageToken,
+                quotaCost: this.getQuotaCost('commentThreads.list') + (videoId ? this.getQuotaCost('videos.list') : 0)
+            };
+
+            // Update output parameters
+            const outputParams = [...Params];
+            const commentsParam = outputParams.find(p => p.Name === 'Comments');
+            if (commentsParam) commentsParam.Value = comments;
+            const summaryParam = outputParams.find(p => p.Name === 'Summary');
+            if (summaryParam) summaryParam.Value = summary;
+            const nextPageTokenParam = outputParams.find(p => p.Name === 'NextPageToken');
+            if (nextPageTokenParam) nextPageTokenParam.Value = commentsResponse.nextPageToken;
+
+            return {
+                Success: true,
+                ResultCode: 'SUCCESS',
+                Message: `Retrieved ${comments.length} comments from ${commentsResponse.items?.length || 0} threads`,
+                Params: outputParams
+            };
+
+        } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            
+            return {
+                Success: false,
+                ResultCode: this.getErrorCode(errorMessage),
+                Message: `Failed to get comments: ${errorMessage}`,
+                Params
+            };
+        }
+    }
+
+    /**
+     * Process raw comment threads into a flat array
+     */
+    private processComments(threads: any[], includeReplies: boolean): any[] {
+        const comments: any[] = [];
+
+        for (const thread of threads) {
+            const topComment = thread.snippet.topLevelComment;
+            
+            // Add top-level comment
+            comments.push({
+                id: topComment.id,
+                threadId: thread.id,
+                text: topComment.snippet.textDisplay,
+                authorDisplayName: topComment.snippet.authorDisplayName,
+                authorChannelId: topComment.snippet.authorChannelId?.value,
+                authorProfileImageUrl: topComment.snippet.authorProfileImageUrl,
+                likeCount: topComment.snippet.likeCount,
+                publishedAt: topComment.snippet.publishedAt,
+                updatedAt: topComment.snippet.updatedAt,
+                isTopLevel: true,
+                replyCount: thread.snippet.totalReplyCount,
+                videoId: topComment.snippet.videoId,
+                canReply: thread.snippet.canReply,
+                isPublic: thread.snippet.isPublic
+            });
+
+            // Add replies if requested and available
+            if (includeReplies && thread.replies?.comments) {
+                for (const reply of thread.replies.comments) {
+                    comments.push({
+                        id: reply.id,
+                        threadId: thread.id,
+                        parentId: topComment.id,
+                        text: reply.snippet.textDisplay,
+                        authorDisplayName: reply.snippet.authorDisplayName,
+                        authorChannelId: reply.snippet.authorChannelId?.value,
+                        authorProfileImageUrl: reply.snippet.authorProfileImageUrl,
+                        likeCount: reply.snippet.likeCount,
+                        publishedAt: reply.snippet.publishedAt,
+                        updatedAt: reply.snippet.updatedAt,
+                        isTopLevel: false,
+                        videoId: reply.snippet.videoId
+                    });
+                }
+            }
+        }
+
+        return comments;
+    }
+
+    /**
+     * Calculate comment statistics
+     */
+    private calculateCommentStats(comments: any[]): any {
+        const stats = {
+            totalLikes: 0,
+            averageLikes: 0,
+            topLevelComments: 0,
+            replies: 0,
+            commentersCount: new Set(),
+            averageCommentLength: 0,
+            longestComment: 0,
+            shortestComment: Infinity
+        };
+
+        let totalLength = 0;
+
+        for (const comment of comments) {
+            stats.totalLikes += comment.likeCount || 0;
+            if (comment.isTopLevel) {
+                stats.topLevelComments++;
+            } else {
+                stats.replies++;
+            }
+            
+            if (comment.authorChannelId) {
+                stats.commentersCount.add(comment.authorChannelId);
+            }
+
+            const length = comment.text.length;
+            totalLength += length;
+            stats.longestComment = Math.max(stats.longestComment, length);
+            stats.shortestComment = Math.min(stats.shortestComment, length);
+        }
+
+        stats.averageLikes = comments.length > 0 ? Math.round(stats.totalLikes / comments.length * 100) / 100 : 0;
+        stats.averageCommentLength = comments.length > 0 ? Math.round(totalLength / comments.length) : 0;
+
+        return {
+            totalLikes: stats.totalLikes,
+            averageLikes: stats.averageLikes,
+            topLevelComments: stats.topLevelComments,
+            replies: stats.replies,
+            uniqueCommenters: stats.commentersCount.size,
+            averageCommentLength: stats.averageCommentLength,
+            longestComment: stats.longestComment,
+            shortestComment: stats.shortestComment === Infinity ? 0 : stats.shortestComment
+        };
+    }
+
+    /**
+     * Basic sentiment analysis (simplified)
+     */
+    private analyzeSentiment(comments: any[]): any {
+        const positiveWords = ['love', 'great', 'amazing', 'awesome', 'excellent', 'fantastic', 'wonderful', 'best', 'perfect', 'thank'];
+        const negativeWords = ['hate', 'bad', 'terrible', 'awful', 'worst', 'horrible', 'disgusting', 'trash', 'waste', 'dislike'];
+        
+        let positive = 0;
+        let negative = 0;
+        let neutral = 0;
+
+        for (const comment of comments) {
+            const text = comment.text.toLowerCase();
+            let hasPositive = false;
+            let hasNegative = false;
+
+            for (const word of positiveWords) {
+                if (text.includes(word)) {
+                    hasPositive = true;
+                    break;
+                }
+            }
+
+            for (const word of negativeWords) {
+                if (text.includes(word)) {
+                    hasNegative = true;
+                    break;
+                }
+            }
+
+            if (hasPositive && !hasNegative) {
+                positive++;
+            } else if (hasNegative && !hasPositive) {
+                negative++;
+            } else {
+                neutral++;
+            }
+        }
+
+        const total = comments.length || 1;
+        return {
+            positive: positive,
+            negative: negative,
+            neutral: neutral,
+            positivePercentage: Math.round((positive / total) * 100),
+            negativePercentage: Math.round((negative / total) * 100),
+            neutralPercentage: Math.round((neutral / total) * 100)
+        };
+    }
+
+    /**
+     * Get top commenters by frequency
+     */
+    private getTopCommenters(comments: any[]): any[] {
+        const commenterMap = new Map<string, any>();
+
+        for (const comment of comments) {
+            if (!comment.authorChannelId) continue;
+
+            const key = comment.authorChannelId;
+            if (!commenterMap.has(key)) {
+                commenterMap.set(key, {
+                    channelId: comment.authorChannelId,
+                    displayName: comment.authorDisplayName,
+                    profileImage: comment.authorProfileImageUrl,
+                    commentCount: 0,
+                    totalLikes: 0
+                });
+            }
+
+            const commenter = commenterMap.get(key);
+            commenter.commentCount++;
+            commenter.totalLikes += comment.likeCount || 0;
+        }
+
+        return Array.from(commenterMap.values())
+            .sort((a, b) => b.commentCount - a.commentCount)
+            .slice(0, 10);
+    }
+
+    /**
+     * Get error code from error message
+     */
+    private getErrorCode(message: string): string {
+        if (message.includes('quota')) return 'QUOTA_EXCEEDED';
+        if (message.includes('401') || message.includes('unauthorized')) return 'INVALID_TOKEN';
+        if (message.includes('403') || message.includes('forbidden')) return 'INSUFFICIENT_PERMISSIONS';
+        if (message.includes('404')) return 'NOT_FOUND';
+        if (message.includes('rate limit')) return 'RATE_LIMIT';
+        if (message.includes('disabled')) return 'COMMENTS_DISABLED';
+        return 'ERROR';
+    }
+
+    /**
+     * Define the parameters this action expects
+     */
+    public get Params(): ActionParam[] {
+        const baseParams = this.commonSocialParams;
+        const specificParams: ActionParam[] = [
+            {
+                Name: 'VideoID',
+                Type: 'Input',
+                Value: null
+            },
+            {
+                Name: 'ChannelID',
+                Type: 'Input',
+                Value: null
+            },
+            {
+                Name: 'MaxResults',
+                Type: 'Input',
+                Value: 100
+            },
+            {
+                Name: 'OrderBy',
+                Type: 'Input',
+                Value: 'time'
+            },
+            {
+                Name: 'SearchTerms',
+                Type: 'Input',
+                Value: null
+            },
+            {
+                Name: 'IncludeReplies',
+                Type: 'Input',
+                Value: true
+            },
+            {
+                Name: 'TextFormat',
+                Type: 'Input',
+                Value: 'plainText'
+            },
+            {
+                Name: 'PageToken',
+                Type: 'Input',
+                Value: null
+            },
+            {
+                Name: 'Comments',
+                Type: 'Output',
+                Value: null
+            },
+            {
+                Name: 'Summary',
+                Type: 'Output',
+                Value: null
+            },
+            {
+                Name: 'NextPageToken',
+                Type: 'Output',
+                Value: null
+            }
+        ];
+        return [...baseParams, ...specificParams];
+    }
+
+    /**
+     * Metadata about this action
+     */
+    public get Description(): string {
+        return 'Gets comments from YouTube videos or channels with sentiment analysis and statistics';
+    }
+}