@memberjunction/actions-bizapps-social 2.61.0

package/src/providers/buffer/actions/get-analytics.action.ts

@@ -0,0 +1,146 @@
+import { RegisterClass } from '@memberjunction/global';
+import { BufferBaseAction } from '../buffer-base.action';
+import { ActionParam, ActionResultSimple, RunActionParams } from '@memberjunction/actions-base';
+
+/**
+ * Action to get detailed analytics for a specific Buffer post
+ */
+@RegisterClass(BufferBaseAction, 'BufferGetAnalyticsAction')
+export class BufferGetAnalyticsAction extends BufferBaseAction {
+    /**
+     * Get analytics for 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
+                };
+            }
+
+            // Get analytics
+            const analyticsData = await this.getAnalytics(updateId);
+
+            // Normalize analytics
+            const normalizedAnalytics = this.normalizeAnalytics(analyticsData);
+
+            // Create detailed analytics object
+            const detailedAnalytics = {
+                updateId: updateId,
+                metrics: normalizedAnalytics,
+                platformSpecific: analyticsData,
+                summary: {
+                    totalEngagements: normalizedAnalytics.engagements,
+                    engagementRate: analyticsData.reach > 0 ? 
+                        (normalizedAnalytics.engagements / analyticsData.reach) * 100 : 0,
+                    primaryMetric: this.determinePrimaryMetric(analyticsData),
+                    performanceLevel: this.calculatePerformanceLevel(normalizedAnalytics)
+                }
+            };
+
+            // Update output parameters
+            const outputParams = [...Params];
+            const analyticsParam = outputParams.find(p => p.Name === 'Analytics');
+            if (analyticsParam) analyticsParam.Value = detailedAnalytics;
+
+            return {
+                Success: true,
+                ResultCode: 'SUCCESS',
+                Message: `Successfully retrieved analytics for 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 get analytics: ${errorMessage}`,
+                Params
+            };
+        }
+    }
+
+    /**
+     * Determine the primary metric based on the platform
+     */
+    private determinePrimaryMetric(analytics: any): { name: string; value: number } {
+        // Twitter/X focuses on retweets
+        if (analytics.retweets !== undefined) {
+            return { name: 'Retweets', value: analytics.retweets || 0 };
+        }
+        
+        // Facebook focuses on shares
+        if (analytics.shares !== undefined) {
+            return { name: 'Shares', value: analytics.shares || 0 };
+        }
+        
+        // LinkedIn focuses on reach
+        if (analytics.reach !== undefined && analytics.reach > 0) {
+            return { name: 'Reach', value: analytics.reach };
+        }
+        
+        // Default to clicks
+        return { name: 'Clicks', value: analytics.clicks || 0 };
+    }
+
+    /**
+     * Calculate performance level based on engagement metrics
+     */
+    private calculatePerformanceLevel(analytics: any): 'low' | 'medium' | 'high' | 'viral' {
+        const engagementRate = analytics.reach > 0 ? 
+            (analytics.engagements / analytics.reach) * 100 : 0;
+
+        if (engagementRate >= 10) return 'viral';
+        if (engagementRate >= 5) return 'high';
+        if (engagementRate >= 2) return 'medium';
+        return 'low';
+    }
+
+    /**
+     * Define the parameters this action expects
+     */
+    public get Params(): ActionParam[] {
+        return [
+            ...this.commonSocialParams,
+            {
+                Name: 'UpdateID',
+                Type: 'Input',
+                Value: null
+            },
+            {
+                Name: 'Analytics',
+                Type: 'Output',
+                Value: null
+            }
+        ];
+    }
+
+    /**
+     * Metadata about this action
+     */
+    public get Description(): string {
+        return 'Retrieves detailed analytics and interaction metrics for a specific Buffer post';
+    }
+}

package/src/providers/buffer/actions/get-pending-posts.action.ts

@@ -0,0 +1,161 @@
+import { RegisterClass } from '@memberjunction/global';
+import { BufferBaseAction } from '../buffer-base.action';
+import { ActionParam, ActionResultSimple, RunActionParams } from '@memberjunction/actions-base';
+
+/**
+ * Action to get pending (scheduled) posts from Buffer
+ */
+@RegisterClass(BufferBaseAction, 'BufferGetPendingPostsAction')
+export class BufferGetPendingPostsAction extends BufferBaseAction {
+    /**
+     * Get pending posts from Buffer
+     */
+    protected async InternalRunAction(params: RunActionParams): Promise<ActionResultSimple> {
+        const { Params, ContextUser } = params;
+        
+        try {
+            // Get parameters
+            const companyIntegrationId = this.getParamValue(Params, 'CompanyIntegrationID');
+            const profileId = this.getParamValue(Params, 'ProfileID');
+            const page = this.getParamValue(Params, 'Page') || 1;
+            const count = this.getParamValue(Params, 'Count') || 10;
+            const since = this.getParamValue(Params, 'Since');
+            const useUTC = this.getParamValue(Params, 'UseUTC') !== false;
+
+            // Validate required parameters
+            if (!companyIntegrationId) {
+                throw new Error('CompanyIntegrationID is required');
+            }
+
+            if (!profileId) {
+                throw new Error('ProfileID is required');
+            }
+
+            // Initialize OAuth
+            if (!await this.initializeOAuth(companyIntegrationId)) {
+                return {
+                    Success: false,
+                    ResultCode: 'INVALID_TOKEN',
+                    Message: 'Failed to initialize Buffer OAuth connection',
+                    Params
+                };
+            }
+
+            // Get pending posts
+            const result = await this.getUpdates(profileId, 'pending', {
+                page,
+                count,
+                since: since ? new Date(since) : undefined,
+                utc: useUTC
+            });
+
+            // Format posts
+            const posts = result.updates || [];
+            const formattedPosts = posts.map((update: any) => this.normalizePost(update));
+
+            // Create summary
+            const summary = {
+                totalPosts: formattedPosts.length,
+                page: page,
+                hasMore: posts.length === count,
+                profileId: profileId,
+                dateRange: {
+                    earliest: formattedPosts.length > 0 ? 
+                        formattedPosts[formattedPosts.length - 1].scheduledFor : null,
+                    latest: formattedPosts.length > 0 ? 
+                        formattedPosts[0].scheduledFor : null
+                },
+                postsByDay: this.groupPostsByDay(formattedPosts)
+            };
+
+            // Update output parameters
+            const outputParams = [...Params];
+            const postsParam = outputParams.find(p => p.Name === 'Posts');
+            if (postsParam) postsParam.Value = formattedPosts;
+            const summaryParam = outputParams.find(p => p.Name === 'Summary');
+            if (summaryParam) summaryParam.Value = summary;
+
+            return {
+                Success: true,
+                ResultCode: 'SUCCESS',
+                Message: `Retrieved ${formattedPosts.length} pending posts from Buffer`,
+                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 get pending posts: ${errorMessage}`,
+                Params
+            };
+        }
+    }
+
+    /**
+     * Group posts by scheduled day
+     */
+    private groupPostsByDay(posts: any[]): Record<string, number> {
+        return posts.reduce((acc, post) => {
+            if (post.scheduledFor) {
+                const day = post.scheduledFor.toISOString().split('T')[0];
+                acc[day] = (acc[day] || 0) + 1;
+            }
+            return acc;
+        }, {} as Record<string, number>);
+    }
+
+    /**
+     * Define the parameters this action expects
+     */
+    public get Params(): ActionParam[] {
+        return [
+            ...this.commonSocialParams,
+            {
+                Name: 'ProfileID',
+                Type: 'Input',
+                Value: null
+            },
+            {
+                Name: 'Page',
+                Type: 'Input',
+                Value: 1
+            },
+            {
+                Name: 'Count',
+                Type: 'Input',
+                Value: 10
+            },
+            {
+                Name: 'Since',
+                Type: 'Input',
+                Value: null
+            },
+            {
+                Name: 'UseUTC',
+                Type: 'Input',
+                Value: true
+            },
+            {
+                Name: 'Posts',
+                Type: 'Output',
+                Value: null
+            },
+            {
+                Name: 'Summary',
+                Type: 'Output',
+                Value: null
+            }
+        ];
+    }
+
+    /**
+     * Metadata about this action
+     */
+    public get Description(): string {
+        return 'Retrieves pending (scheduled) posts from Buffer for a specific social media profile';
+    }
+}

package/src/providers/buffer/actions/get-profiles.action.ts

@@ -0,0 +1,126 @@
+import { RegisterClass } from '@memberjunction/global';
+import { BufferBaseAction } from '../buffer-base.action';
+import { ActionParam, ActionResultSimple, RunActionParams } from '@memberjunction/actions-base';
+
+/**
+ * Action to get all Buffer profiles (social media accounts) for the authenticated user
+ */
+@RegisterClass(BufferBaseAction, 'BufferGetProfilesAction')
+export class BufferGetProfilesAction extends BufferBaseAction {
+    /**
+     * Get Buffer profiles
+     */
+    protected async InternalRunAction(params: RunActionParams): Promise<ActionResultSimple> {
+        const { Params, ContextUser } = params;
+        
+        try {
+            // Get company integration ID
+            const companyIntegrationId = this.getParamValue(Params, 'CompanyIntegrationID');
+            if (!companyIntegrationId) {
+                throw new Error('CompanyIntegrationID is required');
+            }
+
+            // Initialize OAuth
+            if (!await this.initializeOAuth(companyIntegrationId)) {
+                return {
+                    Success: false,
+                    ResultCode: 'INVALID_TOKEN',
+                    Message: 'Failed to initialize Buffer OAuth connection',
+                    Params
+                };
+            }
+
+            // Get profiles
+            const profiles = await this.getProfiles();
+
+            // Format profile data
+            const formattedProfiles = profiles.map(profile => ({
+                id: profile.id,
+                service: profile.service,
+                serviceId: profile.service_id,
+                serviceUsername: profile.service_username,
+                serviceType: profile.service_type,
+                default: profile.default,
+                createdAt: new Date(profile.created_at * 1000),
+                formattedUsername: profile.formatted_username,
+                formattedServiceType: profile.formatted_service,
+                avatar: profile.avatar,
+                avatarHttps: profile.avatar_https,
+                statistics: {
+                    followers: profile.statistics?.followers || 0
+                },
+                timezone: profile.timezone,
+                schedules: profile.schedules || []
+            }));
+
+            // Create summary
+            const summary = {
+                totalProfiles: formattedProfiles.length,
+                profilesByService: this.groupByService(formattedProfiles),
+                defaultProfile: formattedProfiles.find(p => p.default)?.id
+            };
+
+            // Update output parameters
+            const outputParams = [...Params];
+            const profilesParam = outputParams.find(p => p.Name === 'Profiles');
+            if (profilesParam) profilesParam.Value = formattedProfiles;
+            const summaryParam = outputParams.find(p => p.Name === 'Summary');
+            if (summaryParam) summaryParam.Value = summary;
+
+            return {
+                Success: true,
+                ResultCode: 'SUCCESS',
+                Message: `Retrieved ${formattedProfiles.length} Buffer profiles`,
+                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 get Buffer profiles: ${errorMessage}`,
+                Params
+            };
+        }
+    }
+
+    /**
+     * Group profiles by service
+     */
+    private groupByService(profiles: any[]): Record<string, number> {
+        return profiles.reduce((acc, profile) => {
+            const service = profile.service || 'unknown';
+            acc[service] = (acc[service] || 0) + 1;
+            return acc;
+        }, {} as Record<string, number>);
+    }
+
+    /**
+     * Define the parameters this action expects
+     */
+    public get Params(): ActionParam[] {
+        return [
+            ...this.commonSocialParams,
+            {
+                Name: 'Profiles',
+                Type: 'Output',
+                Value: null
+            },
+            {
+                Name: 'Summary',
+                Type: 'Output',
+                Value: null
+            }
+        ];
+    }
+
+    /**
+     * Metadata about this action
+     */
+    public get Description(): string {
+        return 'Retrieves all Buffer profiles (social media accounts) associated with the authenticated user';
+    }
+}

package/src/providers/buffer/actions/get-sent-posts.action.ts

@@ -0,0 +1,189 @@
+import { RegisterClass } from '@memberjunction/global';
+import { BufferBaseAction } from '../buffer-base.action';
+import { ActionParam, ActionResultSimple, RunActionParams } from '@memberjunction/actions-base';
+
+/**
+ * Action to get sent (published) posts from Buffer
+ */
+@RegisterClass(BufferBaseAction, 'BufferGetSentPostsAction')
+export class BufferGetSentPostsAction extends BufferBaseAction {
+    /**
+     * Get sent posts from Buffer
+     */
+    protected async InternalRunAction(params: RunActionParams): Promise<ActionResultSimple> {
+        const { Params, ContextUser } = params;
+        
+        try {
+            // Get parameters
+            const companyIntegrationId = this.getParamValue(Params, 'CompanyIntegrationID');
+            const profileId = this.getParamValue(Params, 'ProfileID');
+            const page = this.getParamValue(Params, 'Page') || 1;
+            const count = this.getParamValue(Params, 'Count') || 10;
+            const since = this.getParamValue(Params, 'Since');
+            const useUTC = this.getParamValue(Params, 'UseUTC') !== false;
+
+            // Validate required parameters
+            if (!companyIntegrationId) {
+                throw new Error('CompanyIntegrationID is required');
+            }
+
+            if (!profileId) {
+                throw new Error('ProfileID is required');
+            }
+
+            // Initialize OAuth
+            if (!await this.initializeOAuth(companyIntegrationId)) {
+                return {
+                    Success: false,
+                    ResultCode: 'INVALID_TOKEN',
+                    Message: 'Failed to initialize Buffer OAuth connection',
+                    Params
+                };
+            }
+
+            // Get sent posts
+            const result = await this.getUpdates(profileId, 'sent', {
+                page,
+                count,
+                since: since ? new Date(since) : undefined,
+                utc: useUTC
+            });
+
+            // Format posts
+            const posts = result.updates || [];
+            const formattedPosts = posts.map((update: any) => this.normalizePost(update));
+
+            // Create summary
+            const summary = {
+                totalPosts: formattedPosts.length,
+                page: page,
+                hasMore: posts.length === count,
+                profileId: profileId,
+                dateRange: {
+                    earliest: formattedPosts.length > 0 ? 
+                        formattedPosts[formattedPosts.length - 1].publishedAt : null,
+                    latest: formattedPosts.length > 0 ? 
+                        formattedPosts[0].publishedAt : null
+                },
+                postsByDay: this.groupPostsByDay(formattedPosts),
+                totalEngagements: this.calculateTotalEngagements(formattedPosts),
+                topPerformingPost: this.findTopPerformingPost(formattedPosts)
+            };
+
+            // Update output parameters
+            const outputParams = [...Params];
+            const postsParam = outputParams.find(p => p.Name === 'Posts');
+            if (postsParam) postsParam.Value = formattedPosts;
+            const summaryParam = outputParams.find(p => p.Name === 'Summary');
+            if (summaryParam) summaryParam.Value = summary;
+
+            return {
+                Success: true,
+                ResultCode: 'SUCCESS',
+                Message: `Retrieved ${formattedPosts.length} sent posts from Buffer`,
+                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 get sent posts: ${errorMessage}`,
+                Params
+            };
+        }
+    }
+
+    /**
+     * Group posts by published day
+     */
+    private groupPostsByDay(posts: any[]): Record<string, number> {
+        return posts.reduce((acc, post) => {
+            if (post.publishedAt) {
+                const day = post.publishedAt.toISOString().split('T')[0];
+                acc[day] = (acc[day] || 0) + 1;
+            }
+            return acc;
+        }, {} as Record<string, number>);
+    }
+
+    /**
+     * Calculate total engagements across all posts
+     */
+    private calculateTotalEngagements(posts: any[]): number {
+        return posts.reduce((total, post) => {
+            if (post.analytics) {
+                return total + post.analytics.engagements;
+            }
+            return total;
+        }, 0);
+    }
+
+    /**
+     * Find the top performing post by engagements
+     */
+    private findTopPerformingPost(posts: any[]): any {
+        if (posts.length === 0) return null;
+
+        return posts.reduce((top, post) => {
+            if (!top || (post.analytics?.engagements || 0) > (top.analytics?.engagements || 0)) {
+                return post;
+            }
+            return top;
+        }, posts[0]);
+    }
+
+    /**
+     * Define the parameters this action expects
+     */
+    public get Params(): ActionParam[] {
+        return [
+            ...this.commonSocialParams,
+            {
+                Name: 'ProfileID',
+                Type: 'Input',
+                Value: null
+            },
+            {
+                Name: 'Page',
+                Type: 'Input',
+                Value: 1
+            },
+            {
+                Name: 'Count',
+                Type: 'Input',
+                Value: 10
+            },
+            {
+                Name: 'Since',
+                Type: 'Input',
+                Value: null
+            },
+            {
+                Name: 'UseUTC',
+                Type: 'Input',
+                Value: true
+            },
+            {
+                Name: 'Posts',
+                Type: 'Output',
+                Value: null
+            },
+            {
+                Name: 'Summary',
+                Type: 'Output',
+                Value: null
+            }
+        ];
+    }
+
+    /**
+     * Metadata about this action
+     */
+    public get Description(): string {
+        return 'Retrieves sent (published) posts from Buffer for a specific social media profile with analytics data';
+    }
+}

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

@@ -0,0 +1,8 @@
+export * from './get-profiles.action';
+export * from './create-post.action';
+export * from './get-pending-posts.action';
+export * from './get-sent-posts.action';
+export * from './get-analytics.action';
+export * from './reorder-queue.action';
+export * from './delete-post.action';
+export * from './search-posts.action';