@memberjunction/actions-bizapps-social 2.111.1 → 2.112.0

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

@@ -1,7 +1,7 @@
 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 { LogStatus, LogError } from '@memberjunction/global';
 import { MediaFile } from '../../../base/base-social.action';
 import { BaseAction } from '@memberjunction/actions';
 
@@ -10,196 +10,195 @@ import { BaseAction } from '@memberjunction/actions';
  */
 @RegisterClass(BaseAction, '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
-            };
+  /**
+   * 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');
         }
-    }
 
-    /**
-     * 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';
+        // 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`);
+          }
         }
-        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
-            }
-        ];
-    }
+        tweetData.poll = {
+          options: pollOptions,
+          duration_minutes: Math.min(Math.max(pollDurationMinutes, 5), 10080), // Min 5 minutes, max 7 days
+        };
+      }
 
-    /**
-     * Get action description
-     */
-    public get Description(): string {
-        return 'Creates a tweet on Twitter/X with optional media attachments, polls, replies, or quote tweets';
+      // 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

@@ -1,7 +1,7 @@
 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';
+import { LogStatus, LogError } from '@memberjunction/global';
 import { BaseAction } from '@memberjunction/actions';
 
 /**
@@ -9,146 +9,145 @@ import { BaseAction } from '@memberjunction/actions';
  */
 @RegisterClass(BaseAction, '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');
-            }
+  /**
+   * Delete a tweet from Twitter
+   */
+  protected async InternalRunAction(params: RunActionParams): Promise<ActionResultSimple> {
+    const { Params, ContextUser } = params;
 
-            // Extract parameters
-            const tweetId = this.getParamValue(Params, 'TweetID');
-            const confirmDeletion = this.getParamValue(Params, 'ConfirmDeletion') === true;
+    try {
+      // Initialize OAuth
+      const companyIntegrationId = this.getParamValue(Params, 'CompanyIntegrationID');
+      if (!(await this.initializeOAuth(companyIntegrationId))) {
+        throw new Error('Failed to initialize OAuth connection');
+      }
 
-            // Validate required parameters
-            if (!tweetId) {
-                throw new Error('TweetID is required');
-            }
+      // Extract parameters
+      const tweetId = this.getParamValue(Params, 'TweetID');
+      const confirmDeletion = this.getParamValue(Params, 'ConfirmDeletion') === true;
 
-            // Safety check - require explicit confirmation
-            if (!confirmDeletion) {
-                return {
-                    Success: false,
-                    ResultCode: 'CONFIRMATION_REQUIRED',
-                    Message: 'Tweet deletion requires explicit confirmation. Set ConfirmDeletion to true.',
-                    Params
-                };
-            }
+      // Validate required parameters
+      if (!tweetId) {
+        throw new Error('TweetID is required');
+      }
 
-            // 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'
-                    }
-                });
+      // Safety check - require explicit confirmation
+      if (!confirmDeletion) {
+        return {
+          Success: false,
+          ResultCode: 'CONFIRMATION_REQUIRED',
+          Message: 'Tweet deletion requires explicit confirmation. Set ConfirmDeletion to true.',
+          Params,
+        };
+      }
 
-                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
-                    };
+      // 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',
+          },
+        });
 
-                    // 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.');
-            }
+        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,
+          };
 
-            // Delete the tweet
-            LogStatus(`Deleting tweet ID: ${tweetId}...`);
-            await this.deleteTweet(tweetId);
+          // 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.');
+      }
 
-            // 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();
+      // Delete the tweet
+      LogStatus(`Deleting tweet ID: ${tweetId}...`);
+      await this.deleteTweet(tweetId);
 
-            return {
-                Success: true,
-                ResultCode: 'SUCCESS',
-                Message: `Successfully deleted tweet (ID: ${tweetId})`,
-                Params: outputParams
-            };
+      // 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();
 
-        } 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
-            };
-        }
-    }
+      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';
 
-    /**
-     * 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';
+      return {
+        Success: false,
+        ResultCode: this.getErrorCode(error),
+        Message: `Failed to delete tweet: ${errorMessage}`,
+        Params,
+      };
     }
+  }
 
-    /**
-     * 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 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';
+  }
 
-    /**
-     * Get action description
-     */
-    public get Description(): string {
-        return 'Deletes a tweet from Twitter/X. Requires explicit confirmation and ownership of the tweet.';
-    }
-}
+  /**
+   * 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.';
+  }
+}