@memberjunction/actions-bizapps-social 2.61.0

package/src/providers/facebook/index.ts

@@ -0,0 +1,2 @@
+export * from './facebook-base.action';
+export * from './actions';

package/src/providers/hootsuite/actions/bulk-schedule-posts.action.ts

@@ -0,0 +1,293 @@
+import { RegisterClass } from '@memberjunction/global';
+import { HootSuiteBaseAction, HootSuitePost } from '../hootsuite-base.action';
+import { ActionParam, ActionResultSimple, RunActionParams } from '@memberjunction/actions-base';
+import { LogStatus, LogError } from '@memberjunction/core';
+import { MediaFile } from '../../../base/base-social.action';
+
+/**
+ * Interface for bulk post data
+ */
+interface BulkPostData {
+    content: string;
+    scheduledTime?: string;
+    profileIds?: string[];
+    mediaFiles?: MediaFile[];
+    tags?: string[];
+    location?: { latitude: number; longitude: number; };
+}
+
+/**
+ * Action to bulk schedule multiple posts in HootSuite
+ */
+@RegisterClass(HootSuiteBaseAction, 'HootSuiteBulkSchedulePostsAction')
+export class HootSuiteBulkSchedulePostsAction extends HootSuiteBaseAction {
+    /**
+     * Bulk schedule posts in HootSuite
+     */
+    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 posts = this.getParamValue(Params, 'Posts') as BulkPostData[];
+            const defaultProfileIds = this.getParamValue(Params, 'DefaultProfileIDs');
+            const scheduleInterval = this.getParamValue(Params, 'ScheduleInterval');
+            const startTime = this.getParamValue(Params, 'StartTime');
+            const skipOnError = this.getParamValue(Params, 'SkipOnError') || true;
+            const validateOnly = this.getParamValue(Params, 'ValidateOnly') || false;
+
+            // Validate required parameters
+            if (!posts || !Array.isArray(posts) || posts.length === 0) {
+                throw new Error('Posts array is required and must not be empty');
+            }
+
+            // Get default profiles if not specified
+            let defaultProfiles: string[] = [];
+            if (defaultProfileIds && Array.isArray(defaultProfileIds)) {
+                defaultProfiles = defaultProfileIds;
+            } else if (defaultProfileIds && typeof defaultProfileIds === 'string') {
+                defaultProfiles = [defaultProfileIds];
+            } else {
+                // Get all available profiles as default
+                const profiles = await this.getSocialProfiles();
+                if (profiles.length === 0) {
+                    throw new Error('No social profiles found. Please specify DefaultProfileIDs.');
+                }
+                defaultProfiles = profiles.map(p => p.id);
+                LogStatus(`Using ${defaultProfiles.length} default profiles`);
+            }
+
+            // Calculate schedule times if interval is specified
+            let baseScheduleTime: Date | null = null;
+            if (scheduleInterval && startTime) {
+                baseScheduleTime = new Date(startTime);
+            }
+
+            // Process posts
+            const results: any[] = [];
+            const errors: any[] = [];
+            let successCount = 0;
+            let failureCount = 0;
+
+            LogStatus(`Processing ${posts.length} posts for bulk scheduling...`);
+
+            for (let i = 0; i < posts.length; i++) {
+                const post = posts[i];
+                const postIndex = i + 1;
+
+                try {
+                    // Validate post data
+                    this.validateBulkPost(post, postIndex);
+
+                    // Calculate scheduled time for this post
+                    let scheduledTime = post.scheduledTime;
+                    if (!scheduledTime && baseScheduleTime && scheduleInterval) {
+                        const offsetMinutes = i * scheduleInterval;
+                        const postScheduleTime = new Date(baseScheduleTime);
+                        postScheduleTime.setMinutes(postScheduleTime.getMinutes() + offsetMinutes);
+                        scheduledTime = postScheduleTime.toISOString();
+                    }
+
+                    // Prepare profile IDs
+                    const profileIds = post.profileIds || defaultProfiles;
+
+                    // If validate only, just check the data
+                    if (validateOnly) {
+                        results.push({
+                            index: postIndex,
+                            status: 'VALIDATED',
+                            content: post.content.substring(0, 50) + '...',
+                            scheduledTime: scheduledTime,
+                            profileCount: profileIds.length
+                        });
+                        successCount++;
+                        continue;
+                    }
+
+                    // Upload media if provided
+                    let mediaIds: string[] = [];
+                    if (post.mediaFiles && Array.isArray(post.mediaFiles)) {
+                        LogStatus(`Uploading ${post.mediaFiles.length} media files for post ${postIndex}...`);
+                        mediaIds = await this.uploadMedia(post.mediaFiles);
+                    }
+
+                    // Create the post
+                    const postData: any = {
+                        text: post.content,
+                        socialProfileIds: profileIds,
+                        scheduledTime: scheduledTime ? this.formatHootSuiteDate(scheduledTime) : undefined,
+                        mediaIds: mediaIds.length > 0 ? mediaIds : undefined,
+                        tags: post.tags,
+                        location: post.location
+                    };
+
+                    const response = await this.axiosInstance.post('/messages', postData);
+                    const createdPost = response.data;
+
+                    results.push({
+                        index: postIndex,
+                        status: 'SUCCESS',
+                        postId: createdPost.id,
+                        content: post.content.substring(0, 50) + '...',
+                        scheduledTime: createdPost.scheduledTime,
+                        profileCount: profileIds.length
+                    });
+                    successCount++;
+
+                } catch (error) {
+                    const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                    
+                    errors.push({
+                        index: postIndex,
+                        content: post.content.substring(0, 50) + '...',
+                        error: errorMessage
+                    });
+                    failureCount++;
+
+                    if (!skipOnError) {
+                        throw new Error(`Failed at post ${postIndex}: ${errorMessage}`);
+                    }
+                }
+
+                // Log progress every 10 posts
+                if (i > 0 && (i + 1) % 10 === 0) {
+                    LogStatus(`Processed ${i + 1}/${posts.length} posts...`);
+                }
+            }
+
+            // Create summary
+            const summary = {
+                totalPosts: posts.length,
+                successCount: successCount,
+                failureCount: failureCount,
+                validationOnly: validateOnly,
+                processingTime: new Date().toISOString(),
+                scheduleRange: baseScheduleTime ? {
+                    start: baseScheduleTime.toISOString(),
+                    end: new Date(baseScheduleTime.getTime() + (posts.length - 1) * (scheduleInterval || 0) * 60000).toISOString()
+                } : null
+            };
+
+            // Update output parameters
+            const outputParams = [...Params];
+            const resultsParam = outputParams.find(p => p.Name === 'Results');
+            if (resultsParam) resultsParam.Value = results;
+            const errorsParam = outputParams.find(p => p.Name === 'Errors');
+            if (errorsParam) errorsParam.Value = errors;
+            const summaryParam = outputParams.find(p => p.Name === 'Summary');
+            if (summaryParam) summaryParam.Value = summary;
+
+            const resultCode = failureCount === 0 ? 'SUCCESS' : (successCount > 0 ? 'PARTIAL_SUCCESS' : 'FAILED');
+            const message = validateOnly 
+                ? `Validated ${successCount} posts, ${failureCount} failed validation`
+                : `Successfully scheduled ${successCount} posts, ${failureCount} failed`;
+
+            return {
+                Success: failureCount === 0 || (skipOnError && successCount > 0),
+                ResultCode: resultCode,
+                Message: message,
+                Params: outputParams
+            };
+
+        } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            
+            return {
+                Success: false,
+                ResultCode: 'ERROR',
+                Message: `Failed to bulk schedule posts: ${errorMessage}`,
+                Params
+            };
+        }
+    }
+
+    /**
+     * Validate bulk post data
+     */
+    private validateBulkPost(post: BulkPostData, index: number): void {
+        if (!post.content || typeof post.content !== 'string' || post.content.trim().length === 0) {
+            throw new Error(`Post ${index}: Content is required and must not be empty`);
+        }
+
+        if (post.content.length > 10000) {
+            throw new Error(`Post ${index}: Content exceeds maximum length of 10000 characters`);
+        }
+
+        if (post.scheduledTime && isNaN(Date.parse(post.scheduledTime))) {
+            throw new Error(`Post ${index}: Invalid scheduled time format`);
+        }
+
+        if (post.location) {
+            if (typeof post.location.latitude !== 'number' || typeof post.location.longitude !== 'number') {
+                throw new Error(`Post ${index}: Location must have numeric latitude and longitude`);
+            }
+        }
+    }
+
+    /**
+     * Define the parameters this action expects
+     */
+    public get Params(): ActionParam[] {
+        return [
+            ...this.oauthParams,
+            {
+                Name: 'Posts',
+                Type: 'Input',
+                Value: null
+            },
+            {
+                Name: 'DefaultProfileIDs',
+                Type: 'Input',
+                Value: null
+            },
+            {
+                Name: 'ScheduleInterval',
+                Type: 'Input',
+                Value: null
+            },
+            {
+                Name: 'StartTime',
+                Type: 'Input',
+                Value: null
+            },
+            {
+                Name: 'SkipOnError',
+                Type: 'Input',
+                Value: null
+            },
+            {
+                Name: 'ValidateOnly',
+                Type: 'Input',
+                Value: null
+            },
+            {
+                Name: 'Results',
+                Type: 'Output',
+                Value: null
+            },
+            {
+                Name: 'Errors',
+                Type: 'Output',
+                Value: null
+            },
+            {
+                Name: 'Summary',
+                Type: 'Output',
+                Value: null
+            }
+        ];
+    }
+
+    /**
+     * Get action description
+     */
+    public get Description(): string {
+        return 'Bulk schedules multiple posts to HootSuite with support for auto-scheduling intervals and validation';
+    }
+}

package/src/providers/hootsuite/actions/create-scheduled-post.action.ts

@@ -0,0 +1,206 @@
+import { RegisterClass } from '@memberjunction/global';
+import { HootSuiteBaseAction } from '../hootsuite-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 create a scheduled post in HootSuite
+ */
+@RegisterClass(HootSuiteBaseAction, 'HootSuiteCreateScheduledPostAction')
+export class HootSuiteCreateScheduledPostAction extends HootSuiteBaseAction {
+    /**
+     * Create a scheduled post in HootSuite
+     */
+    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 profileIds = this.getParamValue(Params, 'ProfileIDs');
+            const scheduledTime = this.getParamValue(Params, 'ScheduledTime');
+            const mediaFiles = this.getParamValue(Params, 'MediaFiles');
+            const tags = this.getParamValue(Params, 'Tags');
+            const location = this.getParamValue(Params, 'Location');
+            const targetingOptions = this.getParamValue(Params, 'TargetingOptions');
+
+            // Validate required parameters
+            if (!content) {
+                throw new Error('Content is required');
+            }
+
+            // Get profile IDs - either from parameter or default profiles
+            let socialProfileIds: string[] = [];
+            if (profileIds && Array.isArray(profileIds)) {
+                socialProfileIds = profileIds;
+            } else if (profileIds && typeof profileIds === 'string') {
+                socialProfileIds = [profileIds];
+            } else {
+                // Get default profiles if none specified
+                const profiles = await this.getSocialProfiles();
+                if (profiles.length === 0) {
+                    throw new Error('No social profiles found. Please specify ProfileIDs.');
+                }
+                socialProfileIds = profiles.map(p => p.id);
+                LogStatus(`Using ${socialProfileIds.length} default profiles`);
+            }
+
+            // Upload media if provided
+            let mediaIds: string[] = [];
+            if (mediaFiles && Array.isArray(mediaFiles)) {
+                LogStatus(`Uploading ${mediaFiles.length} media files...`);
+                mediaIds = await this.uploadMedia(mediaFiles as MediaFile[]);
+            }
+
+            // Build post data
+            const postData: any = {
+                text: content,
+                socialProfileIds: socialProfileIds,
+                scheduledTime: scheduledTime ? this.formatHootSuiteDate(scheduledTime) : undefined,
+                mediaIds: mediaIds.length > 0 ? mediaIds : undefined,
+                tags: tags && Array.isArray(tags) ? tags : undefined,
+                location: location ? {
+                    latitude: location.latitude,
+                    longitude: location.longitude
+                } : undefined
+            };
+
+            // Add targeting options if provided
+            if (targetingOptions) {
+                postData.targeting = targetingOptions;
+            }
+
+            // Create the post
+            LogStatus('Creating scheduled post...');
+            const response = await this.axiosInstance.post('/messages', postData);
+            const createdPost = response.data;
+
+            // Normalize the created post
+            const normalizedPost = this.normalizePost(createdPost);
+
+            // Update output parameters
+            const outputParams = [...Params];
+            const postParam = outputParams.find(p => p.Name === 'CreatedPost');
+            if (postParam) postParam.Value = normalizedPost;
+            const postIdParam = outputParams.find(p => p.Name === 'PostID');
+            if (postIdParam) postIdParam.Value = createdPost.id;
+
+            return {
+                Success: true,
+                ResultCode: 'SUCCESS',
+                Message: `Successfully created scheduled post (ID: ${createdPost.id})`,
+                Params: outputParams
+            };
+
+        } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            
+            return {
+                Success: false,
+                ResultCode: 'ERROR',
+                Message: `Failed to create scheduled post: ${errorMessage}`,
+                Params
+            };
+        }
+    }
+
+    /**
+     * Validate media files before upload
+     */
+    protected validateMediaFile(file: MediaFile): void {
+        // HootSuite-specific media limits
+        const supportedTypes = [
+            'image/jpeg',
+            'image/png',
+            'image/gif',
+            'video/mp4',
+            'video/quicktime'
+        ];
+
+        if (!supportedTypes.includes(file.mimeType)) {
+            throw new Error(`Unsupported media type: ${file.mimeType}. Supported types: ${supportedTypes.join(', ')}`);
+        }
+
+        // Check file sizes
+        const maxSizes: Record<string, number> = {
+            'image/jpeg': 10 * 1024 * 1024,   // 10MB
+            'image/png': 10 * 1024 * 1024,    // 10MB
+            'image/gif': 15 * 1024 * 1024,    // 15MB
+            'video/mp4': 500 * 1024 * 1024,   // 500MB
+            'video/quicktime': 500 * 1024 * 1024 // 500MB
+        };
+
+        const maxSize = maxSizes[file.mimeType];
+        if (file.size > maxSize) {
+            throw new Error(`File size exceeds limit for ${file.mimeType}. Max: ${maxSize / 1024 / 1024}MB, Got: ${file.size / 1024 / 1024}MB`);
+        }
+    }
+
+    /**
+     * Define the parameters this action expects
+     */
+    public get Params(): ActionParam[] {
+        return [
+            ...this.commonSocialParams,
+            {
+                Name: 'Content',
+                Type: 'Input',
+                Value: null
+            },
+            {
+                Name: 'ProfileIDs',
+                Type: 'Input',
+                Value: null
+            },
+            {
+                Name: 'ScheduledTime',
+                Type: 'Input',
+                Value: null
+            },
+            {
+                Name: 'MediaFiles',
+                Type: 'Input',
+                Value: null
+            },
+            {
+                Name: 'Tags',
+                Type: 'Input',
+                Value: null
+            },
+            {
+                Name: 'Location',
+                Type: 'Input',
+                Value: null
+            },
+            {
+                Name: 'TargetingOptions',
+                Type: 'Input',
+                Value: null
+            },
+            {
+                Name: 'CreatedPost',
+                Type: 'Output',
+                Value: null
+            },
+            {
+                Name: 'PostID',
+                Type: 'Output',
+                Value: null
+            }
+        ];
+    }
+
+    /**
+     * Get action description
+     */
+    public get Description(): string {
+        return 'Creates a scheduled post in HootSuite with support for multiple social profiles, media attachments, and scheduling';
+    }
+}

package/src/providers/hootsuite/actions/delete-scheduled-post.action.ts

@@ -0,0 +1,173 @@
+import { RegisterClass } from '@memberjunction/global';
+import { HootSuiteBaseAction } from '../hootsuite-base.action';
+import { ActionParam, ActionResultSimple, RunActionParams } from '@memberjunction/actions-base';
+import { LogStatus, LogError } from '@memberjunction/core';
+/**
+ * Action to delete a scheduled post from HootSuite
+ */
+@RegisterClass(HootSuiteBaseAction, 'HootSuiteDeleteScheduledPostAction')
+export class HootSuiteDeleteScheduledPostAction extends HootSuiteBaseAction {
+    /**
+     * Delete a scheduled post from HootSuite
+     */
+    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 confirmDeletion = this.getParamValue(Params, 'ConfirmDeletion') || false;
+
+            // Validate required parameters
+            if (!postId) {
+                throw new Error('PostID is required');
+            }
+
+            // Safety check - require confirmation
+            if (!confirmDeletion) {
+                return {
+                    Success: false,
+                    ResultCode: 'CONFIRMATION_REQUIRED',
+                    Message: 'Deletion not confirmed. Set ConfirmDeletion to true to proceed.',
+                    Params
+                };
+            }
+
+            // First, get the post details to verify it exists and can be deleted
+            LogStatus(`Fetching post ${postId} details...`);
+            let postDetails: any;
+            
+            try {
+                const response = await this.axiosInstance.get(`/messages/${postId}`);
+                postDetails = response.data;
+            } catch (error: any) {
+                if (error.response?.status === 404) {
+                    return {
+                        Success: false,
+                        ResultCode: 'POST_NOT_FOUND',
+                        Message: `Post with ID ${postId} not found`,
+                        Params
+                    };
+                }
+                throw error;
+            }
+
+            // Check if post can be deleted
+            if (postDetails.state === 'PUBLISHED') {
+                return {
+                    Success: false,
+                    ResultCode: 'CANNOT_DELETE_PUBLISHED',
+                    Message: 'Cannot delete published posts. Only scheduled, draft, or failed posts can be deleted.',
+                    Params
+                };
+            }
+
+            // Store post details before deletion
+            const deletedPostInfo = {
+                id: postDetails.id,
+                content: postDetails.text,
+                state: postDetails.state,
+                scheduledTime: postDetails.scheduledTime,
+                profiles: postDetails.socialProfileIds,
+                mediaCount: postDetails.mediaIds?.length || 0,
+                tags: postDetails.tags || [],
+                deletedAt: new Date().toISOString()
+            };
+
+            // Delete the post
+            LogStatus(`Deleting post ${postId}...`);
+            await this.axiosInstance.delete(`/messages/${postId}`);
+
+            // Verify deletion by trying to fetch the post again
+            let verificationFailed = false;
+            try {
+                await this.axiosInstance.get(`/messages/${postId}`);
+                verificationFailed = true;
+            } catch (error: any) {
+                if (error.response?.status !== 404) {
+                    verificationFailed = true;
+                }
+            }
+
+            if (verificationFailed) {
+                LogStatus('Warning: Post deletion could not be verified');
+            }
+
+            // Update output parameters
+            const outputParams = [...Params];
+            const deletedPostParam = outputParams.find(p => p.Name === 'DeletedPostInfo');
+            if (deletedPostParam) deletedPostParam.Value = deletedPostInfo;
+            const deletionVerifiedParam = outputParams.find(p => p.Name === 'DeletionVerified');
+            if (deletionVerifiedParam) deletionVerifiedParam.Value = !verificationFailed;
+
+            return {
+                Success: true,
+                ResultCode: 'SUCCESS',
+                Message: `Successfully deleted post ${postId}`,
+                Params: outputParams
+            };
+
+        } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            
+            // Handle specific error cases
+            if (error instanceof Error && error.message.includes('404')) {
+                return {
+                    Success: false,
+                    ResultCode: 'POST_NOT_FOUND',
+                    Message: `Post ${this.getParamValue(Params, 'PostID')} not found or already deleted`,
+                    Params
+                };
+            }
+
+            return {
+                Success: false,
+                ResultCode: 'ERROR',
+                Message: `Failed to delete scheduled post: ${errorMessage}`,
+                Params
+            };
+        }
+    }
+
+    /**
+     * Define the parameters this action expects
+     */
+    public get Params(): ActionParam[] {
+        return [
+            ...this.oauthParams,
+            {
+                Name: 'PostID',
+                Type: 'Input',
+                Value: null
+            },
+            {
+                Name: 'ConfirmDeletion',
+                Type: 'Input',
+                Value: null
+            },
+            {
+                Name: 'DeletedPostInfo',
+                Type: 'Output',
+                Value: null
+            },
+            {
+                Name: 'DeletionVerified',
+                Type: 'Output',
+                Value: null
+            }
+        ];
+    }
+
+    /**
+     * Get action description
+     */
+    public get Description(): string {
+        return 'Deletes a scheduled post from HootSuite. Only SCHEDULED, DRAFT, or FAILED posts can be deleted. Published posts cannot be deleted.';
+    }
+}