@memberjunction/actions-bizapps-social 2.61.0

package/src/providers/linkedin/actions/get-post-analytics.action.ts

@@ -0,0 +1,205 @@
+import { RegisterClass } from '@memberjunction/global';
+import { LinkedInBaseAction, LinkedInAnalytics } from '../linkedin-base.action';
+import { ActionParam, ActionResultSimple, RunActionParams } from '@memberjunction/actions-base';
+import { LogStatus, LogError } from '@memberjunction/core';
+import { SocialAnalytics } from '../../../base/base-social.action';
+
+/**
+ * Action to get analytics for a LinkedIn post
+ */
+@RegisterClass(LinkedInBaseAction, 'LinkedInGetPostAnalyticsAction')
+export class LinkedInGetPostAnalyticsAction extends LinkedInBaseAction {
+    /**
+     * Get analytics for a specific LinkedIn post
+     */
+    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 postId = this.getParamValue(Params, 'PostID');
+            const authorType = this.getParamValue(Params, 'AuthorType') || 'organization'; // 'personal' or 'organization'
+            const organizationId = this.getParamValue(Params, 'OrganizationID');
+            const timeRange = this.getParamValue(Params, 'TimeRange'); // Optional: {start: Date, end: Date}
+
+            // Validate required parameters
+            if (!postId) {
+                throw new Error('PostID is required');
+            }
+
+            let analytics: LinkedInAnalytics | null = null;
+
+            if (authorType === 'organization') {
+                // Get organization analytics
+                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}`;
+                }
+
+                analytics = await this.getOrganizationPostAnalytics(postId, organizationUrn, timeRange);
+            } else {
+                // Get personal post analytics (limited)
+                analytics = await this.getPersonalPostAnalytics(postId);
+            }
+
+            if (!analytics) {
+                throw new Error('No analytics data available for this post');
+            }
+
+            // Normalize analytics
+            const normalizedAnalytics = this.normalizeAnalytics(analytics);
+
+            // Update output parameters
+            const outputParams = [...Params];
+            const analyticsParam = outputParams.find(p => p.Name === 'Analytics');
+            if (analyticsParam) analyticsParam.Value = normalizedAnalytics;
+            const rawAnalyticsParam = outputParams.find(p => p.Name === 'RawAnalytics');
+            if (rawAnalyticsParam) rawAnalyticsParam.Value = analytics;
+
+            return {
+                Success: true,
+                ResultCode: 'SUCCESS',
+                Message: `Successfully retrieved analytics for post ${postId}`,
+                Params: outputParams
+            };
+
+        } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            
+            return {
+                Success: false,
+                ResultCode: 'ERROR',
+                Message: `Failed to get post analytics: ${errorMessage}`,
+                Params
+            };
+        }
+    }
+
+    /**
+     * Get analytics for an organization post
+     */
+    private async getOrganizationPostAnalytics(shareId: string, organizationUrn: string, timeRange?: any): Promise<LinkedInAnalytics> {
+        try {
+            const params: any = {
+                q: 'organizationalEntity',
+                organizationalEntity: organizationUrn,
+                shares: `List(${shareId})`
+            };
+
+            // Add time range if specified
+            if (timeRange) {
+                if (timeRange.start) {
+                    params.timeIntervals = `List((start:${new Date(timeRange.start).getTime()},end:${new Date(timeRange.end || Date.now()).getTime()}))`;
+                }
+            }
+
+            const response = await this.axiosInstance.get('/organizationalEntityShareStatistics', { params });
+
+            if (response.data.elements && response.data.elements.length > 0) {
+                const stats = response.data.elements[0];
+                return {
+                    totalShareStatistics: stats.totalShareStatistics || {},
+                    timeRange: timeRange ? {
+                        start: new Date(timeRange.start).getTime(),
+                        end: new Date(timeRange.end || Date.now()).getTime()
+                    } : undefined
+                };
+            }
+
+            throw new Error('No analytics data found');
+        } catch (error) {
+            LogError(`Failed to get organization post analytics: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            throw error;
+        }
+    }
+
+    /**
+     * Get analytics for a personal post (limited data available)
+     */
+    private async getPersonalPostAnalytics(shareId: string): Promise<LinkedInAnalytics> {
+        try {
+            // For personal posts, we need to fetch the post itself to get basic engagement metrics
+            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: response.data.likesSummary?.totalLikes || 0 + response.data.commentsSummary?.totalComments || 0,
+                        likeCount: response.data.likesSummary?.totalLikes || 0,
+                        commentCount: response.data.commentsSummary?.totalComments || 0,
+                        shareCount: 0, // Not directly available
+                        uniqueImpressionsCount: 0 // Not available for personal posts
+                    }
+                };
+            }
+
+            throw new Error('Post not found');
+        } catch (error) {
+            LogError(`Failed to get personal post analytics: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            throw error;
+        }
+    }
+
+    /**
+     * Define the parameters this action expects
+     */
+    public get Params(): ActionParam[] {
+        return [
+            ...this.commonSocialParams,
+            {
+                Name: 'PostID',
+                Type: 'Input',
+                Value: null
+            },
+            {
+                Name: 'AuthorType',
+                Type: 'Input',
+                Value: 'organization' // 'personal' or 'organization'
+            },
+            {
+                Name: 'OrganizationID',
+                Type: 'Input',
+                Value: null
+            },
+            {
+                Name: 'TimeRange',
+                Type: 'Input',
+                Value: null // Optional: {start: Date, end: Date}
+            },
+            {
+                Name: 'Analytics',
+                Type: 'Output',
+                Value: null
+            },
+            {
+                Name: 'RawAnalytics',
+                Type: 'Output',
+                Value: null
+            }
+        ];
+    }
+
+    /**
+     * Get action description
+     */
+    public get Description(): string {
+        return 'Retrieves detailed analytics for a LinkedIn post (organization posts have more detailed analytics than personal posts)';
+    }
+}

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

@@ -0,0 +1,8 @@
+export * from './create-post.action';
+export * from './get-organization-posts.action';
+export * from './get-personal-posts.action';
+export * from './get-post-analytics.action';
+export * from './schedule-post.action';
+export * from './get-followers.action';
+export * from './create-article.action';
+export * from './search-posts.action';

package/src/providers/linkedin/actions/schedule-post.action.ts

@@ -0,0 +1,206 @@
+import { RegisterClass } from '@memberjunction/global';
+import { LinkedInBaseAction, LinkedInShareData } from '../linkedin-base.action';
+import { ActionParam, ActionResultSimple, RunActionParams } from '@memberjunction/actions-base';
+import { LogStatus, LogError } from '@memberjunction/core';
+import { MediaFile } from '../../../base/base-social.action';
+
+/**
+ * Action to schedule a post on LinkedIn
+ * Note: LinkedIn API v2 does not have native scheduling support.
+ * This action stores the post data for later publishing via a separate scheduler service.
+ */
+@RegisterClass(LinkedInBaseAction, 'LinkedInSchedulePostAction')
+export class LinkedInSchedulePostAction extends LinkedInBaseAction {
+    /**
+     * Schedule a post for future publishing on LinkedIn
+     */
+    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 scheduledTime = this.getParamValue(Params, 'ScheduledTime');
+            const authorType = this.getParamValue(Params, 'AuthorType') || 'personal'; // 'personal' or 'organization'
+            const organizationId = this.getParamValue(Params, 'OrganizationID');
+            const mediaFiles = this.getParamValue(Params, 'MediaFiles');
+            const visibility = this.getParamValue(Params, 'Visibility') || 'PUBLIC';
+            const visibleToGuest = this.getParamValue(Params, 'VisibleToGuest') !== false; // Default true
+
+            // Validate required parameters
+            if (!content) {
+                throw new Error('Content is required');
+            }
+            if (!scheduledTime) {
+                throw new Error('ScheduledTime is required');
+            }
+
+            // Validate scheduled time is in the future
+            const scheduledDate = new Date(scheduledTime);
+            if (scheduledDate <= new Date()) {
+                throw new Error('ScheduledTime must be in the future');
+            }
+
+            // Determine author URN
+            let authorUrn: string;
+            if (authorType === 'organization') {
+                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.');
+                    }
+                    authorUrn = orgs[0].urn;
+                    LogStatus(`Using organization: ${orgs[0].name}`);
+                } else {
+                    authorUrn = `urn:li:organization:${organizationId}`;
+                }
+            } else {
+                // Personal post
+                authorUrn = await this.getCurrentUserUrn();
+            }
+
+            // Upload media if provided (to ensure they're valid and get URNs)
+            let mediaUrns: string[] = [];
+            if (mediaFiles && Array.isArray(mediaFiles)) {
+                LogStatus(`Uploading ${mediaFiles.length} media files...`);
+                mediaUrns = await this.uploadMedia(mediaFiles as MediaFile[]);
+            }
+
+            // Build share data for future publishing
+            const shareData: LinkedInShareData = {
+                author: authorUrn,
+                lifecycleState: 'PUBLISHED',
+                specificContent: {
+                    'com.linkedin.ugc.ShareContent': {
+                        shareCommentary: {
+                            text: content
+                        },
+                        shareMediaCategory: mediaUrns.length > 0 ? 'IMAGE' : 'NONE',
+                        media: mediaUrns.length > 0 ? mediaUrns.map(urn => ({
+                            status: 'READY' as const,
+                            media: urn
+                        })) : undefined
+                    }
+                },
+                visibility: {
+                    'com.linkedin.ugc.MemberNetworkVisibility': visibility as any
+                }
+            };
+
+            // Add distribution settings if public
+            if (visibility === 'PUBLIC') {
+                shareData.distribution = {
+                    linkedInDistributionTarget: {
+                        visibleToGuest: visibleToGuest
+                    }
+                };
+            }
+
+            // Create a scheduled post record
+            // Note: This would typically be stored in a database or queue for processing
+            const scheduledPost = {
+                id: `scheduled_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+                platform: 'LinkedIn',
+                companyIntegrationId: companyIntegrationId,
+                scheduledTime: scheduledDate.toISOString(),
+                shareData: shareData,
+                status: 'SCHEDULED',
+                createdAt: new Date().toISOString()
+            };
+
+            LogStatus(`Post scheduled for ${scheduledDate.toISOString()}`);
+
+            // Update output parameters
+            const outputParams = [...Params];
+            const scheduledPostParam = outputParams.find(p => p.Name === 'ScheduledPost');
+            if (scheduledPostParam) scheduledPostParam.Value = scheduledPost;
+            const scheduledIdParam = outputParams.find(p => p.Name === 'ScheduledID');
+            if (scheduledIdParam) scheduledIdParam.Value = scheduledPost.id;
+
+            return {
+                Success: true,
+                ResultCode: 'SUCCESS',
+                Message: `Successfully scheduled LinkedIn post for ${scheduledDate.toISOString()}`,
+                Params: outputParams
+            };
+
+        } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            
+            return {
+                Success: false,
+                ResultCode: 'ERROR',
+                Message: `Failed to schedule LinkedIn post: ${errorMessage}`,
+                Params
+            };
+        }
+    }
+
+    /**
+     * Define the parameters this action expects
+     */
+    public get Params(): ActionParam[] {
+        return [
+            ...this.commonSocialParams,
+            {
+                Name: 'Content',
+                Type: 'Input',
+                Value: null
+            },
+            {
+                Name: 'ScheduledTime',
+                Type: 'Input',
+                Value: null
+            },
+            {
+                Name: 'AuthorType',
+                Type: 'Input',
+                Value: 'personal' // 'personal' or 'organization'
+            },
+            {
+                Name: 'OrganizationID',
+                Type: 'Input',
+                Value: null
+            },
+            {
+                Name: 'MediaFiles',
+                Type: 'Input',
+                Value: null
+            },
+            {
+                Name: 'Visibility',
+                Type: 'Input',
+                Value: 'PUBLIC' // 'PUBLIC', 'CONNECTIONS', 'LOGGED_IN', 'CONTAINER'
+            },
+            {
+                Name: 'VisibleToGuest',
+                Type: 'Input',
+                Value: true
+            },
+            {
+                Name: 'ScheduledPost',
+                Type: 'Output',
+                Value: null
+            },
+            {
+                Name: 'ScheduledID',
+                Type: 'Output',
+                Value: null
+            }
+        ];
+    }
+
+    /**
+     * Get action description
+     */
+    public get Description(): string {
+        return 'Schedules a post for future publishing on LinkedIn. Note: LinkedIn API does not support native scheduling, so this stores the post for later publishing via a scheduler service.';
+    }
+}