@memberjunction/actions-bizapps-social 2.111.0 → 2.112.0

package/src/providers/facebook/actions/respond-to-comments.action.ts

@@ -2,7 +2,7 @@ import { RegisterClass } from '@memberjunction/global';
 import { FacebookBaseAction, FacebookComment } from '../facebook-base.action';
 import { ActionParam, ActionResultSimple, RunActionParams } from '@memberjunction/actions-base';
 import { SocialMediaErrorCode } from '../../../base/base-social.action';
-import { LogStatus, LogError } from '@memberjunction/core';
+import { LogStatus, LogError } from '@memberjunction/global';
 import axios from 'axios';
 import { BaseAction } from '@memberjunction/actions';
 
@@ -12,362 +12,345 @@ import { BaseAction } from '@memberjunction/actions';
  */
 @RegisterClass(BaseAction, 'FacebookRespondToCommentsAction')
 export class FacebookRespondToCommentsAction extends FacebookBaseAction {
-    /**
-     * Get action description
-     */
-    public get Description(): string {
-        return 'Responds to comments on Facebook posts, pages, or other comments with text replies or reactions';
-    }
+  /**
+   * Get action description
+   */
+  public get Description(): string {
+    return 'Responds to comments on Facebook posts, pages, or other comments with text replies or reactions';
+  }
 
-    /**
-     * Define the parameters for this action
-     */
-    public get Params(): ActionParam[] {
-        return [
-            ...this.commonSocialParams,
-            {
-                Name: 'CommentID',
-                Type: 'Input',
-                Value: null,
-                },
-            {
-                Name: 'ResponseText',
-                Type: 'Input',
-                Value: null,
-                },
-            {
-                Name: 'AttachmentURL',
-                Type: 'Input',
-                Value: null,
-                },
-            {
-                Name: 'LikeComment',
-                Type: 'Input',
-                Value: false,
-                },
-            {
-                Name: 'HideComment',
-                Type: 'Input',
-                Value: false,
-                },
-            {
-                Name: 'DeleteComment',
-                Type: 'Input',
-                Value: false,
-                },
-            {
-                Name: 'PrivateReply',
-                Type: 'Input',
-                Value: false,
-                },
-            {
-                Name: 'PageID',
-                Type: 'Input',
-                Value: null,
-                }
-        ];
-    }
+  /**
+   * Define the parameters for this action
+   */
+  public get Params(): ActionParam[] {
+    return [
+      ...this.commonSocialParams,
+      {
+        Name: 'CommentID',
+        Type: 'Input',
+        Value: null,
+      },
+      {
+        Name: 'ResponseText',
+        Type: 'Input',
+        Value: null,
+      },
+      {
+        Name: 'AttachmentURL',
+        Type: 'Input',
+        Value: null,
+      },
+      {
+        Name: 'LikeComment',
+        Type: 'Input',
+        Value: false,
+      },
+      {
+        Name: 'HideComment',
+        Type: 'Input',
+        Value: false,
+      },
+      {
+        Name: 'DeleteComment',
+        Type: 'Input',
+        Value: false,
+      },
+      {
+        Name: 'PrivateReply',
+        Type: 'Input',
+        Value: false,
+      },
+      {
+        Name: 'PageID',
+        Type: 'Input',
+        Value: null,
+      },
+    ];
+  }
+
+  /**
+   * Execute the action
+   */
+  protected async InternalRunAction(params: RunActionParams): Promise<ActionResultSimple> {
+    const { Params, ContextUser } = params;
+
+    try {
+      // Validate required parameters
+      const companyIntegrationId = this.getParamValue(Params, 'CompanyIntegrationID');
+      const commentId = this.getParamValue(Params, 'CommentID');
+
+      if (!companyIntegrationId) {
+        return {
+          Success: false,
+          Message: 'CompanyIntegrationID is required',
+          ResultCode: 'INVALID_TOKEN',
+        };
+      }
+
+      if (!commentId) {
+        return {
+          Success: false,
+          Message: 'CommentID is required',
+          ResultCode: 'MISSING_REQUIRED_PARAM',
+        };
+      }
+
+      // Initialize OAuth
+      if (!(await this.initializeOAuth(companyIntegrationId))) {
+        return {
+          Success: false,
+          Message: 'Failed to initialize Facebook OAuth connection',
+          ResultCode: 'INVALID_TOKEN',
+        };
+      }
+
+      // Get parameters
+      const responseText = this.getParamValue(Params, 'ResponseText') as string;
+      const attachmentUrl = this.getParamValue(Params, 'AttachmentURL') as string;
+      const likeComment = this.getParamValue(Params, 'LikeComment') as boolean;
+      const hideComment = this.getParamValue(Params, 'HideComment') as boolean;
+      const deleteComment = this.getParamValue(Params, 'DeleteComment') as boolean;
+      const privateReply = this.getParamValue(Params, 'PrivateReply') as boolean;
+      const pageId = this.getParamValue(Params, 'PageID') as string;
 
-    /**
-     * Execute the action
-     */
-    protected async InternalRunAction(params: RunActionParams): Promise<ActionResultSimple> {
-        const { Params, ContextUser } = params;
-        
+      // Validate that at least one action is specified
+      if (!responseText && !attachmentUrl && !likeComment && !hideComment && !deleteComment) {
+        return {
+          Success: false,
+          Message: 'At least one action (ResponseText, AttachmentURL, LikeComment, HideComment, or DeleteComment) is required',
+          ResultCode: 'MISSING_ACTION',
+        };
+      }
+
+      // Get appropriate access token
+      let accessToken = this.getAccessToken();
+      if (pageId) {
+        // Use page access token for page actions
+        accessToken = await this.getPageAccessToken(pageId);
+      }
+
+      LogStatus(`Processing comment ${commentId}...`);
+
+      // Get comment details first
+      const commentDetails = await this.getCommentDetails(commentId, accessToken!);
+      if (!commentDetails) {
+        return {
+          Success: false,
+          Message: 'Comment not found or access denied',
+          ResultCode: 'NOT_FOUND',
+        };
+      }
+
+      const results: any = {
+        commentId,
+        originalComment: {
+          message: commentDetails.message,
+          from: commentDetails.from,
+          createdTime: commentDetails.created_time,
+        },
+        actions: [],
+      };
+
+      // Handle delete action first (if specified)
+      if (deleteComment) {
         try {
-            // Validate required parameters
-            const companyIntegrationId = this.getParamValue(Params, 'CompanyIntegrationID');
-            const commentId = this.getParamValue(Params, 'CommentID');
-            
-            if (!companyIntegrationId) {
-                return {
-                Success: false,
-                Message: 'CompanyIntegrationID is required',
-                ResultCode: 'INVALID_TOKEN'
-            };
-            }
-
-            if (!commentId) {
-                return {
-                Success: false,
-                Message: 'CommentID is required',
-                ResultCode: 'MISSING_REQUIRED_PARAM'
-            };
-            }
-
-            // Initialize OAuth
-            if (!await this.initializeOAuth(companyIntegrationId)) {
-                return {
-                Success: false,
-                Message: 'Failed to initialize Facebook OAuth connection',
-                ResultCode: 'INVALID_TOKEN'
-            };
-            }
-
-            // Get parameters
-            const responseText = this.getParamValue(Params, 'ResponseText') as string;
-            const attachmentUrl = this.getParamValue(Params, 'AttachmentURL') as string;
-            const likeComment = this.getParamValue(Params, 'LikeComment') as boolean;
-            const hideComment = this.getParamValue(Params, 'HideComment') as boolean;
-            const deleteComment = this.getParamValue(Params, 'DeleteComment') as boolean;
-            const privateReply = this.getParamValue(Params, 'PrivateReply') as boolean;
-            const pageId = this.getParamValue(Params, 'PageID') as string;
-
-            // Validate that at least one action is specified
-            if (!responseText && !attachmentUrl && !likeComment && !hideComment && !deleteComment) {
-                return {
-                Success: false,
-                Message: 'At least one action (ResponseText, AttachmentURL, LikeComment, HideComment, or DeleteComment) is required',
-                ResultCode: 'MISSING_ACTION'
-            };
-            }
-
-            // Get appropriate access token
-            let accessToken = this.getAccessToken();
-            if (pageId) {
-                // Use page access token for page actions
-                accessToken = await this.getPageAccessToken(pageId);
-            }
-
-            LogStatus(`Processing comment ${commentId}...`);
-
-            // Get comment details first
-            const commentDetails = await this.getCommentDetails(commentId, accessToken!);
-            if (!commentDetails) {
-                return {
-                Success: false,
-                Message: 'Comment not found or access denied',
-                ResultCode: 'NOT_FOUND'
-            };
-            }
-
-            const results: any = {
-                commentId,
-                originalComment: {
-                    message: commentDetails.message,
-                    from: commentDetails.from,
-                    createdTime: commentDetails.created_time
-                },
-                actions: []
-            };
-
-            // Handle delete action first (if specified)
-            if (deleteComment) {
-                try {
-                    await this.deleteCommentAction(commentId, accessToken!);
-                    results.actions.push({ action: 'delete', success: true });
-                    LogStatus(`Deleted comment ${commentId}`);
-                    
-                    // If deleted, no other actions can be performed
-                    return {
-                Success: true,
-                Message: 'Comment deleted successfully',
-                ResultCode: 'SUCCESS',
-                Params
-            };
-                } catch (error) {
-                    LogError(`Failed to delete comment: ${error}`);
-                    results.actions.push({ 
-                        action: 'delete', 
-                        success: false, 
-                        error: error instanceof Error ? error.message : 'Unknown error' 
-                    });
-                }
-            }
-
-            // Handle hide action
-            if (hideComment) {
-                try {
-                    await this.hideCommentAction(commentId, accessToken!, true);
-                    results.actions.push({ action: 'hide', success: true });
-                    LogStatus(`Hidden comment ${commentId}`);
-                } catch (error) {
-                    LogError(`Failed to hide comment: ${error}`);
-                    results.actions.push({ 
-                        action: 'hide', 
-                        success: false, 
-                        error: error instanceof Error ? error.message : 'Unknown error' 
-                    });
-                }
-            }
-
-            // Handle like action
-            if (likeComment) {
-                try {
-                    await this.likeCommentAction(commentId, accessToken!);
-                    results.actions.push({ action: 'like', success: true });
-                    LogStatus(`Liked comment ${commentId}`);
-                } catch (error) {
-                    LogError(`Failed to like comment: ${error}`);
-                    results.actions.push({ 
-                        action: 'like', 
-                        success: false, 
-                        error: error instanceof Error ? error.message : 'Unknown error' 
-                    });
-                }
-            }
-
-            // Handle reply action
-            if (responseText || attachmentUrl) {
-                try {
-                    const replyResult = await this.replyToComment(
-                        commentId,
-                        responseText,
-                        attachmentUrl,
-                        privateReply,
-                        accessToken!
-                    );
-                    
-                    results.actions.push({ 
-                        action: privateReply ? 'private_reply' : 'reply', 
-                        success: true,
-                        replyId: replyResult.id,
-                        message: responseText
-                    });
-                    
-                    LogStatus(`Replied to comment ${commentId}`);
-                } catch (error) {
-                    LogError(`Failed to reply to comment: ${error}`);
-                    results.actions.push({ 
-                        action: privateReply ? 'private_reply' : 'reply', 
-                        success: false, 
-                        error: error instanceof Error ? error.message : 'Unknown error' 
-                    });
-                }
-            }
-
-            // Check if any actions succeeded
-            const successfulActions = results.actions.filter((a: any) => a.success);
-            if (successfulActions.length === 0) {
-                return {
-                    Success: false,
-                    Message: 'All requested actions failed',
-                    ResultCode: 'ERROR'
-                };
-            }
-
-            return {
-                Success: true,
-                Message: `Successfully completed ${successfulActions.length} of ${results.actions.length} actions`,
-                ResultCode: 'SUCCESS',
-                Params
-            };
+          await this.deleteCommentAction(commentId, accessToken!);
+          results.actions.push({ action: 'delete', success: true });
+          LogStatus(`Deleted comment ${commentId}`);
 
+          // If deleted, no other actions can be performed
+          return {
+            Success: true,
+            Message: 'Comment deleted successfully',
+            ResultCode: 'SUCCESS',
+            Params,
+          };
         } catch (error) {
-            LogError(`Failed to respond to Facebook comment: ${error instanceof Error ? error.message : 'Unknown error'}`);
-            
-            if (this.isAuthError(error)) {
-                return this.handleOAuthError(error);
-            }
-
-            return {
-                Success: false,
-                Message: error instanceof Error ? error.message : 'Unknown error occurred',
-                ResultCode: 'ERROR'
-            };
+          LogError(`Failed to delete comment: ${error}`);
+          results.actions.push({
+            action: 'delete',
+            success: false,
+            error: error instanceof Error ? error.message : 'Unknown error',
+          });
         }
-    }
+      }
 
-    /**
-     * Get comment details
-     */
-    private async getCommentDetails(commentId: string, accessToken: string): Promise<FacebookComment | null> {
+      // Handle hide action
+      if (hideComment) {
         try {
-            const response = await axios.get(
-                `${this.apiBaseUrl}/${commentId}`,
-                {
-                    params: {
-                        access_token: accessToken,
-                        fields: 'id,message,created_time,from,like_count,comment_count,parent'
-                    }
-                }
-            );
-
-            return response.data;
+          await this.hideCommentAction(commentId, accessToken!, true);
+          results.actions.push({ action: 'hide', success: true });
+          LogStatus(`Hidden comment ${commentId}`);
         } catch (error) {
-            LogError(`Failed to get comment details: ${error}`);
-            return null;
+          LogError(`Failed to hide comment: ${error}`);
+          results.actions.push({
+            action: 'hide',
+            success: false,
+            error: error instanceof Error ? error.message : 'Unknown error',
+          });
         }
-    }
+      }
 
-    /**
-     * Reply to a comment
-     */
-    private async replyToComment(
-        commentId: string,
-        message: string | null,
-        attachmentUrl: string | null,
-        privateReply: boolean,
-        accessToken: string
-    ): Promise<any> {
-        const endpoint = privateReply 
-            ? `${this.apiBaseUrl}/${commentId}/private_replies`
-            : `${this.apiBaseUrl}/${commentId}/comments`;
-
-        const data: any = {};
-        
-        if (message) {
-            data.message = message;
+      // Handle like action
+      if (likeComment) {
+        try {
+          await this.likeCommentAction(commentId, accessToken!);
+          results.actions.push({ action: 'like', success: true });
+          LogStatus(`Liked comment ${commentId}`);
+        } catch (error) {
+          LogError(`Failed to like comment: ${error}`);
+          results.actions.push({
+            action: 'like',
+            success: false,
+            error: error instanceof Error ? error.message : 'Unknown error',
+          });
         }
-        
-        if (attachmentUrl) {
-            data.attachment_url = attachmentUrl;
+      }
+
+      // Handle reply action
+      if (responseText || attachmentUrl) {
+        try {
+          const replyResult = await this.replyToComment(commentId, responseText, attachmentUrl, privateReply, accessToken!);
+
+          results.actions.push({
+            action: privateReply ? 'private_reply' : 'reply',
+            success: true,
+            replyId: replyResult.id,
+            message: responseText,
+          });
+
+          LogStatus(`Replied to comment ${commentId}`);
+        } catch (error) {
+          LogError(`Failed to reply to comment: ${error}`);
+          results.actions.push({
+            action: privateReply ? 'private_reply' : 'reply',
+            success: false,
+            error: error instanceof Error ? error.message : 'Unknown error',
+          });
         }
+      }
+
+      // Check if any actions succeeded
+      const successfulActions = results.actions.filter((a: any) => a.success);
+      if (successfulActions.length === 0) {
+        return {
+          Success: false,
+          Message: 'All requested actions failed',
+          ResultCode: 'ERROR',
+        };
+      }
 
-        const response = await axios.post(endpoint, data, {
-            params: {
-                access_token: accessToken
-            }
-        });
+      return {
+        Success: true,
+        Message: `Successfully completed ${successfulActions.length} of ${results.actions.length} actions`,
+        ResultCode: 'SUCCESS',
+        Params,
+      };
+    } catch (error) {
+      LogError(`Failed to respond to Facebook comment: ${error instanceof Error ? error.message : 'Unknown error'}`);
 
-        return response.data;
+      if (this.isAuthError(error)) {
+        return this.handleOAuthError(error);
+      }
+
+      return {
+        Success: false,
+        Message: error instanceof Error ? error.message : 'Unknown error occurred',
+        ResultCode: 'ERROR',
+      };
     }
+  }
+
+  /**
+   * Get comment details
+   */
+  private async getCommentDetails(commentId: string, accessToken: string): Promise<FacebookComment | null> {
+    try {
+      const response = await axios.get(`${this.apiBaseUrl}/${commentId}`, {
+        params: {
+          access_token: accessToken,
+          fields: 'id,message,created_time,from,like_count,comment_count,parent',
+        },
+      });
 
-    /**
-     * Like a comment
-     */
-    private async likeCommentAction(commentId: string, accessToken: string): Promise<void> {
-        await axios.post(
-            `${this.apiBaseUrl}/${commentId}/likes`,
-            {},
-            {
-                params: {
-                    access_token: accessToken
-                }
-            }
-        );
+      return response.data;
+    } catch (error) {
+      LogError(`Failed to get comment details: ${error}`);
+      return null;
     }
+  }
+
+  /**
+   * Reply to a comment
+   */
+  private async replyToComment(
+    commentId: string,
+    message: string | null,
+    attachmentUrl: string | null,
+    privateReply: boolean,
+    accessToken: string
+  ): Promise<any> {
+    const endpoint = privateReply ? `${this.apiBaseUrl}/${commentId}/private_replies` : `${this.apiBaseUrl}/${commentId}/comments`;
+
+    const data: any = {};
 
-    /**
-     * Hide or unhide a comment
-     */
-    private async hideCommentAction(commentId: string, accessToken: string, hide: boolean): Promise<void> {
-        await axios.post(
-            `${this.apiBaseUrl}/${commentId}`,
-            {
-                is_hidden: hide
-            },
-            {
-                params: {
-                    access_token: accessToken
-                }
-            }
-        );
+    if (message) {
+      data.message = message;
     }
 
-    /**
-     * Delete a comment
-     */
-    private async deleteCommentAction(commentId: string, accessToken: string): Promise<void> {
-        await axios.delete(
-            `${this.apiBaseUrl}/${commentId}`,
-            {
-                params: {
-                    access_token: accessToken
-                }
-            }
-        );
+    if (attachmentUrl) {
+      data.attachment_url = attachmentUrl;
     }
 
+    const response = await axios.post(endpoint, data, {
+      params: {
+        access_token: accessToken,
+      },
+    });
+
+    return response.data;
+  }
+
+  /**
+   * Like a comment
+   */
+  private async likeCommentAction(commentId: string, accessToken: string): Promise<void> {
+    await axios.post(
+      `${this.apiBaseUrl}/${commentId}/likes`,
+      {},
+      {
+        params: {
+          access_token: accessToken,
+        },
+      }
+    );
+  }
+
+  /**
+   * Hide or unhide a comment
+   */
+  private async hideCommentAction(commentId: string, accessToken: string, hide: boolean): Promise<void> {
+    await axios.post(
+      `${this.apiBaseUrl}/${commentId}`,
+      {
+        is_hidden: hide,
+      },
+      {
+        params: {
+          access_token: accessToken,
+        },
+      }
+    );
+  }
 
-}
+  /**
+   * Delete a comment
+   */
+  private async deleteCommentAction(commentId: string, accessToken: string): Promise<void> {
+    await axios.delete(`${this.apiBaseUrl}/${commentId}`, {
+      params: {
+        access_token: accessToken,
+      },
+    });
+  }
+}