@memberjunction/actions-bizapps-social 2.61.0

package/src/base/base-social.action.ts

@@ -0,0 +1,270 @@
+import { BaseOAuthAction } from '@memberjunction/actions';
+import { ActionParam } from '@memberjunction/actions-base';
+import { LogStatus, LogError } from '@memberjunction/core';
+
+/**
+ * Common interfaces for social media actions
+ */
+export interface SocialPost {
+    id: string;
+    platform: string;
+    profileId: string;
+    content: string;
+    mediaUrls: string[];
+    publishedAt: Date;
+    scheduledFor?: Date;
+    analytics?: SocialAnalytics;
+    platformSpecificData: Record<string, any>;
+}
+
+export interface SocialAnalytics {
+    impressions: number;
+    engagements: number;
+    clicks: number;
+    shares: number;
+    comments: number;
+    likes: number;
+    reach: number;
+    saves?: number;
+    videoViews?: number;
+    platformMetrics: Record<string, any>;
+}
+
+export interface SearchParams {
+    query?: string;
+    hashtags?: string[];
+    startDate?: Date;
+    endDate?: Date;
+    limit?: number;
+    offset?: number;
+}
+
+export interface MediaFile {
+    filename: string;
+    mimeType: string;
+    data: Buffer | string; // Base64 or buffer
+    size: number;
+}
+
+export enum SocialMediaErrorCode {
+    RATE_LIMIT_EXCEEDED = 'RATE_LIMIT',
+    INVALID_TOKEN = 'INVALID_TOKEN',
+    TOKEN_EXPIRED = 'TOKEN_EXPIRED',
+    PLATFORM_ERROR = 'PLATFORM_ERROR',
+    INVALID_MEDIA = 'INVALID_MEDIA',
+    POST_NOT_FOUND = 'POST_NOT_FOUND',
+    INSUFFICIENT_PERMISSIONS = 'INSUFFICIENT_PERMISSIONS'
+}
+
+/**
+ * Base class for all social media actions.
+ * Provides common functionality for authentication, media handling,
+ * analytics normalization, and rate limiting.
+ */
+export abstract class BaseSocialMediaAction extends BaseOAuthAction {
+    
+    /**
+     * Common parameters for all social media actions
+     */
+    protected get commonSocialParams(): ActionParam[] {
+        return [
+            ...this.oauthParams,
+            {
+                Name: 'ProfileID',
+                Type: 'Input',
+                Value: null
+            }
+        ];
+    }
+
+    /**
+     * Get the platform name (e.g., 'Twitter', 'LinkedIn')
+     */
+    protected abstract get platformName(): string;
+
+    /**
+     * Get the API base URL for the platform
+     */
+    protected abstract get apiBaseUrl(): string;
+
+    /**
+     * Normalize platform-specific analytics to common format
+     */
+    protected normalizeAnalytics(platformData: any): SocialAnalytics {
+        // Default implementation - override in platform-specific classes
+        return {
+            impressions: platformData.impressions || 0,
+            engagements: platformData.engagements || 0,
+            clicks: platformData.clicks || 0,
+            shares: platformData.shares || 0,
+            comments: platformData.comments || 0,
+            likes: platformData.likes || 0,
+            reach: platformData.reach || 0,
+            saves: platformData.saves,
+            videoViews: platformData.videoViews,
+            platformMetrics: platformData
+        };
+    }
+
+    /**
+     * Upload media files to the platform
+     */
+    protected async uploadMedia(files: MediaFile[]): Promise<string[]> {
+        const uploadedUrls: string[] = [];
+        
+        for (const file of files) {
+            // Validate file
+            this.validateMediaFile(file);
+            
+            // Upload file (platform-specific implementation)
+            const url = await this.uploadSingleMedia(file);
+            uploadedUrls.push(url);
+        }
+        
+        return uploadedUrls;
+    }
+
+    /**
+     * Platform-specific media upload implementation
+     */
+    protected abstract uploadSingleMedia(file: MediaFile): Promise<string>;
+
+    /**
+     * Validate media file meets platform requirements
+     */
+    protected validateMediaFile(file: MediaFile): void {
+        const maxSizes: Record<string, number> = {
+            'image/jpeg': 5 * 1024 * 1024, // 5MB
+            'image/png': 5 * 1024 * 1024,  // 5MB
+            'image/gif': 15 * 1024 * 1024, // 15MB
+            'video/mp4': 512 * 1024 * 1024 // 512MB
+        };
+
+        const maxSize = maxSizes[file.mimeType];
+        if (!maxSize) {
+            throw new Error(`Unsupported media type: ${file.mimeType}`);
+        }
+
+        if (file.size > maxSize) {
+            throw new Error(`File size exceeds limit. Max ${maxSize} bytes, got ${file.size} bytes`);
+        }
+    }
+
+    /**
+     * Handle rate limiting with exponential backoff
+     */
+    protected async handleRateLimit(retryAfter?: number): Promise<void> {
+        const waitTime = retryAfter || 60; // Default to 60 seconds
+        LogStatus(`Rate limit hit. Waiting ${waitTime} seconds...`);
+        
+        await new Promise(resolve => setTimeout(resolve, waitTime * 1000));
+    }
+
+    /**
+     * Search for posts on the platform
+     */
+    protected abstract searchPosts(params: SearchParams): Promise<SocialPost[]>;
+
+    /**
+     * Convert platform-specific post data to common format
+     */
+    protected abstract normalizePost(platformPost: any): SocialPost;
+
+    /**
+     * Parse rate limit headers from API response
+     */
+    protected parseRateLimitHeaders(headers: any): {
+        remaining: number;
+        reset: Date;
+        limit: number;
+    } | null {
+        // Common header patterns across platforms
+        const remaining = headers['x-rate-limit-remaining'] || 
+                         headers['x-ratelimit-remaining'] ||
+                         headers['rate-limit-remaining'];
+                         
+        const reset = headers['x-rate-limit-reset'] || 
+                     headers['x-ratelimit-reset'] ||
+                     headers['rate-limit-reset'];
+                     
+        const limit = headers['x-rate-limit-limit'] || 
+                     headers['x-ratelimit-limit'] ||
+                     headers['rate-limit-limit'];
+
+        if (remaining !== undefined && reset && limit) {
+            return {
+                remaining: parseInt(remaining),
+                reset: new Date(parseInt(reset) * 1000), // Usually Unix timestamp
+                limit: parseInt(limit)
+            };
+        }
+
+        return null;
+    }
+
+    /**
+     * Build common API headers including authentication
+     */
+    protected buildHeaders(additionalHeaders?: Record<string, string>): Record<string, string> {
+        const token = this.getAccessToken();
+        if (!token) {
+            throw new Error('No access token available');
+        }
+
+        return {
+            'Authorization': `Bearer ${token}`,
+            'Content-Type': 'application/json',
+            'Accept': 'application/json',
+            ...additionalHeaders
+        };
+    }
+
+    /**
+     * Format date for API requests (ISO 8601)
+     */
+    protected formatDate(date: Date | string): string {
+        if (typeof date === 'string') {
+            date = new Date(date);
+        }
+        return date.toISOString();
+    }
+
+    /**
+     * Parse date from API response
+     */
+    protected parseDate(dateString: string): Date {
+        return new Date(dateString);
+    }
+
+    /**
+     * Get profile ID from parameters or default from integration
+     */
+    protected getProfileId(params: any): string {
+        return params.ProfileID || this.getCustomAttribute(1) || '';
+    }
+
+    /**
+     * Log API request for debugging
+     */
+    protected logApiRequest(method: string, url: string, data?: any): void {
+        LogStatus(`${this.platformName} API Request: ${method} ${url}`);
+        if (data) {
+            LogStatus(`Request Data: ${JSON.stringify(data, null, 2)}`);
+        }
+    }
+
+    /**
+     * Log API response for debugging
+     */
+    protected logApiResponse(response: any): void {
+        LogStatus(`${this.platformName} API Response: ${JSON.stringify(response, null, 2)}`);
+    }
+
+    /**
+     * Helper to get parameter value from params array
+     */
+    protected getParamValue(params: ActionParam[], paramName: string): any {
+        const param = params.find(p => p.Name === paramName);
+        return param?.Value;
+    }
+}

package/src/index.ts

@@ -0,0 +1,26 @@
+// Base classes
+export * from './base/base-social.action';
+
+// HootSuite
+export * from './providers/hootsuite';
+
+// Buffer
+export * from './providers/buffer';
+
+// LinkedIn
+export * from './providers/linkedin';
+
+// Twitter/X
+export * from './providers/twitter';
+
+// Facebook
+export * from './providers/facebook';
+
+// Instagram
+export * from './providers/instagram';
+
+// TikTok
+export * from './providers/tiktok';
+
+// YouTube
+export * from './providers/youtube';

package/src/providers/buffer/actions/create-post.action.ts

@@ -0,0 +1,205 @@
+import { RegisterClass } from '@memberjunction/global';
+import { BufferBaseAction } from '../buffer-base.action';
+import { ActionParam, ActionResultSimple, RunActionParams } from '@memberjunction/actions-base';
+import { MediaFile } from '../../../base/base-social.action';
+
+/**
+ * Action to create a new post in Buffer (scheduled or immediate)
+ */
+@RegisterClass(BufferBaseAction, 'BufferCreatePostAction')
+export class BufferCreatePostAction extends BufferBaseAction {
+    /**
+     * Create a Buffer post
+     */
+    protected async InternalRunAction(params: RunActionParams): Promise<ActionResultSimple> {
+        const { Params, ContextUser } = params;
+        
+        try {
+            // Get parameters
+            const companyIntegrationId = this.getParamValue(Params, 'CompanyIntegrationID');
+            const profileIds = this.getParamValue(Params, 'ProfileIDs');
+            const content = this.getParamValue(Params, 'Content');
+            const mediaFiles = this.getParamValue(Params, 'MediaFiles');
+            const scheduledTime = this.getParamValue(Params, 'ScheduledTime');
+            const postNow = this.getParamValue(Params, 'PostNow');
+            const addToTop = this.getParamValue(Params, 'AddToTop');
+            const shortenLinks = this.getParamValue(Params, 'ShortenLinks');
+            const mediaLink = this.getParamValue(Params, 'MediaLink');
+            const mediaDescription = this.getParamValue(Params, 'MediaDescription');
+
+            // Validate required parameters
+            if (!companyIntegrationId) {
+                throw new Error('CompanyIntegrationID is required');
+            }
+
+            if (!profileIds || !Array.isArray(profileIds) || profileIds.length === 0) {
+                throw new Error('ProfileIDs array is required with at least one profile');
+            }
+
+            if (!content && !mediaFiles && !mediaLink) {
+                throw new Error('Content, MediaFiles, or MediaLink is required');
+            }
+
+            // Initialize OAuth
+            if (!await this.initializeOAuth(companyIntegrationId)) {
+                return {
+                    Success: false,
+                    ResultCode: 'INVALID_TOKEN',
+                    Message: 'Failed to initialize Buffer OAuth connection',
+                    Params
+                };
+            }
+
+            // Prepare media array
+            const media: any[] = [];
+
+            // Upload media files if provided
+            if (mediaFiles && Array.isArray(mediaFiles) && mediaFiles.length > 0) {
+                const uploadedUrls = await this.uploadMedia(mediaFiles as MediaFile[]);
+                uploadedUrls.forEach(url => {
+                    media.push({ picture: url });
+                });
+            }
+
+            // Add media link if provided
+            if (mediaLink) {
+                const mediaItem: any = { link: mediaLink };
+                if (mediaDescription) {
+                    mediaItem.description = mediaDescription;
+                }
+                media.push(mediaItem);
+            }
+
+            // Create the update
+            const result = await this.createUpdate(
+                profileIds,
+                content || '',
+                media.length > 0 ? media : undefined,
+                scheduledTime ? new Date(scheduledTime) : undefined,
+                {
+                    now: postNow === true,
+                    top: addToTop === true,
+                    shorten: shortenLinks !== false // Default to true
+                }
+            );
+
+            // Format the response
+            const createdPosts = result.updates || [];
+            const formattedPosts = createdPosts.map((update: any) => ({
+                id: update.id,
+                profileId: update.profile_id,
+                service: update.profile_service,
+                status: update.status,
+                scheduledAt: update.due_at ? new Date(update.due_at * 1000) : null,
+                text: update.text,
+                media: update.media,
+                createdAt: update.created_at ? new Date(update.created_at * 1000) : new Date()
+            }));
+
+            // Create summary
+            const summary = {
+                totalCreated: formattedPosts.length,
+                profilesPosted: profileIds,
+                scheduled: !postNow,
+                scheduledTime: scheduledTime || null,
+                hasMedia: media.length > 0
+            };
+
+            // Update output parameters
+            const outputParams = [...Params];
+            const postsParam = outputParams.find(p => p.Name === 'CreatedPosts');
+            if (postsParam) postsParam.Value = formattedPosts;
+            const summaryParam = outputParams.find(p => p.Name === 'Summary');
+            if (summaryParam) summaryParam.Value = summary;
+
+            return {
+                Success: true,
+                ResultCode: 'SUCCESS',
+                Message: `Successfully created ${formattedPosts.length} Buffer post(s)`,
+                Params: outputParams
+            };
+
+        } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            const resultCode = this.mapBufferError(error);
+            
+            return {
+                Success: false,
+                ResultCode: resultCode,
+                Message: `Failed to create Buffer post: ${errorMessage}`,
+                Params
+            };
+        }
+    }
+
+    /**
+     * Define the parameters this action expects
+     */
+    public get Params(): ActionParam[] {
+        return [
+            ...this.commonSocialParams,
+            {
+                Name: 'ProfileIDs',
+                Type: 'Input',
+                Value: null
+            },
+            {
+                Name: 'Content',
+                Type: 'Input',
+                Value: null
+            },
+            {
+                Name: 'MediaFiles',
+                Type: 'Input',
+                Value: null
+            },
+            {
+                Name: 'MediaLink',
+                Type: 'Input',
+                Value: null
+            },
+            {
+                Name: 'MediaDescription',
+                Type: 'Input',
+                Value: null
+            },
+            {
+                Name: 'ScheduledTime',
+                Type: 'Input',
+                Value: null
+            },
+            {
+                Name: 'PostNow',
+                Type: 'Input',
+                Value: false
+            },
+            {
+                Name: 'AddToTop',
+                Type: 'Input',
+                Value: false
+            },
+            {
+                Name: 'ShortenLinks',
+                Type: 'Input',
+                Value: true
+            },
+            {
+                Name: 'CreatedPosts',
+                Type: 'Output',
+                Value: null
+            },
+            {
+                Name: 'Summary',
+                Type: 'Output',
+                Value: null
+            }
+        ];
+    }
+
+    /**
+     * Metadata about this action
+     */
+    public get Description(): string {
+        return 'Creates a new post in Buffer that can be scheduled or posted immediately to one or more social media profiles';
+    }
+}

package/src/providers/buffer/actions/delete-post.action.ts

@@ -0,0 +1,116 @@
+import { RegisterClass } from '@memberjunction/global';
+import { BufferBaseAction } from '../buffer-base.action';
+import { ActionParam, ActionResultSimple, RunActionParams } from '@memberjunction/actions-base';
+
+/**
+ * Action to delete a post from Buffer
+ */
+@RegisterClass(BufferBaseAction, 'BufferDeletePostAction')
+export class BufferDeletePostAction extends BufferBaseAction {
+    /**
+     * Delete a Buffer post
+     */
+    protected async InternalRunAction(params: RunActionParams): Promise<ActionResultSimple> {
+        const { Params, ContextUser } = params;
+        
+        try {
+            // Get parameters
+            const companyIntegrationId = this.getParamValue(Params, 'CompanyIntegrationID');
+            const updateId = this.getParamValue(Params, 'UpdateID');
+
+            // Validate required parameters
+            if (!companyIntegrationId) {
+                throw new Error('CompanyIntegrationID is required');
+            }
+
+            if (!updateId) {
+                throw new Error('UpdateID is required');
+            }
+
+            // Initialize OAuth
+            if (!await this.initializeOAuth(companyIntegrationId)) {
+                return {
+                    Success: false,
+                    ResultCode: 'INVALID_TOKEN',
+                    Message: 'Failed to initialize Buffer OAuth connection',
+                    Params
+                };
+            }
+
+            // Delete the update
+            const success = await this.deleteUpdate(updateId);
+
+            // Create summary
+            const summary = {
+                updateId: updateId,
+                deleted: success,
+                deletedAt: new Date()
+            };
+
+            // Update output parameters
+            const outputParams = [...Params];
+            const deletedParam = outputParams.find(p => p.Name === 'Deleted');
+            if (deletedParam) deletedParam.Value = success;
+            const summaryParam = outputParams.find(p => p.Name === 'Summary');
+            if (summaryParam) summaryParam.Value = summary;
+
+            if (success) {
+                return {
+                    Success: true,
+                    ResultCode: 'SUCCESS',
+                    Message: `Successfully deleted Buffer post ${updateId}`,
+                    Params: outputParams
+                };
+            } else {
+                return {
+                    Success: false,
+                    ResultCode: 'DELETE_FAILED',
+                    Message: `Failed to delete Buffer post ${updateId}`,
+                    Params: outputParams
+                };
+            }
+
+        } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            const resultCode = this.mapBufferError(error);
+            
+            return {
+                Success: false,
+                ResultCode: resultCode,
+                Message: `Failed to delete post: ${errorMessage}`,
+                Params
+            };
+        }
+    }
+
+    /**
+     * Define the parameters this action expects
+     */
+    public get Params(): ActionParam[] {
+        return [
+            ...this.commonSocialParams,
+            {
+                Name: 'UpdateID',
+                Type: 'Input',
+                Value: null
+            },
+            {
+                Name: 'Deleted',
+                Type: 'Output',
+                Value: false
+            },
+            {
+                Name: 'Summary',
+                Type: 'Output',
+                Value: null
+            }
+        ];
+    }
+
+    /**
+     * Metadata about this action
+     */
+    public get Description(): string {
+        return 'Deletes a pending or sent post from Buffer';
+    }
+}