@memberjunction/actions-bizapps-social 2.61.0

package/src/providers/twitter/actions/create-thread.action.ts

@@ -0,0 +1,227 @@
+import { RegisterClass } from '@memberjunction/global';
+import { TwitterBaseAction, CreateTweetData, Tweet } from '../twitter-base.action';
+import { ActionParam, ActionResultSimple, RunActionParams } from '@memberjunction/actions-base';
+import { LogStatus, LogError } from '@memberjunction/core';
+import { MediaFile, SocialPost } from '../../../base/base-social.action';
+
+/**
+ * Action to create a thread (series of connected tweets) on Twitter/X
+ */
+@RegisterClass(TwitterBaseAction, 'TwitterCreateThreadAction')
+export class TwitterCreateThreadAction extends TwitterBaseAction {
+    /**
+     * Create a thread on 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 tweets = this.getParamValue(Params, 'Tweets');
+            const mediaFilesByTweet = this.getParamValue(Params, 'MediaFilesByTweet');
+            const includeNumbers = this.getParamValue(Params, 'IncludeNumbers') !== false; // Default true
+            const numberFormat = this.getParamValue(Params, 'NumberFormat') || '{n}/{total}'; // Default format
+
+            // Validate required parameters
+            if (!tweets || !Array.isArray(tweets) || tweets.length === 0) {
+                throw new Error('Tweets array is required and must not be empty');
+            }
+
+            if (tweets.length < 2) {
+                throw new Error('A thread must contain at least 2 tweets');
+            }
+
+            if (tweets.length > 25) {
+                throw new Error('Twitter threads are limited to 25 tweets');
+            }
+
+            // Prepare tweets with numbering if requested
+            const preparedTweets = includeNumbers 
+                ? this.addThreadNumbers(tweets, numberFormat)
+                : tweets;
+
+            // Validate all tweet lengths
+            for (let i = 0; i < preparedTweets.length; i++) {
+                if (preparedTweets[i].length > 280) {
+                    throw new Error(`Tweet ${i + 1} exceeds Twitter's 280 character limit (current: ${preparedTweets[i].length} characters)`);
+                }
+            }
+
+            const createdTweets: Tweet[] = [];
+            const createdPosts: SocialPost[] = [];
+            let previousTweetId: string | undefined;
+
+            try {
+                // Create tweets in sequence
+                for (let i = 0; i < preparedTweets.length; i++) {
+                    LogStatus(`Creating tweet ${i + 1} of ${preparedTweets.length}...`);
+
+                    const tweetData: CreateTweetData = {
+                        text: preparedTweets[i]
+                    };
+
+                    // Reply to previous tweet in thread
+                    if (previousTweetId) {
+                        tweetData.reply = {
+                            in_reply_to_tweet_id: previousTweetId
+                        };
+                    }
+
+                    // Add media if provided for this tweet
+                    if (mediaFilesByTweet && mediaFilesByTweet[i]) {
+                        const mediaFiles = mediaFilesByTweet[i];
+                        if (Array.isArray(mediaFiles) && mediaFiles.length > 0) {
+                            if (mediaFiles.length > 4) {
+                                throw new Error(`Tweet ${i + 1}: Twitter supports a maximum of 4 media items per tweet`);
+                            }
+
+                            LogStatus(`Uploading ${mediaFiles.length} media files for tweet ${i + 1}...`);
+                            const mediaIds = await this.uploadMedia(mediaFiles as MediaFile[]);
+                            
+                            tweetData.media = {
+                                media_ids: mediaIds
+                            };
+                        }
+                    }
+
+                    // Create the tweet
+                    const tweet = await this.createTweet(tweetData);
+                    createdTweets.push(tweet);
+                    createdPosts.push(this.normalizePost(tweet));
+                    previousTweetId = tweet.id;
+
+                    // Small delay between tweets to avoid rate limiting
+                    if (i < preparedTweets.length - 1) {
+                        await new Promise(resolve => setTimeout(resolve, 1000)); // 1 second delay
+                    }
+                }
+
+                // Get user info for URLs
+                const user = await this.getCurrentUser();
+
+                // Build thread URL (link to first tweet)
+                const threadUrl = `https://twitter.com/${user.username}/status/${createdTweets[0].id}`;
+
+                // Update output parameters
+                const outputParams = [...Params];
+                const postsParam = outputParams.find(p => p.Name === 'CreatedPosts');
+                if (postsParam) postsParam.Value = createdPosts;
+                const tweetIdsParam = outputParams.find(p => p.Name === 'TweetIDs');
+                if (tweetIdsParam) tweetIdsParam.Value = createdTweets.map(t => t.id);
+                const threadUrlParam = outputParams.find(p => p.Name === 'ThreadURL');
+                if (threadUrlParam) threadUrlParam.Value = threadUrl;
+
+                return {
+                    Success: true,
+                    ResultCode: 'SUCCESS',
+                    Message: `Successfully created thread with ${createdTweets.length} tweets`,
+                    Params: outputParams
+                };
+
+            } catch (error) {
+                // If thread creation fails partway through, note which tweets were created
+                if (createdTweets.length > 0) {
+                    LogError(`Thread creation failed after creating ${createdTweets.length} tweets. Tweet IDs: ${createdTweets.map(t => t.id).join(', ')}`);
+                }
+                throw error;
+            }
+
+        } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            
+            return {
+                Success: false,
+                ResultCode: this.getErrorCode(error),
+                Message: `Failed to create thread: ${errorMessage}`,
+                Params
+            };
+        }
+    }
+
+    /**
+     * Add thread numbers to tweets
+     */
+    private addThreadNumbers(tweets: string[], format: string): string[] {
+        const total = tweets.length;
+        
+        return tweets.map((tweet, index) => {
+            const number = index + 1;
+            const threadNumber = format
+                .replace('{n}', number.toString())
+                .replace('{total}', total.toString());
+            
+            // Add number to beginning of tweet with a space
+            return `${threadNumber} ${tweet}`;
+        });
+    }
+
+    /**
+     * 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';
+        }
+        return 'ERROR';
+    }
+
+    /**
+     * Define the parameters this action expects
+     */
+    public get Params(): ActionParam[] {
+        return [
+            ...this.commonSocialParams,
+            {
+                Name: 'Tweets',
+                Type: 'Input',
+                Value: null
+            },
+            {
+                Name: 'MediaFilesByTweet',
+                Type: 'Input',
+                Value: null
+            },
+            {
+                Name: 'IncludeNumbers',
+                Type: 'Input',
+                Value: true
+            },
+            {
+                Name: 'NumberFormat',
+                Type: 'Input',
+                Value: '{n}/{total}'
+            },
+            {
+                Name: 'CreatedPosts',
+                Type: 'Output',
+                Value: null
+            },
+            {
+                Name: 'TweetIDs',
+                Type: 'Output',
+                Value: null
+            },
+            {
+                Name: 'ThreadURL',
+                Type: 'Output',
+                Value: null
+            }
+        ];
+    }
+
+    /**
+     * Get action description
+     */
+    public get Description(): string {
+        return 'Creates a thread (series of connected tweets) on Twitter/X with optional media attachments and automatic numbering';
+    }
+}

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

@@ -0,0 +1,204 @@
+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 create a tweet on Twitter/X
+ */
+@RegisterClass(TwitterBaseAction, 'TwitterCreateTweetAction')
+export class TwitterCreateTweetAction extends TwitterBaseAction {
+    /**
+     * Create a tweet on 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 content = this.getParamValue(Params, 'Content');
+            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');
+            }
+
+            // Validate content length (Twitter's limit is 280 characters)
+            if (content.length > 280) {
+                throw new Error(`Content exceeds Twitter's 280 character limit (current: ${content.length} characters)`);
+            }
+
+            // Build tweet data
+            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 (max 25 characters each)
+                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) // Min 5 minutes, max 7 days
+                };
+            }
+
+            // Upload media if provided
+            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');
+                }
+
+                LogStatus(`Uploading ${mediaFiles.length} media files...`);
+                const mediaIds = await this.uploadMedia(mediaFiles as MediaFile[]);
+                
+                tweetData.media = {
+                    media_ids: mediaIds
+                };
+            }
+
+            // Create the tweet
+            LogStatus('Creating tweet...');
+            const tweet = await this.createTweet(tweetData);
+
+            // Normalize the created tweet
+            const normalizedPost = this.normalizePost(tweet);
+
+            // Get user info for additional context
+            const user = await this.getCurrentUser();
+
+            // Update output parameters
+            const outputParams = [...Params];
+            const postParam = outputParams.find(p => p.Name === 'CreatedPost');
+            if (postParam) postParam.Value = normalizedPost;
+            const tweetIdParam = outputParams.find(p => p.Name === 'TweetID');
+            if (tweetIdParam) tweetIdParam.Value = tweet.id;
+            const tweetUrlParam = outputParams.find(p => p.Name === 'TweetURL');
+            if (tweetUrlParam) tweetUrlParam.Value = `https://twitter.com/${user.username}/status/${tweet.id}`;
+
+            return {
+                Success: true,
+                ResultCode: 'SUCCESS',
+                Message: `Successfully created tweet (ID: ${tweet.id})`,
+                Params: outputParams
+            };
+
+        } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            
+            return {
+                Success: false,
+                ResultCode: this.getErrorCode(error),
+                Message: `Failed to create tweet: ${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('character limit')) return 'CONTENT_TOO_LONG';
+            if (error.message.includes('media')) return 'INVALID_MEDIA';
+        }
+        return 'ERROR';
+    }
+
+    /**
+     * Define the parameters this action expects
+     */
+    public get Params(): ActionParam[] {
+        return [
+            ...this.commonSocialParams,
+            {
+                Name: 'Content',
+                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: 'CreatedPost',
+                Type: 'Output',
+                Value: null
+            },
+            {
+                Name: 'TweetID',
+                Type: 'Output',
+                Value: null
+            },
+            {
+                Name: 'TweetURL',
+                Type: 'Output',
+                Value: null
+            }
+        ];
+    }
+
+    /**
+     * Get action description
+     */
+    public get Description(): string {
+        return 'Creates a tweet on Twitter/X with optional media attachments, polls, replies, or quote tweets';
+    }
+}

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

@@ -0,0 +1,153 @@
+import { RegisterClass } from '@memberjunction/global';
+import { TwitterBaseAction } from '../twitter-base.action';
+import { ActionParam, ActionResultSimple, RunActionParams } from '@memberjunction/actions-base';
+import { LogStatus, LogError } from '@memberjunction/core';
+
+/**
+ * Action to delete a tweet from Twitter/X
+ */
+@RegisterClass(TwitterBaseAction, 'TwitterDeleteTweetAction')
+export class TwitterDeleteTweetAction extends TwitterBaseAction {
+    /**
+     * Delete a tweet 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 tweetId = this.getParamValue(Params, 'TweetID');
+            const confirmDeletion = this.getParamValue(Params, 'ConfirmDeletion') === true;
+
+            // Validate required parameters
+            if (!tweetId) {
+                throw new Error('TweetID is required');
+            }
+
+            // Safety check - require explicit confirmation
+            if (!confirmDeletion) {
+                return {
+                    Success: false,
+                    ResultCode: 'CONFIRMATION_REQUIRED',
+                    Message: 'Tweet deletion requires explicit confirmation. Set ConfirmDeletion to true.',
+                    Params
+                };
+            }
+
+            // Get the tweet details before deletion (for output)
+            let tweetDetails: any = null;
+            try {
+                LogStatus(`Retrieving tweet details for ID: ${tweetId}...`);
+                const response = await this.axiosInstance.get(`/tweets/${tweetId}`, {
+                    params: {
+                        'tweet.fields': 'id,text,created_at,author_id,public_metrics',
+                        'expansions': 'author_id',
+                        'user.fields': 'id,username'
+                    }
+                });
+
+                if (response.data.data) {
+                    tweetDetails = {
+                        id: response.data.data.id,
+                        text: response.data.data.text,
+                        createdAt: response.data.data.created_at,
+                        metrics: response.data.data.public_metrics
+                    };
+
+                    // Verify ownership
+                    const currentUser = await this.getCurrentUser();
+                    if (response.data.data.author_id !== currentUser.id) {
+                        throw new Error('You can only delete your own tweets');
+                    }
+                }
+            } catch (error) {
+                // If we can't retrieve the tweet, it might already be deleted or we don't have access
+                LogStatus('Could not retrieve tweet details. It may already be deleted or inaccessible.');
+            }
+
+            // Delete the tweet
+            LogStatus(`Deleting tweet ID: ${tweetId}...`);
+            await this.deleteTweet(tweetId);
+
+            // Update output parameters
+            const outputParams = [...Params];
+            const deletedDetailsParam = outputParams.find(p => p.Name === 'DeletedTweetDetails');
+            if (deletedDetailsParam && tweetDetails) deletedDetailsParam.Value = tweetDetails;
+            const deletionTimeParam = outputParams.find(p => p.Name === 'DeletionTime');
+            if (deletionTimeParam) deletionTimeParam.Value = new Date().toISOString();
+
+            return {
+                Success: true,
+                ResultCode: 'SUCCESS',
+                Message: `Successfully deleted tweet (ID: ${tweetId})`,
+                Params: outputParams
+            };
+
+        } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            
+            return {
+                Success: false,
+                ResultCode: this.getErrorCode(error),
+                Message: `Failed to delete tweet: ${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 'TWEET_NOT_FOUND';
+            if (error.message.includes('Forbidden')) return 'INSUFFICIENT_PERMISSIONS';
+            if (error.message.includes('own tweets')) return 'NOT_OWNER';
+        }
+        return 'ERROR';
+    }
+
+    /**
+     * Define the parameters this action expects
+     */
+    public get Params(): ActionParam[] {
+        return [
+            ...this.commonSocialParams,
+            {
+                Name: 'TweetID',
+                Type: 'Input',
+                Value: null
+            },
+            {
+                Name: 'ConfirmDeletion',
+                Type: 'Input',
+                Value: false
+            },
+            {
+                Name: 'DeletedTweetDetails',
+                Type: 'Output',
+                Value: null
+            },
+            {
+                Name: 'DeletionTime',
+                Type: 'Output',
+                Value: null
+            }
+        ];
+    }
+
+    /**
+     * Get action description
+     */
+    public get Description(): string {
+        return 'Deletes a tweet from Twitter/X. Requires explicit confirmation and ownership of the tweet.';
+    }
+}