n8n-nodes-sharepoint-custom 0.1.0 → 0.1.2

package/dist/nodes/Microsoft/Outlook/v1/MicrosoftOutlookV1.node.js

@@ -0,0 +1,838 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MicrosoftOutlookV1 = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const descriptions_1 = require("../../../../utils/descriptions");
+const DraftDescription_1 = require("./DraftDescription");
+const DraftMessageSharedDescription_1 = require("./DraftMessageSharedDescription");
+const FolderDescription_1 = require("./FolderDescription");
+const FolderMessageDecription_1 = require("./FolderMessageDecription");
+const GenericFunctions_1 = require("./GenericFunctions");
+const MessageAttachmentDescription_1 = require("./MessageAttachmentDescription");
+const MessageDescription_1 = require("./MessageDescription");
+const versionDescription = {
+    displayName: 'Microsoft Outlook',
+    name: 'microsoftOutlook',
+    group: ['transform'],
+    icon: 'file:outlook.svg',
+    version: 1,
+    subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
+    description: 'Consume Microsoft Outlook API',
+    defaults: {
+        name: 'Microsoft Outlook',
+    },
+    inputs: [n8n_workflow_1.NodeConnectionTypes.Main],
+    outputs: [n8n_workflow_1.NodeConnectionTypes.Main],
+    credentials: [
+        {
+            name: 'microsoftOutlookOAuth2Api',
+            required: true,
+        },
+    ],
+    properties: [
+        descriptions_1.oldVersionNotice,
+        {
+            displayName: 'Resource',
+            name: 'resource',
+            type: 'options',
+            noDataExpression: true,
+            default: 'message',
+            options: [
+                {
+                    name: 'Draft',
+                    value: 'draft',
+                },
+                {
+                    name: 'Folder',
+                    value: 'folder',
+                },
+                {
+                    name: 'Folder Message',
+                    value: 'folderMessage',
+                },
+                {
+                    name: 'Message',
+                    value: 'message',
+                },
+                {
+                    name: 'Message Attachment',
+                    value: 'messageAttachment',
+                },
+            ],
+        },
+        // Draft
+        ...DraftDescription_1.draftOperations,
+        ...DraftDescription_1.draftFields,
+        // Message
+        ...MessageDescription_1.messageOperations,
+        ...MessageDescription_1.messageFields,
+        // Message Attachment
+        ...MessageAttachmentDescription_1.messageAttachmentOperations,
+        ...MessageAttachmentDescription_1.messageAttachmentFields,
+        // Folder
+        ...FolderDescription_1.folderOperations,
+        ...FolderDescription_1.folderFields,
+        // Folder Message
+        ...FolderMessageDecription_1.folderMessageOperations,
+        ...FolderMessageDecription_1.folderMessageFields,
+        // Draft & Message
+        ...DraftMessageSharedDescription_1.draftMessageSharedFields,
+    ],
+};
+class MicrosoftOutlookV1 {
+    constructor(baseDescription) {
+        this.methods = {
+            loadOptions: {
+                // Get all the categories to display them to user so that he can
+                // select them easily
+                async getCategories() {
+                    const returnData = [];
+                    const categories = await GenericFunctions_1.microsoftApiRequestAllItems.call(this, 'value', 'GET', '/outlook/masterCategories');
+                    for (const category of categories) {
+                        returnData.push({
+                            name: category.displayName,
+                            value: category.id,
+                        });
+                    }
+                    return returnData;
+                },
+            },
+        };
+        this.description = {
+            ...baseDescription,
+            ...versionDescription,
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        const length = items.length;
+        const qs = {};
+        let responseData;
+        const resource = this.getNodeParameter('resource', 0);
+        const operation = this.getNodeParameter('operation', 0);
+        if (['draft', 'message'].includes(resource)) {
+            if (operation === 'delete') {
+                for (let i = 0; i < length; i++) {
+                    try {
+                        const messageId = this.getNodeParameter('messageId', i);
+                        responseData = await GenericFunctions_1.microsoftApiRequest.call(this, 'DELETE', `/messages/${messageId}`);
+                        returnData.push({ success: true });
+                    }
+                    catch (error) {
+                        if (this.continueOnFail()) {
+                            returnData.push({ error: error.message });
+                            continue;
+                        }
+                        throw error;
+                    }
+                }
+            }
+            if (operation === 'get') {
+                for (let i = 0; i < length; i++) {
+                    try {
+                        const messageId = this.getNodeParameter('messageId', i);
+                        const additionalFields = this.getNodeParameter('additionalFields', i);
+                        if (additionalFields.fields) {
+                            qs.$select = additionalFields.fields;
+                        }
+                        if (additionalFields.filter) {
+                            qs.$filter = additionalFields.filter;
+                        }
+                        responseData = await GenericFunctions_1.microsoftApiRequest.call(this, 'GET', `/messages/${messageId}`, undefined, qs);
+                        if (additionalFields.dataPropertyAttachmentsPrefixName) {
+                            const prefix = additionalFields.dataPropertyAttachmentsPrefixName;
+                            const data = await GenericFunctions_1.downloadAttachments.call(this, responseData, prefix);
+                            returnData.push.apply(returnData, data);
+                        }
+                        else {
+                            returnData.push(responseData);
+                        }
+                        if (additionalFields.dataPropertyAttachmentsPrefixName) {
+                            return [returnData];
+                        }
+                    }
+                    catch (error) {
+                        if (this.continueOnFail()) {
+                            returnData.push({ error: error.message });
+                            continue;
+                        }
+                        throw error;
+                    }
+                }
+            }
+            if (operation === 'update') {
+                for (let i = 0; i < length; i++) {
+                    try {
+                        const messageId = this.getNodeParameter('messageId', i);
+                        const updateFields = this.getNodeParameter('updateFields', i);
+                        // Create message from optional fields
+                        const body = (0, GenericFunctions_1.createMessage)(updateFields);
+                        responseData = await GenericFunctions_1.microsoftApiRequest.call(this, 'PATCH', `/messages/${messageId}`, body, {});
+                        returnData.push(responseData);
+                    }
+                    catch (error) {
+                        if (this.continueOnFail()) {
+                            returnData.push({ error: error.message });
+                            continue;
+                        }
+                        throw error;
+                    }
+                }
+            }
+        }
+        if (resource === 'draft') {
+            if (operation === 'create') {
+                for (let i = 0; i < length; i++) {
+                    try {
+                        const additionalFields = this.getNodeParameter('additionalFields', i);
+                        const subject = this.getNodeParameter('subject', i);
+                        const bodyContent = this.getNodeParameter('bodyContent', i, '');
+                        additionalFields.subject = subject;
+                        additionalFields.bodyContent = bodyContent || ' ';
+                        // Create message object from optional fields
+                        const body = (0, GenericFunctions_1.createMessage)(additionalFields);
+                        if (additionalFields.attachments) {
+                            const attachments = additionalFields.attachments
+                                .attachments;
+                            // // Handle attachments
+                            body.attachments = attachments.map((attachment) => {
+                                const binaryPropertyName = attachment.binaryPropertyName;
+                                if (items[i].binary === undefined) {
+                                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'No binary data exists on item!', {
+                                        itemIndex: i,
+                                    });
+                                }
+                                if (items[i].binary[binaryPropertyName] === undefined) {
+                                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `No binary data property "${binaryPropertyName}" does not exists on item!`, { itemIndex: i });
+                                }
+                                const binaryData = items[i].binary[binaryPropertyName];
+                                return {
+                                    '@odata.type': '#microsoft.graph.fileAttachment',
+                                    name: binaryData.fileName,
+                                    contentBytes: binaryData.data,
+                                };
+                            });
+                        }
+                        responseData = await GenericFunctions_1.microsoftApiRequest.call(this, 'POST', '/messages', body, {});
+                        returnData.push(responseData);
+                    }
+                    catch (error) {
+                        if (this.continueOnFail()) {
+                            returnData.push({ error: error.message });
+                            continue;
+                        }
+                        throw error;
+                    }
+                }
+            }
+            if (operation === 'send') {
+                for (let i = 0; i < length; i++) {
+                    try {
+                        const messageId = this.getNodeParameter('messageId', i);
+                        const additionalFields = this.getNodeParameter('additionalFields', i, {});
+                        if (additionalFields?.recipients) {
+                            const recipients = additionalFields.recipients
+                                .split(',')
+                                .filter((email) => !!email);
+                            if (recipients.length !== 0) {
+                                await GenericFunctions_1.microsoftApiRequest.call(this, 'PATCH', `/messages/${messageId}`, {
+                                    toRecipients: recipients.map((recipient) => (0, GenericFunctions_1.makeRecipient)(recipient)),
+                                });
+                            }
+                        }
+                        responseData = await GenericFunctions_1.microsoftApiRequest.call(this, 'POST', `/messages/${messageId}/send`);
+                        returnData.push({ success: true });
+                    }
+                    catch (error) {
+                        if (this.continueOnFail()) {
+                            returnData.push({ error: error.message });
+                            continue;
+                        }
+                        throw error;
+                    }
+                }
+            }
+        }
+        if (resource === 'message') {
+            if (operation === 'reply') {
+                for (let i = 0; i < length; i++) {
+                    try {
+                        const messageId = this.getNodeParameter('messageId', i);
+                        const replyType = this.getNodeParameter('replyType', i);
+                        const comment = this.getNodeParameter('comment', i);
+                        const send = this.getNodeParameter('send', i, false);
+                        const additionalFields = this.getNodeParameter('additionalFields', i, {});
+                        const body = {};
+                        let action = 'createReply';
+                        if (replyType === 'replyAll') {
+                            body.comment = comment;
+                            action = 'createReplyAll';
+                        }
+                        else {
+                            body.comment = comment;
+                            body.message = {};
+                            Object.assign(body.message, (0, GenericFunctions_1.createMessage)(additionalFields));
+                            delete body.message.attachments;
+                        }
+                        responseData = await GenericFunctions_1.microsoftApiRequest.call(this, 'POST', `/messages/${messageId}/${action}`, body);
+                        if (additionalFields.attachments) {
+                            const attachments = additionalFields.attachments
+                                .attachments;
+                            // // Handle attachments
+                            const data = attachments.map((attachment) => {
+                                const binaryPropertyName = attachment.binaryPropertyName;
+                                if (items[i].binary === undefined) {
+                                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'No binary data exists on item!', {
+                                        itemIndex: i,
+                                    });
+                                }
+                                if (items[i].binary[binaryPropertyName] === undefined) {
+                                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `No binary data property "${binaryPropertyName}" does not exists on item!`, { itemIndex: i });
+                                }
+                                const binaryData = items[i].binary[binaryPropertyName];
+                                return {
+                                    '@odata.type': '#microsoft.graph.fileAttachment',
+                                    name: binaryData.fileName,
+                                    contentBytes: binaryData.data,
+                                };
+                            });
+                            for (const attachment of data) {
+                                await GenericFunctions_1.microsoftApiRequest.call(this, 'POST', `/messages/${responseData.id}/attachments`, attachment, {});
+                            }
+                        }
+                        if (send) {
+                            await GenericFunctions_1.microsoftApiRequest.call(this, 'POST', `/messages/${responseData.id}/send`);
+                        }
+                        returnData.push(responseData);
+                    }
+                    catch (error) {
+                        if (this.continueOnFail()) {
+                            returnData.push({ error: error.message });
+                            continue;
+                        }
+                        throw error;
+                    }
+                }
+            }
+            if (operation === 'getMime') {
+                for (let i = 0; i < length; i++) {
+                    try {
+                        const messageId = this.getNodeParameter('messageId', i);
+                        const dataPropertyNameDownload = this.getNodeParameter('binaryPropertyName', i);
+                        const response = await GenericFunctions_1.microsoftApiRequest.call(this, 'GET', `/messages/${messageId}/$value`, undefined, {}, undefined, {}, { encoding: null, resolveWithFullResponse: true });
+                        let mimeType;
+                        if (response.headers['content-type']) {
+                            mimeType = response.headers['content-type'];
+                        }
+                        const newItem = {
+                            json: items[i].json,
+                            binary: {},
+                        };
+                        if (items[i].binary !== undefined) {
+                            // Create a shallow copy of the binary data so that the old
+                            // data references which do not get changed still stay behind
+                            // but the incoming data does not get changed.
+                            Object.assign(newItem.binary, items[i].binary);
+                        }
+                        items[i] = newItem;
+                        const fileName = `${messageId}.eml`;
+                        const data = Buffer.from(response.body, 'utf8');
+                        items[i].binary[dataPropertyNameDownload] = await this.helpers.prepareBinaryData(data, fileName, mimeType);
+                    }
+                    catch (error) {
+                        if (this.continueOnFail()) {
+                            items[i].json = { error: error.message };
+                            continue;
+                        }
+                        throw error;
+                    }
+                }
+            }
+            if (operation === 'getAll') {
+                let additionalFields = {};
+                for (let i = 0; i < length; i++) {
+                    try {
+                        const returnAll = this.getNodeParameter('returnAll', i);
+                        additionalFields = this.getNodeParameter('additionalFields', i);
+                        if (additionalFields.fields) {
+                            qs.$select = additionalFields.fields;
+                        }
+                        if (additionalFields.filter) {
+                            qs.$filter = additionalFields.filter;
+                        }
+                        const endpoint = '/messages';
+                        if (returnAll) {
+                            responseData = await GenericFunctions_1.microsoftApiRequestAllItems.call(this, 'value', 'GET', endpoint, undefined, qs);
+                        }
+                        else {
+                            qs.$top = this.getNodeParameter('limit', i);
+                            responseData = await GenericFunctions_1.microsoftApiRequest.call(this, 'GET', endpoint, undefined, qs);
+                            responseData = responseData.value;
+                        }
+                        if (additionalFields.dataPropertyAttachmentsPrefixName) {
+                            const prefix = additionalFields.dataPropertyAttachmentsPrefixName;
+                            const data = await GenericFunctions_1.downloadAttachments.call(this, responseData, prefix);
+                            returnData.push.apply(returnData, data);
+                        }
+                        else {
+                            returnData.push.apply(returnData, responseData);
+                        }
+                    }
+                    catch (error) {
+                        if (this.continueOnFail()) {
+                            returnData.push({ error: error.message });
+                            continue;
+                        }
+                        throw error;
+                    }
+                }
+                if (additionalFields.dataPropertyAttachmentsPrefixName) {
+                    return [returnData];
+                }
+            }
+            if (operation === 'move') {
+                for (let i = 0; i < length; i++) {
+                    try {
+                        const messageId = this.getNodeParameter('messageId', i);
+                        const destinationId = this.getNodeParameter('folderId', i);
+                        const body = {
+                            destinationId,
+                        };
+                        responseData = await GenericFunctions_1.microsoftApiRequest.call(this, 'POST', `/messages/${messageId}/move`, body);
+                        returnData.push({ success: true });
+                    }
+                    catch (error) {
+                        if (this.continueOnFail()) {
+                            returnData.push({ error: error.message });
+                            continue;
+                        }
+                        throw error;
+                    }
+                }
+            }
+            if (operation === 'send') {
+                for (let i = 0; i < length; i++) {
+                    try {
+                        const additionalFields = this.getNodeParameter('additionalFields', i);
+                        const toRecipients = this.getNodeParameter('toRecipients', i);
+                        const subject = this.getNodeParameter('subject', i);
+                        const bodyContent = this.getNodeParameter('bodyContent', i, '');
+                        additionalFields.subject = subject;
+                        additionalFields.bodyContent = bodyContent || ' ';
+                        additionalFields.toRecipients = toRecipients;
+                        const saveToSentItems = additionalFields.saveToSentItems === undefined
+                            ? true
+                            : additionalFields.saveToSentItems;
+                        delete additionalFields.saveToSentItems;
+                        // Create message object from optional fields
+                        const message = (0, GenericFunctions_1.createMessage)(additionalFields);
+                        if (additionalFields.attachments) {
+                            const attachments = additionalFields.attachments
+                                .attachments;
+                            // // Handle attachments
+                            message.attachments = attachments.map((attachment) => {
+                                const binaryPropertyName = attachment.binaryPropertyName;
+                                if (items[i].binary === undefined) {
+                                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'No binary data exists on item!', {
+                                        itemIndex: i,
+                                    });
+                                }
+                                if (items[i].binary[binaryPropertyName] === undefined) {
+                                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `No binary data property "${binaryPropertyName}" does not exists on item!`, { itemIndex: i });
+                                }
+                                const binaryData = items[i].binary[binaryPropertyName];
+                                return {
+                                    '@odata.type': '#microsoft.graph.fileAttachment',
+                                    name: binaryData.fileName,
+                                    contentBytes: binaryData.data,
+                                };
+                            });
+                        }
+                        const body = {
+                            message,
+                            saveToSentItems,
+                        };
+                        responseData = await GenericFunctions_1.microsoftApiRequest.call(this, 'POST', '/sendMail', body, {});
+                        returnData.push({ success: true });
+                    }
+                    catch (error) {
+                        if (this.continueOnFail()) {
+                            returnData.push({ error: error.message });
+                            continue;
+                        }
+                        throw error;
+                    }
+                }
+            }
+        }
+        if (resource === 'messageAttachment') {
+            if (operation === 'add') {
+                for (let i = 0; i < length; i++) {
+                    try {
+                        const messageId = this.getNodeParameter('messageId', i);
+                        const binaryPropertyName = this.getNodeParameter('binaryPropertyName', 0);
+                        const additionalFields = this.getNodeParameter('additionalFields', i);
+                        if (items[i].binary === undefined) {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'No binary data exists on item!');
+                        }
+                        if (items[i].binary[binaryPropertyName] === undefined) {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `No binary data property "${binaryPropertyName}" does not exists on item!`, { itemIndex: i });
+                        }
+                        const binaryData = items[i].binary[binaryPropertyName];
+                        const dataBuffer = await this.helpers.getBinaryDataBuffer(i, binaryPropertyName);
+                        const fileName = additionalFields.fileName === undefined
+                            ? binaryData.fileName
+                            : additionalFields.fileName;
+                        if (!fileName) {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'File name is not set. It has either to be set via "Additional Fields" or has to be set on the binary property!', { itemIndex: i });
+                        }
+                        // Check if the file is over 3MB big
+                        if (dataBuffer.length > 3e6) {
+                            // Maximum chunk size is 4MB
+                            const chunkSize = 4e6;
+                            const body = {
+                                AttachmentItem: {
+                                    attachmentType: 'file',
+                                    name: fileName,
+                                    size: dataBuffer.length,
+                                },
+                            };
+                            // Create upload session
+                            responseData = await GenericFunctions_1.microsoftApiRequest.call(this, 'POST', `/messages/${messageId}/attachments/createUploadSession`, body);
+                            const uploadUrl = responseData.uploadUrl;
+                            if (uploadUrl === undefined) {
+                                throw new n8n_workflow_1.NodeApiError(this.getNode(), responseData, {
+                                    message: 'Failed to get upload session',
+                                });
+                            }
+                            for (let bytesUploaded = 0; bytesUploaded < dataBuffer.length; bytesUploaded += chunkSize) {
+                                // Upload the file chunk by chunk
+                                const nextChunk = Math.min(bytesUploaded + chunkSize, dataBuffer.length);
+                                const contentRange = `bytes ${bytesUploaded}-${nextChunk - 1}/${dataBuffer.length}`;
+                                const data = dataBuffer.subarray(bytesUploaded, nextChunk);
+                                responseData = await this.helpers.request(uploadUrl, {
+                                    method: 'PUT',
+                                    headers: {
+                                        'Content-Type': 'application/octet-stream',
+                                        'Content-Length': data.length,
+                                        'Content-Range': contentRange,
+                                    },
+                                    body: data,
+                                });
+                            }
+                        }
+                        else {
+                            const body = {
+                                '@odata.type': '#microsoft.graph.fileAttachment',
+                                name: fileName,
+                                contentBytes: binaryData.data,
+                            };
+                            responseData = await GenericFunctions_1.microsoftApiRequest.call(this, 'POST', `/messages/${messageId}/attachments`, body, {});
+                        }
+                        returnData.push({ success: true });
+                    }
+                    catch (error) {
+                        if (this.continueOnFail()) {
+                            returnData.push({ error: error.message });
+                            continue;
+                        }
+                        throw error;
+                    }
+                }
+            }
+            if (operation === 'download') {
+                for (let i = 0; i < length; i++) {
+                    try {
+                        const messageId = this.getNodeParameter('messageId', i);
+                        const attachmentId = this.getNodeParameter('attachmentId', i);
+                        const dataPropertyNameDownload = this.getNodeParameter('binaryPropertyName', i);
+                        // Get attachment details first
+                        const attachmentDetails = await GenericFunctions_1.microsoftApiRequest.call(this, 'GET', `/messages/${messageId}/attachments/${attachmentId}`, undefined, { $select: 'id,name,contentType' });
+                        let mimeType;
+                        if (attachmentDetails.contentType) {
+                            mimeType = attachmentDetails.contentType;
+                        }
+                        const fileName = attachmentDetails.name;
+                        const response = await GenericFunctions_1.microsoftApiRequest.call(this, 'GET', `/messages/${messageId}/attachments/${attachmentId}/$value`, undefined, {}, undefined, {}, { encoding: null, resolveWithFullResponse: true });
+                        const newItem = {
+                            json: items[i].json,
+                            binary: {},
+                        };
+                        if (items[i].binary !== undefined) {
+                            // Create a shallow copy of the binary data so that the old
+                            // data references which do not get changed still stay behind
+                            // but the incoming data does not get changed.
+                            Object.assign(newItem.binary, items[i].binary);
+                        }
+                        items[i] = newItem;
+                        const data = Buffer.from(response.body, 'utf8');
+                        items[i].binary[dataPropertyNameDownload] = await this.helpers.prepareBinaryData(data, fileName, mimeType);
+                    }
+                    catch (error) {
+                        if (this.continueOnFail()) {
+                            items[i].json = { error: error.message };
+                            continue;
+                        }
+                        throw error;
+                    }
+                }
+            }
+            if (operation === 'get') {
+                for (let i = 0; i < length; i++) {
+                    try {
+                        const messageId = this.getNodeParameter('messageId', i);
+                        const attachmentId = this.getNodeParameter('attachmentId', i);
+                        const additionalFields = this.getNodeParameter('additionalFields', i);
+                        // Have sane defaults so we don't fetch attachment data in this operation
+                        qs.$select = 'id,lastModifiedDateTime,name,contentType,size,isInline';
+                        if (additionalFields.fields) {
+                            qs.$select = additionalFields.fields;
+                        }
+                        responseData = await GenericFunctions_1.microsoftApiRequest.call(this, 'GET', `/messages/${messageId}/attachments/${attachmentId}`, undefined, qs);
+                        returnData.push(responseData);
+                    }
+                    catch (error) {
+                        if (this.continueOnFail()) {
+                            returnData.push({ error: error.message });
+                            continue;
+                        }
+                        throw error;
+                    }
+                }
+            }
+            if (operation === 'getAll') {
+                for (let i = 0; i < length; i++) {
+                    try {
+                        const messageId = this.getNodeParameter('messageId', i);
+                        const returnAll = this.getNodeParameter('returnAll', i);
+                        const additionalFields = this.getNodeParameter('additionalFields', i);
+                        // Have sane defaults so we don't fetch attachment data in this operation
+                        qs.$select = 'id,lastModifiedDateTime,name,contentType,size,isInline';
+                        if (additionalFields.fields) {
+                            qs.$select = additionalFields.fields;
+                        }
+                        if (additionalFields.filter) {
+                            qs.$filter = additionalFields.filter;
+                        }
+                        const endpoint = `/messages/${messageId}/attachments`;
+                        if (returnAll) {
+                            responseData = await GenericFunctions_1.microsoftApiRequestAllItems.call(this, 'value', 'GET', endpoint, undefined, qs);
+                        }
+                        else {
+                            qs.$top = this.getNodeParameter('limit', i);
+                            responseData = await GenericFunctions_1.microsoftApiRequest.call(this, 'GET', endpoint, undefined, qs);
+                            responseData = responseData.value;
+                        }
+                        returnData.push.apply(returnData, responseData);
+                    }
+                    catch (error) {
+                        if (this.continueOnFail()) {
+                            returnData.push({ error: error.message });
+                            continue;
+                        }
+                        throw error;
+                    }
+                }
+            }
+        }
+        if (resource === 'folder') {
+            if (operation === 'create') {
+                for (let i = 0; i < length; i++) {
+                    try {
+                        const displayName = this.getNodeParameter('displayName', i);
+                        const folderType = this.getNodeParameter('folderType', i);
+                        const body = {
+                            displayName,
+                        };
+                        let endpoint = '/mailFolders';
+                        if (folderType === 'searchFolder') {
+                            endpoint = '/mailFolders/searchfolders/childFolders';
+                            const includeNestedFolders = this.getNodeParameter('includeNestedFolders', i);
+                            const sourceFolderIds = this.getNodeParameter('sourceFolderIds', i);
+                            const filterQuery = this.getNodeParameter('filterQuery', i);
+                            Object.assign(body, {
+                                '@odata.type': 'microsoft.graph.mailSearchFolder',
+                                includeNestedFolders,
+                                sourceFolderIds,
+                                filterQuery,
+                            });
+                        }
+                        responseData = await GenericFunctions_1.microsoftApiRequest.call(this, 'POST', endpoint, body);
+                        returnData.push(responseData);
+                    }
+                    catch (error) {
+                        if (this.continueOnFail()) {
+                            returnData.push({ error: error.message });
+                            continue;
+                        }
+                        throw error;
+                    }
+                }
+            }
+            if (operation === 'delete') {
+                for (let i = 0; i < length; i++) {
+                    try {
+                        const folderId = this.getNodeParameter('folderId', i);
+                        responseData = await GenericFunctions_1.microsoftApiRequest.call(this, 'DELETE', `/mailFolders/${folderId}`);
+                        returnData.push({ success: true });
+                    }
+                    catch (error) {
+                        if (this.continueOnFail()) {
+                            returnData.push({ error: error.message });
+                            continue;
+                        }
+                        throw error;
+                    }
+                }
+            }
+            if (operation === 'get') {
+                for (let i = 0; i < length; i++) {
+                    try {
+                        const folderId = this.getNodeParameter('folderId', i);
+                        const additionalFields = this.getNodeParameter('additionalFields', i);
+                        if (additionalFields.fields) {
+                            qs.$select = additionalFields.fields;
+                        }
+                        if (additionalFields.filter) {
+                            qs.$filter = additionalFields.filter;
+                        }
+                        responseData = await GenericFunctions_1.microsoftApiRequest.call(this, 'GET', `/mailFolders/${folderId}`, {}, qs);
+                        returnData.push(responseData);
+                    }
+                    catch (error) {
+                        if (this.continueOnFail()) {
+                            returnData.push({ error: error.message });
+                            continue;
+                        }
+                        throw error;
+                    }
+                }
+            }
+            if (operation === 'getAll') {
+                for (let i = 0; i < length; i++) {
+                    try {
+                        const returnAll = this.getNodeParameter('returnAll', i);
+                        const additionalFields = this.getNodeParameter('additionalFields', i);
+                        if (additionalFields.fields) {
+                            qs.$select = additionalFields.fields;
+                        }
+                        if (additionalFields.filter) {
+                            qs.$filter = additionalFields.filter;
+                        }
+                        if (returnAll) {
+                            responseData = await GenericFunctions_1.microsoftApiRequestAllItems.call(this, 'value', 'GET', '/mailFolders', {}, qs);
+                        }
+                        else {
+                            qs.$top = this.getNodeParameter('limit', i);
+                            responseData = await GenericFunctions_1.microsoftApiRequest.call(this, 'GET', '/mailFolders', {}, qs);
+                            responseData = responseData.value;
+                        }
+                        returnData.push.apply(returnData, responseData);
+                    }
+                    catch (error) {
+                        if (this.continueOnFail()) {
+                            returnData.push({ error: error.message });
+                            continue;
+                        }
+                        throw error;
+                    }
+                }
+            }
+            if (operation === 'getChildren') {
+                for (let i = 0; i < length; i++) {
+                    try {
+                        const folderId = this.getNodeParameter('folderId', i);
+                        const returnAll = this.getNodeParameter('returnAll', i);
+                        const additionalFields = this.getNodeParameter('additionalFields', i);
+                        if (additionalFields.fields) {
+                            qs.$select = additionalFields.fields;
+                        }
+                        if (additionalFields.filter) {
+                            qs.$filter = additionalFields.filter;
+                        }
+                        if (returnAll) {
+                            responseData = await GenericFunctions_1.microsoftApiRequestAllItems.call(this, 'value', 'GET', `/mailFolders/${folderId}/childFolders`, qs);
+                        }
+                        else {
+                            qs.$top = this.getNodeParameter('limit', i);
+                            responseData = await GenericFunctions_1.microsoftApiRequest.call(this, 'GET', `/mailFolders/${folderId}/childFolders`, undefined, qs);
+                            responseData = responseData.value;
+                        }
+                        returnData.push.apply(returnData, responseData);
+                    }
+                    catch (error) {
+                        if (this.continueOnFail()) {
+                            returnData.push({ error: error.message });
+                            continue;
+                        }
+                        throw error;
+                    }
+                }
+            }
+            if (operation === 'update') {
+                for (let i = 0; i < length; i++) {
+                    try {
+                        const folderId = this.getNodeParameter('folderId', i);
+                        const updateFields = this.getNodeParameter('updateFields', i);
+                        const body = {
+                            ...updateFields,
+                        };
+                        responseData = await GenericFunctions_1.microsoftApiRequest.call(this, 'PATCH', `/mailFolders/${folderId}`, body);
+                        returnData.push(responseData);
+                    }
+                    catch (error) {
+                        if (this.continueOnFail()) {
+                            returnData.push({ error: error.message });
+                            continue;
+                        }
+                        throw error;
+                    }
+                }
+            }
+        }
+        if (resource === 'folderMessage') {
+            for (let i = 0; i < length; i++) {
+                try {
+                    if (operation === 'getAll') {
+                        const folderId = this.getNodeParameter('folderId', i);
+                        const returnAll = this.getNodeParameter('returnAll', i);
+                        const additionalFields = this.getNodeParameter('additionalFields', i);
+                        if (additionalFields.fields) {
+                            qs.$select = additionalFields.fields;
+                        }
+                        if (additionalFields.filter) {
+                            qs.$filter = additionalFields.filter;
+                        }
+                        const endpoint = `/mailFolders/${folderId}/messages`;
+                        if (returnAll) {
+                            responseData = await GenericFunctions_1.microsoftApiRequestAllItems.call(this, 'value', 'GET', endpoint, qs);
+                        }
+                        else {
+                            qs.$top = this.getNodeParameter('limit', i);
+                            responseData = await GenericFunctions_1.microsoftApiRequest.call(this, 'GET', endpoint, undefined, qs);
+                            responseData = responseData.value;
+                        }
+                        returnData.push.apply(returnData, responseData);
+                    }
+                }
+                catch (error) {
+                    if (this.continueOnFail()) {
+                        returnData.push({ error: error.message });
+                        continue;
+                    }
+                    throw error;
+                }
+            }
+        }
+        if ((resource === 'message' && operation === 'getMime') ||
+            (resource === 'messageAttachment' && operation === 'download')) {
+            return [items];
+        }
+        else {
+            return [this.helpers.returnJsonArray(returnData)];
+        }
+    }
+}
+exports.MicrosoftOutlookV1 = MicrosoftOutlookV1;
+//# sourceMappingURL=MicrosoftOutlookV1.node.js.map