n8n-nodes-microsoft-teams-bot 1.0.0

package/dist/nodes/TeamsBot/actions/messages.js

@@ -0,0 +1,1259 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.messageOperations = void 0;
+const index_1 = require("../transport/index");
+const messages_1 = require("../errors/messages");
+const n8n_workflow_1 = require("n8n-workflow");
+const utils_1 = require("../utils");
+const fileProcessing_1 = require("../utils/fileProcessing");
+const validation_1 = require("../utils/validation");
+const constants_1 = require("../utils/constants");
+/**
+ * Analyze reaction patterns from reaction data
+ */
+function analyzeReactionPatterns(reactionData) {
+    const reactions = reactionData.reactions || [];
+    const analysis = {
+        totalReactions: reactions.length,
+        reactionBreakdown: {},
+        userEngagement: {},
+        temporalPatterns: {},
+        sentiment: 'neutral',
+    };
+    // Count reaction types
+    reactions.forEach((reaction) => {
+        var _a;
+        const type = reaction.type || 'unknown';
+        analysis.reactionBreakdown[type] = (analysis.reactionBreakdown[type] || 0) + 1;
+        // Track user engagement
+        const userId = ((_a = reaction.user) === null || _a === void 0 ? void 0 : _a.id) || 'unknown';
+        if (!analysis.userEngagement[userId]) {
+            analysis.userEngagement[userId] = {
+                totalReactions: 0,
+                reactionTypes: {},
+                firstReaction: reaction.timestamp,
+                lastReaction: reaction.timestamp,
+            };
+        }
+        analysis.userEngagement[userId].totalReactions++;
+        analysis.userEngagement[userId].reactionTypes[type] =
+            (analysis.userEngagement[userId].reactionTypes[type] || 0) + 1;
+        // Update timestamps
+        if (reaction.timestamp < analysis.userEngagement[userId].firstReaction) {
+            analysis.userEngagement[userId].firstReaction = reaction.timestamp;
+        }
+        if (reaction.timestamp > analysis.userEngagement[userId].lastReaction) {
+            analysis.userEngagement[userId].lastReaction = reaction.timestamp;
+        }
+    });
+    // Determine sentiment based on reaction types
+    const positiveReactions = ['like', 'heart', 'thumbsUp', 'laugh', 'celebrate'];
+    const negativeReactions = ['thumbsDown', 'sad', 'angry'];
+    let positiveCount = 0;
+    let negativeCount = 0;
+    Object.keys(analysis.reactionBreakdown).forEach(type => {
+        if (positiveReactions.includes(type))
+            positiveCount += analysis.reactionBreakdown[type];
+        if (negativeReactions.includes(type))
+            negativeCount += analysis.reactionBreakdown[type];
+    });
+    if (positiveCount > negativeCount)
+        analysis.sentiment = 'positive';
+    else if (negativeCount > positiveCount)
+        analysis.sentiment = 'negative';
+    return analysis;
+}
+/**
+ * Generate comprehensive reaction analytics for a conversation
+ */
+function generateReactionAnalytics(messages, timeRangeHours) {
+    const cutoffTime = new Date(Date.now() - timeRangeHours * 60 * 60 * 1000);
+    const analytics = {
+        timeRange: `${timeRangeHours} hours`,
+        totalMessages: messages.length,
+        messagesWithReactions: 0,
+        totalReactions: 0,
+        reactionTypeDistribution: {},
+        topReactedMessages: [],
+        engagementRate: 0,
+        peakReactionHours: [],
+    };
+    let reactionCount = 0;
+    const hourlyReactions = {};
+    const messageReactionCounts = [];
+    messages.forEach(message => {
+        var _a;
+        const messageReactions = message.reactions || [];
+        const reactionCountForMessage = messageReactions.length;
+        if (reactionCountForMessage > 0) {
+            analytics.messagesWithReactions++;
+            reactionCount += reactionCountForMessage;
+            // Track message with most reactions
+            messageReactionCounts.push({
+                id: message.id,
+                count: reactionCountForMessage,
+                content: ((_a = message.body) === null || _a === void 0 ? void 0 : _a.content) || message.text || '',
+            });
+            // Track reaction types
+            messageReactions.forEach((reaction) => {
+                const type = reaction.reactionType || reaction.type || 'unknown';
+                analytics.reactionTypeDistribution[type] =
+                    (analytics.reactionTypeDistribution[type] || 0) + 1;
+                // Track hourly distribution
+                const reactionTime = new Date(reaction.createdDateTime || message.createdDateTime);
+                if (reactionTime >= cutoffTime) {
+                    const hour = reactionTime.getHours();
+                    hourlyReactions[hour] = (hourlyReactions[hour] || 0) + 1;
+                }
+            });
+        }
+    });
+    analytics.totalReactions = reactionCount;
+    analytics.engagementRate = analytics.totalMessages > 0 ?
+        (analytics.messagesWithReactions / analytics.totalMessages) * 100 : 0;
+    // Find top reacted messages
+    messageReactionCounts
+        .sort((a, b) => b.count - a.count)
+        .slice(0, 5)
+        .forEach(item => {
+        analytics.topReactedMessages.push(item);
+    });
+    // Find peak reaction hours
+    const sortedHours = Object.entries(hourlyReactions)
+        .sort(([, a], [, b]) => b - a)
+        .slice(0, 3);
+    analytics.peakReactionHours = sortedHours.map(([hour, count]) => ({
+        hour: parseInt(hour),
+        reactionCount: count,
+    }));
+    return analytics;
+}
+/**
+ * Validates required parameters for message operations
+ */
+function validateMessageParams(params, requiredFields, executeFunctions, itemIndex) {
+    // Always validate message
+    if (!params.message) {
+        throw messages_1.TeamsMessageError.invalidRecipient(executeFunctions.getNode(), 'Required parameter "message" is missing', { itemIndex });
+    }
+    // Validate recipient type and required fields
+    if (params.recipientType === 'channel') {
+        if (!params.teamId) {
+            throw messages_1.TeamsMessageError.invalidRecipient(executeFunctions.getNode(), 'Required parameter "teamId" is missing for channel messages', { itemIndex });
+        }
+        if (!params.channelId) {
+            throw messages_1.TeamsMessageError.invalidRecipient(executeFunctions.getNode(), 'Required parameter "channelId" is missing for channel messages', { itemIndex });
+        }
+    }
+    else if (params.recipientType === 'chat') {
+        if (!params.userId) {
+            throw messages_1.TeamsMessageError.invalidRecipient(executeFunctions.getNode(), 'Required parameter "userId" is missing for chat messages', { itemIndex });
+        }
+    }
+    else {
+        throw messages_1.TeamsMessageError.invalidRecipient(executeFunctions.getNode(), `Invalid recipient type: ${params.recipientType}`, { itemIndex });
+    }
+}
+/**
+ * Message operations for the Teams Bot node
+ */
+exports.messageOperations = {
+    /**
+     * Sends a message to a channel or chat
+     */
+    async send() {
+        const items = this.getInputData();
+        const returnData = [];
+        const api = new index_1.TeamsApiClient(this);
+        await api.initialize();
+        for (let i = 0; i < items.length; i++) {
+            try {
+                // Get operation parameters
+                const message = this.getNodeParameter('message', i);
+                const recipientType = this.getNodeParameter('recipientType', i);
+                // Get required fields based on recipient type
+                let teamId;
+                let channelId;
+                let userId;
+                if (recipientType === 'channel') {
+                    teamId = this.getNodeParameter('teamId', i);
+                    channelId = this.getNodeParameter('channelId', i);
+                }
+                else if (recipientType === 'chat') {
+                    userId = this.getNodeParameter('userId', i);
+                }
+                // Get message options
+                const options = this.getNodeParameter('options', i, {});
+                // Prepare message options
+                const messageOptions = {};
+                // Add text format if specified
+                if (options.format) {
+                    messageOptions.textFormat = options.format;
+                }
+                // Validate parameters
+                const params = {
+                    message,
+                    recipientType,
+                    teamId,
+                    channelId,
+                    userId,
+                };
+                validateMessageParams(params, ['message', 'recipientType'], this, i);
+                // Send message based on recipient type
+                let response;
+                try {
+                    if (recipientType === 'channel') {
+                        response = await api.sendChannelMessage(teamId, channelId, message, messageOptions);
+                    }
+                    else if (recipientType === 'chat') {
+                        // Always handle auto-installation for direct messages
+                        await (0, index_1.handleAutoInstall)(api, userId, i, this);
+                        response = await api.sendMessage(userId, message, messageOptions);
+                    }
+                    else {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unsupported recipient type: ${recipientType}`, { itemIndex: i });
+                    }
+                    // Ensure response is properly parsed before returning
+                    returnData.push({
+                        json: (0, utils_1.ensureObjectResponse)(response),
+                        pairedItem: { item: i },
+                    });
+                }
+                catch (error) {
+                    if (this.continueOnFail()) {
+                        const errorMessage = error instanceof Error ? error.message : String(error);
+                        returnData.push({
+                            json: {
+                                error: errorMessage,
+                            },
+                            pairedItem: { item: i },
+                        });
+                        continue;
+                    }
+                    throw error;
+                }
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    returnData.push({
+                        json: {
+                            error: errorMessage,
+                        },
+                        pairedItem: { item: i },
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    },
+    /**
+     * Updates an existing message in a conversation
+     */
+    async update() {
+        const items = this.getInputData();
+        const returnData = [];
+        const api = new index_1.TeamsApiClient(this);
+        await api.initialize();
+        for (let i = 0; i < items.length; i++) {
+            try {
+                // Get operation parameters
+                const conversationId = this.getNodeParameter('conversationId', i);
+                const activityId = this.getNodeParameter('activityId', i);
+                const message = this.getNodeParameter('message', i);
+                // Optional parameters for message formatting
+                const textFormat = this.getNodeParameter('textFormat', i, 'markdown');
+                const attachmentsJson = this.getNodeParameter('attachments', i, '');
+                // Parse attachments if provided
+                let attachments;
+                if (attachmentsJson) {
+                    try {
+                        attachments = JSON.parse(attachmentsJson);
+                    }
+                    catch (error) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Invalid JSON in attachments parameter: ${error}`, { itemIndex: i });
+                    }
+                }
+                // Prepare message options
+                const options = {
+                    textFormat,
+                    attachments,
+                };
+                // Update the message
+                const response = await api.updateMessage(conversationId, activityId, message, options);
+                // Ensure response is properly parsed before returning
+                returnData.push({
+                    json: (0, utils_1.ensureObjectResponse)(response),
+                    pairedItem: { item: i },
+                });
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    returnData.push({
+                        json: {
+                            error: errorMessage,
+                        },
+                        pairedItem: { item: i },
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    },
+    /**
+     * Deletes a message from a conversation
+     */
+    async delete() {
+        const items = this.getInputData();
+        const returnData = [];
+        const api = new index_1.TeamsApiClient(this);
+        await api.initialize();
+        for (let i = 0; i < items.length; i++) {
+            try {
+                // Get operation parameters
+                const conversationId = this.getNodeParameter('conversationId', i);
+                const activityId = this.getNodeParameter('activityId', i);
+                // Delete the message
+                await api.deleteMessage(conversationId, activityId);
+                // Return success confirmation
+                returnData.push({
+                    json: {
+                        success: true,
+                        message: `Message ${activityId} deleted successfully`,
+                        conversationId,
+                        activityId,
+                    },
+                    pairedItem: { item: i },
+                });
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    returnData.push({
+                        json: {
+                            error: errorMessage,
+                            conversationId: this.getNodeParameter('conversationId', i),
+                            activityId: this.getNodeParameter('activityId', i),
+                        },
+                        pairedItem: { item: i },
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    },
+    /**
+     * Replies to an existing message in a conversation
+     */
+    async reply() {
+        const items = this.getInputData();
+        const returnData = [];
+        const api = new index_1.TeamsApiClient(this);
+        await api.initialize();
+        for (let i = 0; i < items.length; i++) {
+            try {
+                // Get operation parameters
+                const conversationId = this.getNodeParameter('conversationId', i);
+                const replyToId = this.getNodeParameter('replyToId', i);
+                const message = this.getNodeParameter('message', i);
+                // Optional parameters for message formatting
+                const textFormat = this.getNodeParameter('textFormat', i, 'markdown');
+                const attachmentsJson = this.getNodeParameter('attachments', i, '');
+                // Parse attachments if provided
+                let attachments;
+                if (attachmentsJson) {
+                    try {
+                        attachments = JSON.parse(attachmentsJson);
+                    }
+                    catch (error) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Invalid JSON in attachments parameter: ${error}`, { itemIndex: i });
+                    }
+                }
+                // Prepare message options
+                const options = {
+                    textFormat,
+                    attachments,
+                };
+                // Reply to the message
+                const response = await api.replyToMessage(conversationId, replyToId, message, options);
+                // Ensure response is properly parsed before returning
+                returnData.push({
+                    json: (0, utils_1.ensureObjectResponse)(response),
+                    pairedItem: { item: i },
+                });
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    returnData.push({
+                        json: {
+                            error: errorMessage,
+                        },
+                        pairedItem: { item: i },
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    },
+    /**
+     * Sends a message and waits for a response
+     */
+    async sendAndWait() {
+        const items = this.getInputData();
+        const returnData = [];
+        const api = new index_1.TeamsApiClient(this);
+        await api.initialize();
+        for (let i = 0; i < items.length; i++) {
+            try {
+                // Get operation parameters
+                const message = this.getNodeParameter('message', i);
+                const recipientType = this.getNodeParameter('recipientType', i);
+                const timeout = this.getNodeParameter('timeout', i, 300); // Default 5 minutes
+                // Get required fields based on recipient type
+                let teamId;
+                let channelId;
+                let userId;
+                if (recipientType === 'channel') {
+                    teamId = this.getNodeParameter('teamId', i);
+                    channelId = this.getNodeParameter('channelId', i);
+                }
+                else if (recipientType === 'chat') {
+                    userId = this.getNodeParameter('userId', i);
+                }
+                // Optional parameters for message formatting
+                const textFormat = this.getNodeParameter('textFormat', i, 'markdown');
+                const attachmentsJson = this.getNodeParameter('attachments', i, '');
+                // Parse attachments if provided
+                let attachments;
+                if (attachmentsJson) {
+                    try {
+                        attachments = JSON.parse(attachmentsJson);
+                    }
+                    catch (error) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Invalid JSON in attachments parameter: ${error}`, { itemIndex: i });
+                    }
+                }
+                // Prepare message options
+                const options = {
+                    textFormat,
+                    attachments,
+                };
+                // Send the message first
+                let response;
+                if (recipientType === 'channel') {
+                    response = await api.sendChannelMessage(teamId, channelId, message, options);
+                }
+                else {
+                    response = await api.sendMessage(userId, message, options);
+                }
+                // Store context for the send-and-wait operation
+                // Use 'global' scope so the trigger node can access it
+                const workflowStaticData = this.getWorkflowStaticData('global');
+                const conversation = response.conversation;
+                const waitContext = {
+                    conversationId: (conversation === null || conversation === void 0 ? void 0 : conversation.id) || response.id,
+                    originalMessageId: response.id,
+                    timeout: Date.now() + (timeout * 1000),
+                    recipientType,
+                    teamId,
+                    channelId,
+                    userId,
+                };
+                // Store in workflow static data for the trigger to find
+                if (!workflowStaticData.waitingResponses) {
+                    workflowStaticData.waitingResponses = {};
+                }
+                workflowStaticData.waitingResponses[response.id] = waitContext;
+                // Calculate wait till date (same as base implementation)
+                const waitTill = new Date(Date.now() + (timeout * 1000));
+                // Put execution to wait
+                await this.putExecutionToWait(waitTill);
+                // Return the sent message data
+                returnData.push({
+                    json: (0, utils_1.ensureObjectResponse)(response),
+                    pairedItem: { item: i },
+                });
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    returnData.push({
+                        json: {
+                            error: errorMessage,
+                        },
+                        pairedItem: { item: i },
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    },
+    /**
+     * Retrieves conversation history for context
+     */
+    async getHistory() {
+        var _a;
+        const items = this.getInputData();
+        const returnData = [];
+        const api = new index_1.TeamsApiClient(this);
+        await api.initialize();
+        for (let i = 0; i < items.length; i++) {
+            try {
+                // Get operation parameters
+                const recipientType = this.getNodeParameter('recipientType', i);
+                const count = this.getNodeParameter('count', i, 10);
+                const filter = this.getNodeParameter('filter', i, '');
+                let response;
+                if (recipientType === 'channel') {
+                    const teamId = this.getNodeParameter('teamId', i);
+                    const channelId = this.getNodeParameter('channelId', i);
+                    response = await api.getChannelMessages(teamId, channelId, count, filter || undefined);
+                }
+                else {
+                    const chatId = this.getNodeParameter('chatId', i);
+                    response = await api.getChatMessages(chatId, count, filter || undefined);
+                }
+                // Format the response for easier consumption
+                const formattedResponse = {
+                    messages: response.value || [],
+                    totalCount: ((_a = response.value) === null || _a === void 0 ? void 0 : _a.length) || 0,
+                    recipientType,
+                    retrievedAt: new Date().toISOString(),
+                };
+                returnData.push({
+                    json: formattedResponse,
+                    pairedItem: { item: i },
+                });
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    returnData.push({
+                        json: {
+                            error: errorMessage,
+                            messages: [],
+                            totalCount: 0,
+                        },
+                        pairedItem: { item: i },
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    },
+    /**
+     * Gets a specific message by ID from a chat or channel
+     */
+    async get() {
+        const items = this.getInputData();
+        const returnData = [];
+        const api = new index_1.TeamsApiClient(this);
+        await api.initialize();
+        for (let i = 0; i < items.length; i++) {
+            try {
+                const recipientType = this.getNodeParameter('recipientType', i);
+                const messageId = this.getNodeParameter('messageId', i);
+                let response;
+                if (recipientType === 'channel') {
+                    const teamId = this.getNodeParameter('teamId', i);
+                    const channelId = this.getNodeParameter('channelId', i);
+                    response = await api.getChannelMessage(teamId, channelId, messageId);
+                }
+                else {
+                    const chatId = this.getNodeParameter('chatId', i);
+                    response = await api.getChatMessage(chatId, messageId);
+                }
+                returnData.push({
+                    json: response,
+                    pairedItem: { item: i },
+                });
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    returnData.push({
+                        json: {
+                            error: errorMessage,
+                        },
+                        pairedItem: { item: i },
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    },
+    /**
+     * Gets all messages from a chat or channel with pagination support
+     */
+    async getAll() {
+        const items = this.getInputData();
+        const returnData = [];
+        const api = new index_1.TeamsApiClient(this);
+        await api.initialize();
+        for (let i = 0; i < items.length; i++) {
+            try {
+                const recipientType = this.getNodeParameter('recipientType', i);
+                const returnAll = this.getNodeParameter('returnAll', i, false);
+                let messages;
+                if (recipientType === 'channel') {
+                    const teamId = this.getNodeParameter('teamId', i);
+                    const channelId = this.getNodeParameter('channelId', i);
+                    const limit = returnAll ? undefined : this.getNodeParameter('limit', i, 50);
+                    messages = await api.getAllChannelMessages(teamId, channelId, returnAll, limit);
+                }
+                else {
+                    const chatId = this.getNodeParameter('chatId', i);
+                    const limit = returnAll ? undefined : this.getNodeParameter('limit', i, 50);
+                    messages = await api.getAllChatMessages(chatId, returnAll, limit);
+                }
+                // Return messages as separate items
+                for (const message of messages) {
+                    returnData.push({
+                        json: message,
+                        pairedItem: { item: i },
+                    });
+                }
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    returnData.push({
+                        json: {
+                            error: errorMessage,
+                            value: [],
+                        },
+                        pairedItem: { item: i },
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    },
+    /**
+     * Pins a message in a chat
+     */
+    async pin() {
+        const items = this.getInputData();
+        const returnData = [];
+        const api = new index_1.TeamsApiClient(this);
+        await api.initialize();
+        for (let i = 0; i < items.length; i++) {
+            try {
+                const chatId = this.getNodeParameter('chatId', i);
+                const messageId = this.getNodeParameter('messageId', i);
+                if (!chatId || !messageId) {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Both chatId and messageId are required for pinning messages', { itemIndex: i });
+                }
+                const response = await api.pinChatMessage(chatId, messageId);
+                returnData.push({
+                    json: (0, utils_1.ensureObjectResponse)(response),
+                    pairedItem: { item: i },
+                });
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    returnData.push({
+                        json: { error: errorMessage },
+                        pairedItem: { item: i },
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    },
+    /**
+     * Unpins a message from a chat
+     */
+    async unpin() {
+        const items = this.getInputData();
+        const returnData = [];
+        const api = new index_1.TeamsApiClient(this);
+        await api.initialize();
+        for (let i = 0; i < items.length; i++) {
+            try {
+                const chatId = this.getNodeParameter('chatId', i);
+                const messageId = this.getNodeParameter('messageId', i);
+                if (!chatId || !messageId) {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Both chatId and messageId are required for unpinning messages', { itemIndex: i });
+                }
+                await api.unpinChatMessage(chatId, messageId);
+                returnData.push({
+                    json: {
+                        success: true,
+                        message: `Message ${messageId} unpinned from chat ${chatId}`,
+                    },
+                    pairedItem: { item: i },
+                });
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    returnData.push({
+                        json: { error: errorMessage },
+                        pairedItem: { item: i },
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    },
+    /**
+     * Gets all pinned messages in a chat
+     */
+    async getPinned() {
+        const items = this.getInputData();
+        const returnData = [];
+        const api = new index_1.TeamsApiClient(this);
+        await api.initialize();
+        for (let i = 0; i < items.length; i++) {
+            try {
+                const chatId = this.getNodeParameter('chatId', i);
+                if (!chatId) {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'chatId is required for getting pinned messages', { itemIndex: i });
+                }
+                const response = await api.getPinnedChatMessages(chatId);
+                returnData.push({
+                    json: (0, utils_1.ensureObjectResponse)(response),
+                    pairedItem: { item: i },
+                });
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    returnData.push({
+                        json: { error: errorMessage },
+                        pairedItem: { item: i },
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    },
+    /**
+     * Pins a message in a channel (Note: This will throw an error as it's not supported)
+     */
+    async pinChannel() {
+        const items = this.getInputData();
+        const returnData = [];
+        const api = new index_1.TeamsApiClient(this);
+        await api.initialize();
+        for (let i = 0; i < items.length; i++) {
+            try {
+                const teamId = this.getNodeParameter('teamId', i);
+                const channelId = this.getNodeParameter('channelId', i);
+                const messageId = this.getNodeParameter('messageId', i);
+                if (!teamId || !channelId || !messageId) {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'teamId, channelId, and messageId are required for pinning channel messages', { itemIndex: i });
+                }
+                // This will throw an error as channel pinning is not supported
+                const response = await api.pinChannelMessage(teamId, channelId, messageId);
+                returnData.push({
+                    json: (0, utils_1.ensureObjectResponse)(response),
+                    pairedItem: { item: i },
+                });
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    returnData.push({
+                        json: { error: errorMessage },
+                        pairedItem: { item: i },
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    },
+    /**
+     * Unpins a message from a channel (Note: This will throw an error as it's not supported)
+     */
+    async unpinChannel() {
+        const items = this.getInputData();
+        const returnData = [];
+        const api = new index_1.TeamsApiClient(this);
+        await api.initialize();
+        for (let i = 0; i < items.length; i++) {
+            try {
+                const teamId = this.getNodeParameter('teamId', i);
+                const channelId = this.getNodeParameter('channelId', i);
+                const messageId = this.getNodeParameter('messageId', i);
+                if (!teamId || !channelId || !messageId) {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'teamId, channelId, and messageId are required for unpinning channel messages', { itemIndex: i });
+                }
+                // This will throw an error as channel unpinning is not supported
+                await api.unpinChannelMessage(teamId, channelId, messageId);
+                returnData.push({
+                    json: {
+                        success: true,
+                        message: `Message ${messageId} unpinned from channel ${channelId}`,
+                    },
+                    pairedItem: { item: i },
+                });
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    returnData.push({
+                        json: { error: errorMessage },
+                        pairedItem: { item: i },
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    },
+    /**
+     * Analyze and process message reactions
+     */
+    async analyzeReactions() {
+        const items = this.getInputData();
+        const returnData = [];
+        const api = new index_1.TeamsApiClient(this);
+        await api.initialize();
+        for (let i = 0; i < items.length; i++) {
+            try {
+                const reactionData = this.getNodeParameter('reactionData', i);
+                let parsedReactions;
+                try {
+                    parsedReactions = JSON.parse(reactionData);
+                }
+                catch (error) {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Invalid JSON in reaction data', { itemIndex: i });
+                }
+                // Analyze reaction patterns
+                const analysis = analyzeReactionPatterns(parsedReactions);
+                returnData.push({
+                    json: {
+                        reactionData: parsedReactions,
+                        analysis,
+                        timestamp: new Date().toISOString(),
+                    },
+                    pairedItem: { item: i },
+                });
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    returnData.push({
+                        json: { error: errorMessage },
+                        pairedItem: { item: i },
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    },
+    /**
+     * Get reaction analytics for a conversation
+     */
+    async getReactionAnalytics() {
+        const items = this.getInputData();
+        const returnData = [];
+        const api = new index_1.TeamsApiClient(this);
+        await api.initialize();
+        for (let i = 0; i < items.length; i++) {
+            try {
+                const conversationId = this.getNodeParameter('conversationId', i);
+                const timeRange = this.getNodeParameter('timeRange', i, 24); // hours
+                if (!conversationId) {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Conversation ID is required', { itemIndex: i });
+                }
+                // Get message history to analyze reactions
+                const messageHistory = await api.getChatMessages(conversationId, 100);
+                // Analyze reactions across all messages
+                const analytics = generateReactionAnalytics(messageHistory.value || [], timeRange);
+                returnData.push({
+                    json: {
+                        conversationId,
+                        analytics,
+                        timeRangeHours: timeRange,
+                        analyzedAt: new Date().toISOString(),
+                    },
+                    pairedItem: { item: i },
+                });
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    returnData.push({
+                        json: { error: errorMessage },
+                        pairedItem: { item: i },
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    },
+    /**
+     * Process and optimize file attachments
+     */
+    async processFile() {
+        var _a, _b;
+        const items = this.getInputData();
+        const returnData = [];
+        const api = new index_1.TeamsApiClient(this);
+        await api.initialize();
+        for (let i = 0; i < items.length; i++) {
+            try {
+                const fileData = this.getNodeParameter('fileData', i);
+                const fileName = this.getNodeParameter('fileName', i);
+                const contentType = this.getNodeParameter('contentType', i);
+                const enableOptimization = this.getNodeParameter('enableOptimization', i, true);
+                let fileContent;
+                let parsedAttachment;
+                try {
+                    // Try to parse as JSON first (for structured attachment data)
+                    parsedAttachment = JSON.parse(fileData);
+                    // If it's a URL, we'll need to download it
+                    if (parsedAttachment.contentUrl && !parsedAttachment.content) {
+                        throw new Error('File content not available, would need download');
+                    }
+                    // Handle content field properly - it could be a string or object
+                    const contentData = parsedAttachment.content;
+                    let contentString = '';
+                    if (typeof contentData === 'string') {
+                        contentString = contentData;
+                    }
+                    else if (contentData && typeof contentData === 'object') {
+                        contentString = contentData.data || '';
+                    }
+                    fileContent = Buffer.from(contentString, 'base64');
+                }
+                catch {
+                    // Assume it's base64 encoded file content
+                    fileContent = Buffer.from(fileData, 'base64');
+                    parsedAttachment = {
+                        name: fileName,
+                        contentType,
+                        content: { data: fileData },
+                        size: fileContent.length,
+                    };
+                }
+                // Validate file content
+                (0, fileProcessing_1.validateFileContent)(this.getNode(), fileContent, contentType, i);
+                // Extract file metadata
+                const metadata = await (0, fileProcessing_1.extractFileMetadata)(this.getNode(), fileContent, contentType, fileName, i);
+                let processingResult;
+                if (enableOptimization && contentType.startsWith('image/')) {
+                    // Optimize image if enabled
+                    processingResult = await (0, fileProcessing_1.optimizeImage)(this.getNode(), parsedAttachment, i);
+                }
+                else {
+                    // Create basic processing result
+                    processingResult = {
+                        originalFile: {
+                            name: fileName,
+                            size: fileContent.length,
+                            contentType,
+                        },
+                        status: constants_1.FileProcessingStatus.COMPLETE,
+                        processingTime: 0,
+                    };
+                }
+                (0, validation_1.validateFileProcessingResult)(this.getNode(), processingResult, i);
+                returnData.push({
+                    json: {
+                        fileName,
+                        contentType,
+                        originalSize: fileContent.length,
+                        processedSize: ((_a = processingResult.processedFile) === null || _a === void 0 ? void 0 : _a.size) || fileContent.length,
+                        metadata,
+                        processingResult,
+                        optimized: ((_b = processingResult.processedFile) === null || _b === void 0 ? void 0 : _b.optimized) || false,
+                        processingTime: processingResult.processingTime,
+                    },
+                    pairedItem: { item: i },
+                });
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    returnData.push({
+                        json: { error: errorMessage },
+                        pairedItem: { item: i },
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    },
+    /**
+     * Generate thumbnail for image attachments
+     */
+    async generateThumbnail() {
+        var _a;
+        const items = this.getInputData();
+        const returnData = [];
+        const api = new index_1.TeamsApiClient(this);
+        await api.initialize();
+        for (let i = 0; i < items.length; i++) {
+            try {
+                const imageData = this.getNodeParameter('imageData', i);
+                const maxWidth = this.getNodeParameter('maxWidth', i, 200);
+                const maxHeight = this.getNodeParameter('maxHeight', i, 200);
+                let imageAttachment;
+                try {
+                    imageAttachment = JSON.parse(imageData);
+                }
+                catch {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Invalid image data format', { itemIndex: i });
+                }
+                // Validate that it's an image
+                if (!((_a = imageAttachment.contentType) === null || _a === void 0 ? void 0 : _a.startsWith('image/'))) {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Thumbnail generation requires image content', { itemIndex: i });
+                }
+                // Generate thumbnail
+                const thumbnailUrl = await (0, fileProcessing_1.generateThumbnail)(this.getNode(), imageAttachment, maxWidth, maxHeight, i);
+                returnData.push({
+                    json: {
+                        originalImage: {
+                            name: imageAttachment.name,
+                            contentType: imageAttachment.contentType,
+                            size: imageAttachment.size,
+                        },
+                        thumbnail: {
+                            url: thumbnailUrl,
+                            maxWidth,
+                            maxHeight,
+                        },
+                        generated: true,
+                    },
+                    pairedItem: { item: i },
+                });
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    returnData.push({
+                        json: { error: errorMessage },
+                        pairedItem: { item: i },
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    },
+    /**
+     * Send message with file attachment (enhanced reply functionality)
+     */
+    async sendWithAttachment() {
+        var _a;
+        const items = this.getInputData();
+        const returnData = [];
+        const api = new index_1.TeamsApiClient(this);
+        await api.initialize();
+        for (let i = 0; i < items.length; i++) {
+            try {
+                const message = this.getNodeParameter('message', i);
+                const recipientType = this.getNodeParameter('recipientType', i);
+                const attachmentData = this.getNodeParameter('attachmentData', i);
+                const enableProcessing = this.getNodeParameter('enableProcessing', i, true);
+                let teamId;
+                let channelId;
+                let userId;
+                if (recipientType === 'channel') {
+                    teamId = this.getNodeParameter('teamId', i);
+                    channelId = this.getNodeParameter('channelId', i);
+                }
+                else if (recipientType === 'chat') {
+                    userId = this.getNodeParameter('userId', i);
+                }
+                let attachment;
+                try {
+                    attachment = JSON.parse(attachmentData);
+                }
+                catch {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Invalid attachment data format', { itemIndex: i });
+                }
+                // Validate attachment
+                await (0, validation_1.validateAttachment)(this.getNode(), attachment, i);
+                // Process attachment if enabled
+                if (enableProcessing && ((_a = attachment.contentType) === null || _a === void 0 ? void 0 : _a.startsWith('image/'))) {
+                    const processingResult = await (0, fileProcessing_1.optimizeImage)(this.getNode(), attachment, i);
+                    if (processingResult.processedFile) {
+                        attachment = {
+                            ...attachment,
+                            ...processingResult.processedFile,
+                        };
+                    }
+                }
+                const options = {
+                    attachments: [attachment],
+                    textFormat: 'markdown',
+                };
+                let response;
+                if (recipientType === 'channel') {
+                    response = await api.sendChannelMessage(teamId, channelId, message, options);
+                }
+                else {
+                    response = await api.sendMessage(userId, message, options);
+                }
+                returnData.push({
+                    json: (0, utils_1.ensureObjectResponse)(response),
+                    pairedItem: { item: i },
+                });
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    returnData.push({
+                        json: { error: errorMessage },
+                        pairedItem: { item: i },
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    },
+    /**
+     * Reply to message with file attachment
+     */
+    async replyWithAttachment() {
+        var _a;
+        const items = this.getInputData();
+        const returnData = [];
+        const api = new index_1.TeamsApiClient(this);
+        await api.initialize();
+        for (let i = 0; i < items.length; i++) {
+            try {
+                const conversationId = this.getNodeParameter('conversationId', i);
+                const activityId = this.getNodeParameter('activityId', i);
+                const message = this.getNodeParameter('message', i);
+                const attachmentData = this.getNodeParameter('attachmentData', i);
+                const enableProcessing = this.getNodeParameter('enableProcessing', i, true);
+                let attachment;
+                try {
+                    attachment = JSON.parse(attachmentData);
+                }
+                catch {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Invalid attachment data format', { itemIndex: i });
+                }
+                // Validate attachment
+                await (0, validation_1.validateAttachment)(this.getNode(), attachment, i);
+                // Process attachment if enabled
+                if (enableProcessing && ((_a = attachment.contentType) === null || _a === void 0 ? void 0 : _a.startsWith('image/'))) {
+                    const processingResult = await (0, fileProcessing_1.optimizeImage)(this.getNode(), attachment, i);
+                    if (processingResult.processedFile) {
+                        attachment = {
+                            ...attachment,
+                            ...processingResult.processedFile,
+                        };
+                    }
+                }
+                const options = {
+                    attachments: [attachment],
+                    textFormat: 'markdown',
+                };
+                const response = await api.replyToMessage(conversationId, activityId, message, options);
+                returnData.push({
+                    json: (0, utils_1.ensureObjectResponse)(response),
+                    pairedItem: { item: i },
+                });
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    returnData.push({
+                        json: { error: errorMessage },
+                        pairedItem: { item: i },
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    },
+    /**
+     * Monitor upload progress
+     */
+    async monitorUpload() {
+        const items = this.getInputData();
+        const returnData = [];
+        const api = new index_1.TeamsApiClient(this);
+        await api.initialize();
+        for (let i = 0; i < items.length; i++) {
+            try {
+                const fileName = this.getNodeParameter('fileName', i);
+                const fileSize = this.getNodeParameter('fileSize', i);
+                const bytesUploaded = this.getNodeParameter('bytesUploaded', i, 0);
+                const uploadSpeed = this.getNodeParameter('uploadSpeed', i, 0);
+                // Create or update upload progress
+                let progress;
+                if (bytesUploaded === 0) {
+                    progress = (0, fileProcessing_1.createUploadProgress)(fileName, fileSize);
+                }
+                else {
+                    progress = (0, fileProcessing_1.createUploadProgress)(fileName, fileSize);
+                    progress = (0, fileProcessing_1.updateUploadProgress)(progress, bytesUploaded, uploadSpeed);
+                }
+                (0, validation_1.validateUploadProgress)(this.getNode(), progress, i);
+                returnData.push({
+                    json: {
+                        fileName: progress.fileName,
+                        fileSize: progress.fileSize,
+                        bytesUploaded: progress.bytesUploaded,
+                        percentage: Math.round(progress.percentage * 100) / 100,
+                        status: progress.status,
+                        startTime: progress.startTime.toISOString(),
+                        estimatedTimeRemaining: progress.estimatedTimeRemaining,
+                        timeElapsed: Date.now() - progress.startTime.getTime(),
+                    },
+                    pairedItem: { item: i },
+                });
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    returnData.push({
+                        json: { error: errorMessage },
+                        pairedItem: { item: i },
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    },
+};
+//# sourceMappingURL=messages.js.map