Initial commit to release

packages/nodes-base/nodes/EmailReadImap.node.ts

@@ -0,0 +1,261 @@
+import { ITriggerFunctions } from 'n8n-core';
+import {
+	IBinaryData,
+	IDataObject,
+	INodeExecutionData,
+	INodeType,
+	INodeTypeDescription,
+	ITriggerResponse,
+} from 'n8n-workflow';
+
+import { connect as imapConnect, ImapSimple, getParts, Message }  from 'imap-simple';
+
+export class EmailReadImap implements INodeType {
+	description: INodeTypeDescription = {
+		displayName: 'EmailReadImap',
+		name: 'emailReadImap',
+		icon: 'fa:inbox',
+		group: ['trigger'],
+		version: 1,
+		description: 'Triggers the workflow when a new email gets received',
+		defaults: {
+			name: 'IMAP Email',
+			color: '#44AA22',
+		},
+		inputs: [],
+		outputs: ['main'],
+		credentials: [
+			{
+				name: 'imap',
+				required: true,
+			}
+		],
+		properties: [
+			{
+				displayName: 'Mailbox Name',
+				name: 'mailbox',
+				type: 'string',
+				default: 'INBOX',
+			},
+			{
+				displayName: 'Action',
+				name: 'postProcessAction',
+				type: 'options',
+				options: [
+					{
+						name: 'Mark as read',
+						value: 'read'
+					},
+					{
+						name: 'Nothing',
+						value: 'nothing'
+					},
+				],
+				default: 'read',
+				description: 'What to do after the email has been received. If "nothing" gets<br />selected it will be processed multiple times.',
+			},
+			{
+				displayName: 'Download Attachments',
+				name: 'downloadAttachments',
+				type: 'boolean',
+				default: false,
+				description: 'If attachments of emails should be downloaded.<br />Only set if needed as it increases processing.',
+			},
+			{
+				displayName: 'Property Prefix Name',
+				name: 'dataPropertyAttachmentsPrefixName',
+				type: 'string',
+				default: 'attachment_',
+				displayOptions: {
+					show: {
+						downloadAttachments: [
+							'true'
+						],
+					},
+				},
+				description: 'Prefix for name of the binary property to which to<br />write the attachments. An index starting with 0 will be added.<br />So if name is "attachment_" the first attachment is saved to "attachment_0"',
+			},
+		],
+	};
+
+
+
+	async trigger(this: ITriggerFunctions): Promise<ITriggerResponse> {
+		let isFirstRun = true;
+
+		const credentials = this.getCredentials('imap');
+
+		if (credentials === undefined) {
+			throw new Error('No credentials got returned!');
+		}
+
+		const mailbox = this.getNodeParameter('mailbox') as string;
+		const dataPropertyAttachmentsPrefixName = this.getNodeParameter('dataPropertyAttachmentsPrefixName') as string;
+		const postProcessAction = this.getNodeParameter('postProcessAction') as string;
+		const downloadAttachments = this.getNodeParameter('downloadAttachments') as boolean;
+
+
+		// Returns the email text
+		const getText = async (parts: any[], message: Message, subtype: string) => { // tslint:disable-line:no-any
+			if (!message.attributes.struct) {
+				return '';
+			}
+
+			const textParts = parts.filter((part) => {
+				return part.type.toUpperCase() === 'TEXT' && part.subtype.toUpperCase() === subtype.toUpperCase();
+			});
+
+			if (textParts.length === 0) {
+				return '';
+			}
+
+			return await connection.getPartData(message, textParts[0]);
+		};
+
+
+		// Returns the email attachments
+		const getAttachment = async (connection: ImapSimple, parts: any[], message: Message): Promise<IBinaryData[]> => { // tslint:disable-line:no-any
+			if (!message.attributes.struct) {
+				return [];
+			}
+
+			// Check if the message has attachments and if so get them
+			const attachmentParts = parts.filter((part) => {
+				return part.disposition && part.disposition.type.toUpperCase() === 'ATTACHMENT';
+			});
+
+			const attachmentPromises = [];
+			let attachmentPromise;
+			for (const attachmentPart of attachmentParts) {
+				attachmentPromise = connection.getPartData(message, attachmentPart)
+					.then((partData) => {
+						// Return it in the format n8n expects
+						return this.helpers.prepareBinaryData(partData, attachmentPart.disposition.params.filename);
+					});
+
+				attachmentPromises.push(attachmentPromise);
+			}
+
+			return Promise.all(attachmentPromises);
+		};
+
+
+		// Returns all the new unseen messages
+		const getNewEmails = async (connection: ImapSimple): Promise<INodeExecutionData[]> => {
+
+			const searchCriteria = [
+				'UNSEEN'
+			];
+
+			const fetchOptions = {
+				bodies: ['HEADER', 'TEXT'],
+				markSeen: postProcessAction === 'read',
+				struct: true,
+			};
+
+			const results = await connection.search(searchCriteria, fetchOptions);
+
+			const newEmails: INodeExecutionData[] = [];
+			let newEmail: INodeExecutionData, messageHeader, messageBody;
+			let attachments: IBinaryData[];
+			let propertyName: string;
+
+			// All properties get by default moved to metadata except the ones
+			// which are defined here which get set on the top level.
+			const topLevelProperties = [
+				'cc',
+				'date',
+				'from',
+				'subject',
+				'to',
+			];
+			for (const message of results) {
+
+				const parts = getParts(message.attributes.struct!);
+
+				newEmail = {
+					json: {
+						textHtml: await getText(parts, message, 'html'),
+						textPlain: await getText(parts, message, 'plain'),
+						metadata: {} as IDataObject,
+					}
+				};
+
+				messageHeader = message.parts.filter((part) => {
+					return part.which === 'HEADER';
+				});
+
+				messageBody = messageHeader[0].body;
+				for (propertyName of Object.keys(messageBody)) {
+					if (messageBody[propertyName].length) {
+						if (topLevelProperties.includes(propertyName)) {
+							newEmail.json[propertyName] = messageBody[propertyName][0];
+						} else {
+							(newEmail.json.metadata as IDataObject)[propertyName] = messageBody[propertyName][0];
+						}
+					}
+				}
+
+				if (downloadAttachments === true) {
+					// Get attachments and add them if any get found
+					attachments = await getAttachment(connection, parts, message);
+					if (attachments.length) {
+						newEmail.binary = {};
+						for (let i = 0; i < attachments.length; i++) {
+							newEmail.binary[`${dataPropertyAttachmentsPrefixName}${i}`] = attachments[i];
+						}
+					}
+				}
+
+				newEmails.push(newEmail);
+			}
+
+			return newEmails;
+		};
+
+
+
+		let connection: ImapSimple;
+
+		const config = {
+			imap: {
+				user: credentials.user as string,
+				password: credentials.password as string,
+				host: credentials.host as string,
+				port: credentials.port as number,
+				tls: credentials.secure as boolean,
+				authTimeout: 3000
+			},
+			onmail: async () => {
+				const returnData = await getNewEmails(connection);
+
+				if (returnData.length) {
+					this.emit([returnData]);
+				} else if (isFirstRun === true && this.getMode() === 'manual') {
+					// If it is the first run we emit even when it is empty. If we would
+					// not do that it would wait till the first unread email arrives
+					// before it would continue to execute the next node.
+					this.emit([]);
+				}
+
+				isFirstRun = false;
+			},
+		};
+
+		// Connect to the IMAP server and open the mailbox
+		// that we get informed whenever a new email arrives
+		connection = await imapConnect(config);
+		await connection.openBox(mailbox);
+
+
+		// When workflow and so node gets set to inactive close the connectoin
+		async function closeFunction() {
+			await connection.end();
+		}
+
+		return {
+			closeFunction,
+		};
+
+	}
+}