@memberjunction/actions-bizapps-social 2.61.0

package/src/providers/linkedin/actions/get-followers.action.ts

@@ -0,0 +1,226 @@
+import { RegisterClass } from '@memberjunction/global';
+import { LinkedInBaseAction } from '../linkedin-base.action';
+import { ActionParam, ActionResultSimple, RunActionParams } from '@memberjunction/actions-base';
+import { LogStatus, LogError } from '@memberjunction/core';
+
+/**
+ * Action to get follower statistics for LinkedIn profiles and organizations
+ */
+@RegisterClass(LinkedInBaseAction, 'LinkedInGetFollowersAction')
+export class LinkedInGetFollowersAction extends LinkedInBaseAction {
+    /**
+     * Get follower statistics for personal profile or organization
+     */
+    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 entityType = this.getParamValue(Params, 'EntityType') || 'organization'; // 'personal' or 'organization'
+            const organizationId = this.getParamValue(Params, 'OrganizationID');
+            const includeGrowth = this.getParamValue(Params, 'IncludeGrowth') === true;
+            const timeRange = this.getParamValue(Params, 'TimeRange'); // Optional: {start: Date, end: Date}
+
+            let followerData: any = {};
+
+            if (entityType === 'organization') {
+                // Get organization follower statistics
+                let organizationUrn: string;
+                if (!organizationId) {
+                    // Get first admin organization if not specified
+                    const orgs = await this.getAdminOrganizations();
+                    if (orgs.length === 0) {
+                        throw new Error('No organizations found. Please specify OrganizationID.');
+                    }
+                    organizationUrn = orgs[0].urn;
+                    LogStatus(`Using organization: ${orgs[0].name}`);
+                } else {
+                    organizationUrn = `urn:li:organization:${organizationId}`;
+                }
+
+                followerData = await this.getOrganizationFollowers(organizationUrn, includeGrowth, timeRange);
+            } else {
+                // Get personal profile follower statistics
+                const userUrn = await this.getCurrentUserUrn();
+                followerData = await this.getPersonalFollowers(userUrn);
+            }
+
+            // Update output parameters
+            const outputParams = [...Params];
+            const followersParam = outputParams.find(p => p.Name === 'FollowerCount');
+            if (followersParam) followersParam.Value = followerData.followerCount || 0;
+            const statsParam = outputParams.find(p => p.Name === 'FollowerStatistics');
+            if (statsParam) statsParam.Value = followerData;
+
+            return {
+                Success: true,
+                ResultCode: 'SUCCESS',
+                Message: `Successfully retrieved follower statistics`,
+                Params: outputParams
+            };
+
+        } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            
+            return {
+                Success: false,
+                ResultCode: 'ERROR',
+                Message: `Failed to get followers: ${errorMessage}`,
+                Params
+            };
+        }
+    }
+
+    /**
+     * Get organization follower statistics
+     */
+    private async getOrganizationFollowers(organizationUrn: string, includeGrowth: boolean, timeRange?: any): Promise<any> {
+        try {
+            const params: any = {
+                q: 'organizationalEntity',
+                organizationalEntity: organizationUrn
+            };
+
+            // Add time range if specified for growth metrics
+            if (includeGrowth && timeRange) {
+                params.timeIntervals = `List((start:${new Date(timeRange.start).getTime()},end:${new Date(timeRange.end || Date.now()).getTime()}))`;
+            }
+
+            // Get follower statistics
+            const response = await this.axiosInstance.get('/organizationalEntityFollowerStatistics', { params });
+
+            const stats = response.data.elements?.[0] || {};
+            
+            const result: any = {
+                followerCount: stats.followerCounts?.organicFollowerCount || 0,
+                paidFollowerCount: stats.followerCounts?.paidFollowerCount || 0,
+                totalFollowerCount: (stats.followerCounts?.organicFollowerCount || 0) + (stats.followerCounts?.paidFollowerCount || 0)
+            };
+
+            // Add growth metrics if requested
+            if (includeGrowth && stats.followerGains) {
+                result.followerGrowth = {
+                    organicGains: stats.followerGains.organicFollowerGains || 0,
+                    paidGains: stats.followerGains.paidFollowerGains || 0,
+                    totalGains: (stats.followerGains.organicFollowerGains || 0) + (stats.followerGains.paidFollowerGains || 0),
+                    timeRange: timeRange
+                };
+            }
+
+            // Get demographics if available
+            try {
+                const demographicsResponse = await this.axiosInstance.get('/organizationalEntityFollowerStatistics', {
+                    params: {
+                        q: 'organizationalEntity',
+                        organizationalEntity: organizationUrn,
+                        projection: '(followerCountsByAssociationType,followerCountsByFunction,followerCountsBySeniority,followerCountsByIndustry,followerCountsByRegion,followerCountsByCountry)'
+                    }
+                });
+
+                if (demographicsResponse.data.elements?.[0]) {
+                    const demographics = demographicsResponse.data.elements[0];
+                    result.demographics = {
+                        byFunction: demographics.followerCountsByFunction || [],
+                        bySeniority: demographics.followerCountsBySeniority || [],
+                        byIndustry: demographics.followerCountsByIndustry || [],
+                        byRegion: demographics.followerCountsByRegion || [],
+                        byCountry: demographics.followerCountsByCountry || []
+                    };
+                }
+            } catch (error) {
+                LogError(`Failed to get follower demographics: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            }
+
+            return result;
+        } catch (error) {
+            LogError(`Failed to get organization followers: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            throw error;
+        }
+    }
+
+    /**
+     * Get personal profile follower statistics
+     * Note: LinkedIn provides limited follower data for personal profiles
+     */
+    private async getPersonalFollowers(userUrn: string): Promise<any> {
+        try {
+            // Get basic profile information including follower count
+            const response = await this.axiosInstance.get('/me', {
+                params: {
+                    projection: '(id,firstName,lastName,headline,publicProfileUrl,followerCount)'
+                }
+            });
+
+            return {
+                followerCount: response.data.followerCount || 0,
+                profileInfo: {
+                    name: `${response.data.firstName?.localized?.en_US || ''} ${response.data.lastName?.localized?.en_US || ''}`.trim(),
+                    headline: response.data.headline?.localized?.en_US || '',
+                    profileUrl: response.data.publicProfileUrl || ''
+                },
+                note: 'LinkedIn API provides limited follower statistics for personal profiles'
+            };
+        } catch (error) {
+            LogError(`Failed to get personal followers: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            
+            // Fallback: return basic info
+            return {
+                followerCount: 0,
+                note: 'Unable to retrieve follower count for personal profile',
+                error: error instanceof Error ? error.message : 'Unknown error'
+            };
+        }
+    }
+
+    /**
+     * Define the parameters this action expects
+     */
+    public get Params(): ActionParam[] {
+        return [
+            ...this.commonSocialParams,
+            {
+                Name: 'EntityType',
+                Type: 'Input',
+                Value: 'organization' // 'personal' or 'organization'
+            },
+            {
+                Name: 'OrganizationID',
+                Type: 'Input',
+                Value: null
+            },
+            {
+                Name: 'IncludeGrowth',
+                Type: 'Input',
+                Value: false
+            },
+            {
+                Name: 'TimeRange',
+                Type: 'Input',
+                Value: null // Optional: {start: Date, end: Date}
+            },
+            {
+                Name: 'FollowerCount',
+                Type: 'Output',
+                Value: null
+            },
+            {
+                Name: 'FollowerStatistics',
+                Type: 'Output',
+                Value: null
+            }
+        ];
+    }
+
+    /**
+     * Get action description
+     */
+    public get Description(): string {
+        return 'Retrieves follower statistics for LinkedIn personal profiles or organization pages, including demographics and growth metrics where available';
+    }
+}

package/src/providers/linkedin/actions/get-organization-posts.action.ts

@@ -0,0 +1,164 @@
+import { RegisterClass } from '@memberjunction/global';
+import { LinkedInBaseAction } from '../linkedin-base.action';
+import { ActionParam, ActionResultSimple, RunActionParams } from '@memberjunction/actions-base';
+import { LogStatus, LogError } from '@memberjunction/core';
+import { SocialPost } from '../../../base/base-social.action';
+
+/**
+ * Action to get posts from a LinkedIn organization page
+ */
+@RegisterClass(LinkedInBaseAction, 'LinkedInGetOrganizationPostsAction')
+export class LinkedInGetOrganizationPostsAction extends LinkedInBaseAction {
+    /**
+     * Get posts from a LinkedIn organization page
+     */
+    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 organizationId = this.getParamValue(Params, 'OrganizationID');
+            const count = this.getParamValue(Params, 'Count') || 50;
+            const startIndex = this.getParamValue(Params, 'StartIndex') || 0;
+            const includeAnalytics = this.getParamValue(Params, 'IncludeAnalytics') === true;
+
+            // Determine organization URN
+            let organizationUrn: string;
+            if (!organizationId) {
+                // Get first admin organization if not specified
+                const orgs = await this.getAdminOrganizations();
+                if (orgs.length === 0) {
+                    throw new Error('No organizations found. Please specify OrganizationID.');
+                }
+                organizationUrn = orgs[0].urn;
+                LogStatus(`Using organization: ${orgs[0].name}`);
+            } else {
+                organizationUrn = `urn:li:organization:${organizationId}`;
+            }
+
+            // Get posts
+            LogStatus(`Fetching posts for organization...`);
+            const shares = await this.getShares(organizationUrn, count, startIndex);
+
+            // Convert to common format
+            const posts: SocialPost[] = [];
+            for (const share of shares) {
+                const post = this.normalizePost(share);
+                
+                // Optionally fetch analytics
+                if (includeAnalytics) {
+                    try {
+                        const analytics = await this.getPostAnalytics(share.id, organizationUrn);
+                        post.analytics = this.normalizeAnalytics(analytics);
+                    } catch (error) {
+                        LogError(`Failed to get analytics for post ${share.id}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+                    }
+                }
+                
+                posts.push(post);
+            }
+
+            LogStatus(`Retrieved ${posts.length} posts`);
+
+            // Update output parameters
+            const outputParams = [...Params];
+            const postsParam = outputParams.find(p => p.Name === 'Posts');
+            if (postsParam) postsParam.Value = posts;
+            const totalCountParam = outputParams.find(p => p.Name === 'TotalCount');
+            if (totalCountParam) totalCountParam.Value = posts.length;
+
+            return {
+                Success: true,
+                ResultCode: 'SUCCESS',
+                Message: `Successfully retrieved ${posts.length} organization posts`,
+                Params: outputParams
+            };
+
+        } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            
+            return {
+                Success: false,
+                ResultCode: 'ERROR',
+                Message: `Failed to get organization posts: ${errorMessage}`,
+                Params
+            };
+        }
+    }
+
+    /**
+     * Get analytics for a specific post
+     */
+    private async getPostAnalytics(shareId: string, organizationUrn: string): Promise<any> {
+        try {
+            const response = await this.axiosInstance.get('/organizationalEntityShareStatistics', {
+                params: {
+                    q: 'organizationalEntity',
+                    organizationalEntity: organizationUrn,
+                    shares: `List(${shareId})`
+                }
+            });
+
+            if (response.data.elements && response.data.elements.length > 0) {
+                return response.data.elements[0];
+            }
+
+            return null;
+        } catch (error) {
+            LogError(`Failed to get post analytics: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            return null;
+        }
+    }
+
+    /**
+     * Define the parameters this action expects
+     */
+    public get Params(): ActionParam[] {
+        return [
+            ...this.commonSocialParams,
+            {
+                Name: 'OrganizationID',
+                Type: 'Input',
+                Value: null
+            },
+            {
+                Name: 'Count',
+                Type: 'Input',
+                Value: 50
+            },
+            {
+                Name: 'StartIndex',
+                Type: 'Input',
+                Value: 0
+            },
+            {
+                Name: 'IncludeAnalytics',
+                Type: 'Input',
+                Value: false
+            },
+            {
+                Name: 'Posts',
+                Type: 'Output',
+                Value: null
+            },
+            {
+                Name: 'TotalCount',
+                Type: 'Output',
+                Value: null
+            }
+        ];
+    }
+
+    /**
+     * Get action description
+     */
+    public get Description(): string {
+        return 'Retrieves posts from a LinkedIn organization page with optional analytics data';
+    }
+}

package/src/providers/linkedin/actions/get-personal-posts.action.ts

@@ -0,0 +1,158 @@
+import { RegisterClass } from '@memberjunction/global';
+import { LinkedInBaseAction } from '../linkedin-base.action';
+import { ActionParam, ActionResultSimple, RunActionParams } from '@memberjunction/actions-base';
+import { LogStatus, LogError } from '@memberjunction/core';
+import { SocialPost } from '../../../base/base-social.action';
+
+/**
+ * Action to get posts from a LinkedIn personal profile
+ */
+@RegisterClass(LinkedInBaseAction, 'LinkedInGetPersonalPostsAction')
+export class LinkedInGetPersonalPostsAction extends LinkedInBaseAction {
+    /**
+     * Get posts from the authenticated user's LinkedIn profile
+     */
+    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 count = this.getParamValue(Params, 'Count') || 50;
+            const startIndex = this.getParamValue(Params, 'StartIndex') || 0;
+            const includeAnalytics = this.getParamValue(Params, 'IncludeAnalytics') === true;
+
+            // Get current user URN
+            const userUrn = await this.getCurrentUserUrn();
+            LogStatus(`Fetching posts for user: ${userUrn}`);
+
+            // Get posts
+            const shares = await this.getShares(userUrn, count, startIndex);
+
+            // Convert to common format
+            const posts: SocialPost[] = [];
+            for (const share of shares) {
+                const post = this.normalizePost(share);
+                
+                // Personal posts have limited analytics access
+                if (includeAnalytics) {
+                    try {
+                        // Note: Personal share analytics are limited compared to organization analytics
+                        const analytics = await this.getPersonalPostAnalytics(share.id);
+                        if (analytics) {
+                            post.analytics = this.normalizeAnalytics(analytics);
+                        }
+                    } catch (error) {
+                        LogError(`Failed to get analytics for post ${share.id}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+                    }
+                }
+                
+                posts.push(post);
+            }
+
+            LogStatus(`Retrieved ${posts.length} personal posts`);
+
+            // Update output parameters
+            const outputParams = [...Params];
+            const postsParam = outputParams.find(p => p.Name === 'Posts');
+            if (postsParam) postsParam.Value = posts;
+            const totalCountParam = outputParams.find(p => p.Name === 'TotalCount');
+            if (totalCountParam) totalCountParam.Value = posts.length;
+
+            return {
+                Success: true,
+                ResultCode: 'SUCCESS',
+                Message: `Successfully retrieved ${posts.length} personal posts`,
+                Params: outputParams
+            };
+
+        } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            
+            return {
+                Success: false,
+                ResultCode: 'ERROR',
+                Message: `Failed to get personal posts: ${errorMessage}`,
+                Params
+            };
+        }
+    }
+
+    /**
+     * Get analytics for a personal post
+     * Note: LinkedIn provides limited analytics for personal posts
+     */
+    private async getPersonalPostAnalytics(shareId: string): Promise<any> {
+        try {
+            // LinkedIn v2 API has limited personal analytics
+            // We can get basic engagement data from the share itself
+            const response = await this.axiosInstance.get(`/ugcPosts/${shareId}`);
+            
+            if (response.data) {
+                // Extract available metrics from the post data
+                return {
+                    totalShareStatistics: {
+                        impressionCount: 0, // Not available for personal posts
+                        clickCount: 0, // Not available for personal posts
+                        engagement: 0, // Not available for personal posts
+                        likeCount: response.data.likesSummary?.totalLikes || 0,
+                        commentCount: response.data.commentsSummary?.totalComments || 0,
+                        shareCount: 0, // Not available in this endpoint
+                        uniqueImpressionsCount: 0 // Not available for personal posts
+                    }
+                };
+            }
+
+            return null;
+        } catch (error) {
+            LogError(`Failed to get personal post analytics: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            return null;
+        }
+    }
+
+    /**
+     * Define the parameters this action expects
+     */
+    public get Params(): ActionParam[] {
+        return [
+            ...this.commonSocialParams,
+            {
+                Name: 'Count',
+                Type: 'Input',
+                Value: 50
+            },
+            {
+                Name: 'StartIndex',
+                Type: 'Input',
+                Value: 0
+            },
+            {
+                Name: 'IncludeAnalytics',
+                Type: 'Input',
+                Value: false
+            },
+            {
+                Name: 'Posts',
+                Type: 'Output',
+                Value: null
+            },
+            {
+                Name: 'TotalCount',
+                Type: 'Output',
+                Value: null
+            }
+        ];
+    }
+
+    /**
+     * Get action description
+     */
+    public get Description(): string {
+        return 'Retrieves posts from the authenticated user\'s LinkedIn personal profile with limited analytics data';
+    }
+}