@memberjunction/actions-bizapps-social 2.61.0

package/src/providers/twitter/actions/get-timeline.action.ts

@@ -0,0 +1,248 @@
+import { RegisterClass } from '@memberjunction/global';
+import { TwitterBaseAction, Tweet } from '../twitter-base.action';
+import { ActionParam, ActionResultSimple, RunActionParams } from '@memberjunction/actions-base';
+import { LogStatus, LogError } from '@memberjunction/core';
+import { SocialPost } from '../../../base/base-social.action';
+
+/**
+ * Action to get timeline tweets (home timeline or user timeline) from Twitter/X
+ */
+@RegisterClass(TwitterBaseAction, 'TwitterGetTimelineAction')
+export class TwitterGetTimelineAction extends TwitterBaseAction {
+    /**
+     * Get timeline tweets from Twitter
+     */
+    protected async InternalRunAction(params: RunActionParams): Promise<ActionResultSimple> {
+        const { Params, ContextUser } = params;
+        
+        try {
+            // Initialize OAuth
+            const companyIntegrationId = this.getParamValue(Params, 'CompanyIntegrationID');
+            if (!await this.initializeOAuth(companyIntegrationId)) {
+                throw new Error('Failed to initialize OAuth connection');
+            }
+
+            // Extract parameters
+            const timelineType = this.getParamValue(Params, 'TimelineType') || 'home'; // 'home' or 'user'
+            const userId = this.getParamValue(Params, 'UserID');
+            const username = this.getParamValue(Params, 'Username');
+            const maxResults = this.getParamValue(Params, 'MaxResults') || 100;
+            const excludeReplies = this.getParamValue(Params, 'ExcludeReplies') === true;
+            const excludeRetweets = this.getParamValue(Params, 'ExcludeRetweets') === true;
+            const startTime = this.getParamValue(Params, 'StartTime');
+            const endTime = this.getParamValue(Params, 'EndTime');
+            const sinceId = this.getParamValue(Params, 'SinceID');
+            const untilId = this.getParamValue(Params, 'UntilID');
+
+            let tweets: Tweet[] = [];
+            let endpoint: string;
+            const queryParams: Record<string, any> = {
+                'tweet.fields': 'id,text,created_at,author_id,conversation_id,public_metrics,attachments,entities,referenced_tweets',
+                'user.fields': 'id,name,username,profile_image_url,description,created_at,verified',
+                'media.fields': 'url,preview_image_url,type,width,height',
+                'expansions': 'author_id,attachments.media_keys,referenced_tweets.id,referenced_tweets.id.author_id',
+                'max_results': Math.min(maxResults, 100) // API limit per request
+            };
+
+            if (timelineType === 'home') {
+                // Get home timeline (requires user context)
+                const currentUser = await this.getCurrentUser();
+                endpoint = `/users/${currentUser.id}/timelines/reverse_chronological`;
+                
+                // Home timeline specific parameters
+                if (excludeReplies) {
+                    queryParams['exclude'] = queryParams['exclude'] ? `${queryParams['exclude']},replies` : 'replies';
+                }
+                if (excludeRetweets) {
+                    queryParams['exclude'] = queryParams['exclude'] ? `${queryParams['exclude']},retweets` : 'retweets';
+                }
+            } else {
+                // Get user timeline
+                let targetUserId: string;
+                
+                if (userId) {
+                    targetUserId = userId;
+                } else if (username) {
+                    // Look up user by username
+                    const userResponse = await this.axiosInstance.get(`/users/by/username/${username}`, {
+                        params: { 'user.fields': 'id' }
+                    });
+                    targetUserId = userResponse.data.data.id;
+                } else {
+                    // Default to authenticated user
+                    const currentUser = await this.getCurrentUser();
+                    targetUserId = currentUser.id;
+                }
+
+                endpoint = `/users/${targetUserId}/tweets`;
+                
+                // User timeline specific parameters
+                if (excludeReplies) {
+                    queryParams['exclude'] = queryParams['exclude'] ? `${queryParams['exclude']},replies` : 'replies';
+                }
+                if (excludeRetweets) {
+                    queryParams['exclude'] = queryParams['exclude'] ? `${queryParams['exclude']},retweets` : 'retweets';
+                }
+            }
+
+            // Add time-based filters if provided
+            if (startTime) {
+                queryParams['start_time'] = this.formatTwitterDate(startTime);
+            }
+            if (endTime) {
+                queryParams['end_time'] = this.formatTwitterDate(endTime);
+            }
+            if (sinceId) {
+                queryParams['since_id'] = sinceId;
+            }
+            if (untilId) {
+                queryParams['until_id'] = untilId;
+            }
+
+            // Get paginated tweets
+            LogStatus(`Getting ${timelineType} timeline tweets...`);
+            tweets = await this.getPaginatedTweets(endpoint, queryParams, maxResults);
+
+            // Convert to normalized format
+            const normalizedPosts: SocialPost[] = tweets.map(tweet => this.normalizePost(tweet));
+
+            // Calculate summary statistics
+            const stats = {
+                totalTweets: normalizedPosts.length,
+                totalLikes: 0,
+                totalRetweets: 0,
+                totalReplies: 0,
+                totalImpressions: 0
+            };
+
+            normalizedPosts.forEach(post => {
+                if (post.analytics) {
+                    stats.totalLikes += post.analytics.likes;
+                    stats.totalRetweets += post.analytics.shares;
+                    stats.totalReplies += post.analytics.comments;
+                    stats.totalImpressions += post.analytics.impressions;
+                }
+            });
+
+            // Update output parameters
+            const outputParams = [...Params];
+            const postsParam = outputParams.find(p => p.Name === 'Posts');
+            if (postsParam) postsParam.Value = normalizedPosts;
+            const tweetsParam = outputParams.find(p => p.Name === 'Tweets');
+            if (tweetsParam) tweetsParam.Value = tweets;
+            const statsParam = outputParams.find(p => p.Name === 'Statistics');
+            if (statsParam) statsParam.Value = stats;
+
+            return {
+                Success: true,
+                ResultCode: 'SUCCESS',
+                Message: `Successfully retrieved ${normalizedPosts.length} tweets from ${timelineType} timeline`,
+                Params: outputParams
+            };
+
+        } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            
+            return {
+                Success: false,
+                ResultCode: this.getErrorCode(error),
+                Message: `Failed to get timeline: ${errorMessage}`,
+                Params
+            };
+        }
+    }
+
+    /**
+     * Get error code based on error type
+     */
+    private getErrorCode(error: any): string {
+        if (error instanceof Error) {
+            if (error.message.includes('Rate Limit')) return 'RATE_LIMIT';
+            if (error.message.includes('Unauthorized')) return 'INVALID_TOKEN';
+            if (error.message.includes('Not Found')) return 'USER_NOT_FOUND';
+            if (error.message.includes('Forbidden')) return 'INSUFFICIENT_PERMISSIONS';
+        }
+        return 'ERROR';
+    }
+
+    /**
+     * Define the parameters this action expects
+     */
+    public get Params(): ActionParam[] {
+        return [
+            ...this.commonSocialParams,
+            {
+                Name: 'TimelineType',
+                Type: 'Input',
+                Value: 'home' // 'home' or 'user'
+            },
+            {
+                Name: 'UserID',
+                Type: 'Input',
+                Value: null
+            },
+            {
+                Name: 'Username',
+                Type: 'Input',
+                Value: null
+            },
+            {
+                Name: 'MaxResults',
+                Type: 'Input',
+                Value: 100
+            },
+            {
+                Name: 'ExcludeReplies',
+                Type: 'Input',
+                Value: false
+            },
+            {
+                Name: 'ExcludeRetweets',
+                Type: 'Input',
+                Value: false
+            },
+            {
+                Name: 'StartTime',
+                Type: 'Input',
+                Value: null
+            },
+            {
+                Name: 'EndTime',
+                Type: 'Input',
+                Value: null
+            },
+            {
+                Name: 'SinceID',
+                Type: 'Input',
+                Value: null
+            },
+            {
+                Name: 'UntilID',
+                Type: 'Input',
+                Value: null
+            },
+            {
+                Name: 'Posts',
+                Type: 'Output',
+                Value: null
+            },
+            {
+                Name: 'Tweets',
+                Type: 'Output',
+                Value: null
+            },
+            {
+                Name: 'Statistics',
+                Type: 'Output',
+                Value: null
+            }
+        ];
+    }
+
+    /**
+     * Get action description
+     */
+    public get Description(): string {
+        return 'Gets timeline tweets from Twitter/X including home timeline or a specific user\'s timeline with filtering options';
+    }
+}

package/src/providers/twitter/actions/index.ts

@@ -0,0 +1,14 @@
+/**
+ * Twitter/X Actions for MemberJunction
+ * 
+ * This module exports all Twitter-specific actions for social media automation.
+ */
+
+export * from './create-tweet.action';
+export * from './create-thread.action';
+export * from './get-timeline.action';
+export * from './get-mentions.action';
+export * from './get-analytics.action';
+export * from './schedule-tweet.action';
+export * from './delete-tweet.action';
+export * from './search-tweets.action';

package/src/providers/twitter/actions/schedule-tweet.action.ts

@@ -0,0 +1,259 @@
+import { RegisterClass } from '@memberjunction/global';
+import { TwitterBaseAction, CreateTweetData } from '../twitter-base.action';
+import { ActionParam, ActionResultSimple, RunActionParams } from '@memberjunction/actions-base';
+import { LogStatus, LogError } from '@memberjunction/core';
+import { MediaFile } from '../../../base/base-social.action';
+
+/**
+ * Action to schedule a tweet for future posting on Twitter/X
+ * Note: Twitter API v2 doesn't have native scheduling, so this action
+ * saves the tweet data for later posting via a separate scheduler service
+ */
+@RegisterClass(TwitterBaseAction, 'TwitterScheduleTweetAction')
+export class TwitterScheduleTweetAction extends TwitterBaseAction {
+    /**
+     * Schedule a tweet for future posting
+     */
+    protected async InternalRunAction(params: RunActionParams): Promise<ActionResultSimple> {
+        const { Params, ContextUser } = params;
+        
+        try {
+            // Initialize OAuth
+            const companyIntegrationId = this.getParamValue(Params, 'CompanyIntegrationID');
+            if (!await this.initializeOAuth(companyIntegrationId)) {
+                throw new Error('Failed to initialize OAuth connection');
+            }
+
+            // Extract parameters
+            const content = this.getParamValue(Params, 'Content');
+            const scheduledTime = this.getParamValue(Params, 'ScheduledTime');
+            const mediaFiles = this.getParamValue(Params, 'MediaFiles');
+            const replyToTweetId = this.getParamValue(Params, 'ReplyToTweetID');
+            const quoteTweetId = this.getParamValue(Params, 'QuoteTweetID');
+            const pollOptions = this.getParamValue(Params, 'PollOptions');
+            const pollDurationMinutes = this.getParamValue(Params, 'PollDurationMinutes') || 1440; // Default 24 hours
+
+            // Validate required parameters
+            if (!content) {
+                throw new Error('Content is required');
+            }
+
+            if (!scheduledTime) {
+                throw new Error('ScheduledTime is required');
+            }
+
+            // Validate scheduled time is in the future
+            const scheduleDate = new Date(scheduledTime);
+            const now = new Date();
+            
+            if (scheduleDate <= now) {
+                throw new Error('ScheduledTime must be in the future');
+            }
+
+            // Validate scheduled time is not too far in the future (e.g., 1 year)
+            const maxFutureDate = new Date();
+            maxFutureDate.setFullYear(maxFutureDate.getFullYear() + 1);
+            
+            if (scheduleDate > maxFutureDate) {
+                throw new Error('ScheduledTime cannot be more than 1 year in the future');
+            }
+
+            // Validate content length
+            if (content.length > 280) {
+                throw new Error(`Content exceeds Twitter's 280 character limit (current: ${content.length} characters)`);
+            }
+
+            // Build tweet data structure
+            const tweetData: CreateTweetData = {
+                text: content
+            };
+
+            // Add reply if specified
+            if (replyToTweetId) {
+                tweetData.reply = {
+                    in_reply_to_tweet_id: replyToTweetId
+                };
+            }
+
+            // Add quote tweet if specified
+            if (quoteTweetId) {
+                tweetData.quote_tweet_id = quoteTweetId;
+            }
+
+            // Add poll if specified
+            if (pollOptions && Array.isArray(pollOptions) && pollOptions.length >= 2) {
+                if (pollOptions.length > 4) {
+                    throw new Error('Twitter polls support a maximum of 4 options');
+                }
+                
+                // Validate poll option lengths
+                for (const option of pollOptions) {
+                    if (option.length > 25) {
+                        throw new Error(`Poll option "${option}" exceeds 25 character limit`);
+                    }
+                }
+
+                tweetData.poll = {
+                    options: pollOptions,
+                    duration_minutes: Math.min(Math.max(pollDurationMinutes, 5), 10080)
+                };
+            }
+
+            // Handle media files
+            let uploadedMediaIds: string[] = [];
+            if (mediaFiles && Array.isArray(mediaFiles) && mediaFiles.length > 0) {
+                if (mediaFiles.length > 4) {
+                    throw new Error('Twitter supports a maximum of 4 media items per tweet');
+                }
+
+                // For scheduling, we'll upload the media now and store the IDs
+                // Note: Twitter media IDs expire after 24 hours if not used
+                const hoursUntilScheduled = (scheduleDate.getTime() - now.getTime()) / (1000 * 60 * 60);
+                
+                if (hoursUntilScheduled <= 24) {
+                    // Upload now if scheduling within 24 hours
+                    LogStatus(`Uploading ${mediaFiles.length} media files...`);
+                    uploadedMediaIds = await this.uploadMedia(mediaFiles as MediaFile[]);
+                    tweetData.media = {
+                        media_ids: uploadedMediaIds
+                    };
+                } else {
+                    // For tweets scheduled beyond 24 hours, we'll need to store media
+                    // data and upload closer to the scheduled time
+                    LogStatus('Media will be uploaded closer to scheduled time due to Twitter\'s 24-hour media expiration');
+                }
+            }
+
+            // Create scheduled tweet record
+            // In a real implementation, this would save to a database or queue service
+            const scheduledTweet = {
+                id: this.generateScheduledTweetId(),
+                scheduledFor: scheduleDate.toISOString(),
+                tweetData: tweetData,
+                mediaFiles: mediaFiles, // Store for later upload if needed
+                companyIntegrationId: companyIntegrationId,
+                createdAt: new Date().toISOString(),
+                status: 'scheduled'
+            };
+
+            // Simulate saving to a scheduling service
+            LogStatus(`Tweet scheduled for ${scheduleDate.toLocaleString()}`);
+
+            // Get user info for context
+            const user = await this.getCurrentUser();
+
+            // Update output parameters
+            const outputParams = [...Params];
+            const scheduledIdParam = outputParams.find(p => p.Name === 'ScheduledTweetID');
+            if (scheduledIdParam) scheduledIdParam.Value = scheduledTweet.id;
+            const scheduledDataParam = outputParams.find(p => p.Name === 'ScheduledTweetData');
+            if (scheduledDataParam) scheduledDataParam.Value = scheduledTweet;
+            const estimatedUrlParam = outputParams.find(p => p.Name === 'EstimatedURL');
+            if (estimatedUrlParam) estimatedUrlParam.Value = `https://twitter.com/${user.username}/status/[pending]`;
+
+            return {
+                Success: true,
+                ResultCode: 'SUCCESS',
+                Message: `Successfully scheduled tweet for ${scheduleDate.toLocaleString()}`,
+                Params: outputParams
+            };
+
+        } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            
+            return {
+                Success: false,
+                ResultCode: this.getErrorCode(error),
+                Message: `Failed to schedule tweet: ${errorMessage}`,
+                Params
+            };
+        }
+    }
+
+    /**
+     * Generate a unique ID for scheduled tweet
+     */
+    private generateScheduledTweetId(): string {
+        return `scheduled_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+
+    /**
+     * Get error code based on error type
+     */
+    private getErrorCode(error: any): string {
+        if (error instanceof Error) {
+            if (error.message.includes('Rate Limit')) return 'RATE_LIMIT';
+            if (error.message.includes('Unauthorized')) return 'INVALID_TOKEN';
+            if (error.message.includes('character limit')) return 'CONTENT_TOO_LONG';
+            if (error.message.includes('media')) return 'INVALID_MEDIA';
+            if (error.message.includes('future')) return 'INVALID_SCHEDULE_TIME';
+        }
+        return 'ERROR';
+    }
+
+    /**
+     * Define the parameters this action expects
+     */
+    public get Params(): ActionParam[] {
+        return [
+            ...this.commonSocialParams,
+            {
+                Name: 'Content',
+                Type: 'Input',
+                Value: null
+            },
+            {
+                Name: 'ScheduledTime',
+                Type: 'Input',
+                Value: null
+            },
+            {
+                Name: 'MediaFiles',
+                Type: 'Input',
+                Value: null
+            },
+            {
+                Name: 'ReplyToTweetID',
+                Type: 'Input',
+                Value: null
+            },
+            {
+                Name: 'QuoteTweetID',
+                Type: 'Input',
+                Value: null
+            },
+            {
+                Name: 'PollOptions',
+                Type: 'Input',
+                Value: null
+            },
+            {
+                Name: 'PollDurationMinutes',
+                Type: 'Input',
+                Value: 1440 // Default 24 hours
+            },
+            {
+                Name: 'ScheduledTweetID',
+                Type: 'Output',
+                Value: null
+            },
+            {
+                Name: 'ScheduledTweetData',
+                Type: 'Output',
+                Value: null
+            },
+            {
+                Name: 'EstimatedURL',
+                Type: 'Output',
+                Value: null
+            }
+        ];
+    }
+
+    /**
+     * Get action description
+     */
+    public get Description(): string {
+        return 'Schedules a tweet for future posting on Twitter/X with optional media attachments, polls, replies, or quote tweets';
+    }
+}