@5minds/node-red-contrib-processcube-tools 1.0.1 → 1.0.2-develop-e3d5d9-mfm8oea8

package/.env.template

@@ -0,0 +1,4 @@
+EMAIL_SEND_PORT=
+EMAIL_SEND_HOST=
+EMAIL_SEND_USER=
+EMAIL_SEND_PASSWORD=

package/README.md

@@ -1,5 +1,5 @@
 # Some Nodes to efficent with the ProcessCube LowCode component (Node-RED)
 
-This repository contains some nodes to efficent with the ProcessCube LowCode component (Node-RED).
+This repository contains nodes for working efficiently with the ProcessCube Low-Code component (Node-RED).
 
 Details see @ [ProcessCub.io - LowCode Integration Nodes](https://processcube.io/docs/node-red/integration-nodes) and [ProcessCub.io - LowCode Event Nodes](https://processcube.io/docs/node-red/event-nodes).

package/email-receiver/email-receiver.html

@@ -0,0 +1,219 @@
+<script type="text/javascript">
+    RED.nodes.registerType('email-receiver', {
+        category: 'ProcessCube Tools',
+        color: '#02AFD6',
+        defaults: {
+            name: { value: '' },
+            host: { value: '', required: true, validate: RED.validators.typedInput('hostType') },
+            hostType: { value: 'str' },
+            port: { value: '', required: true, validate: RED.validators.typedInput('portType') },
+            portType: { value: 'num' },
+            tls: { value: true, required: true, validate: RED.validators.typedInput('tlsType') },
+            tlsType: { value: 'bool' },
+            user: { value: '', required: true, validate: RED.validators.typedInput('userType') },
+            userType: { value: 'str' },
+            password: { value: '', required: true, type: 'password' },
+            passwordType: { value: 'env', required: true },
+            folder: { value: '', required: true, validate: RED.validators.typedInput('folderType') },
+            folderType: { value: 'json' },
+            markseen: { value: true, validate: RED.validators.typedInput('markseenType') },
+            markseenType: { value: 'bool' },
+        },
+        inputs: 1,
+        outputs: 1,
+        icon: 'font-awesome/fa-inbox',
+        label: function () {
+            return this.name || 'E-Mail Receiver';
+        },
+        oneditprepare: function () {
+            $('#node-input-host').typedInput({
+                default: 'str',
+                types: ['str', 'msg', 'flow', 'global', 'env'],
+                typeField: '#node-input-hostType',
+            });
+
+            $('#node-input-port').typedInput({
+                default: 'num',
+                types: ['num', 'msg', 'flow', 'global', 'env'],
+                typeField: '#node-input-portType',
+            });
+
+            $('#node-input-tls').typedInput({
+                default: 'bool',
+                types: ['bool', 'msg', 'flow', 'global', 'env'],
+                typeField: '#node-input-tlsType',
+            });
+
+            $('#node-input-user').typedInput({
+                default: 'str',
+                types: ['str', 'msg', 'flow', 'global', 'env'],
+                typeField: '#node-input-userType',
+            });
+
+            $('#node-input-password').typedInput({
+                default: 'env',
+                types: ['msg', 'flow', 'global', 'env'],
+                typeField: '#node-input-passwordType',
+            });
+
+            $('#node-input-folder').typedInput({
+                default: 'json',
+                types: ['msg', 'flow', 'global', 'json', 'jsonata', 'env'],
+                typeField: '#node-input-folderType',
+            });
+
+            $('#node-input-markseen').typedInput({
+                default: 'bool',
+                types: ['bool', 'msg', 'flow', 'global', 'env'],
+                typeField: '#node-input-markseenType',
+            });
+        },
+    });
+</script>
+
+<script type="text/html" data-template-name="email-receiver">
+    <div class="form-row">
+        <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
+        <input type="text" id="node-input-name" placeholder="Name" />
+    </div>
+
+    <div class="form-row">
+        <label for="node-input-host"><i class="fa fa-server"></i> IMAP Host</label>
+        <input type="text" id="node-input-host" placeholder="imap.gmail.com" />
+        <input type="hidden" id="node-input-hostType" />
+    </div>
+
+    <div class="form-row">
+        <label for="node-input-port"><i class="fa fa-terminal"></i> Port</label>
+        <input type="text" id="node-input-port" placeholder="993" />
+        <input type="hidden" id="node-input-portType" />
+    </div>
+
+    <div class="form-row">
+        <label for="node-input-tls"><i class="fa fa-lock"></i> Use TLS</label>
+        <input type="text" id="node-input-tls" />
+        <input type="hidden" id="node-input-tlsType" />
+    </div>
+
+    <div class="form-row">
+        <label for="node-input-user"><i class="fa fa-user"></i> User</label>
+        <input type="text" id="node-input-user" />
+        <input type="hidden" id="node-input-userType" />
+    </div>
+
+    <div class="form-row">
+        <label for="node-input-password"><i class="fa fa-key"></i> Password</label>
+        <input type="text" id="node-input-password" />
+        <input type="hidden" id="node-input-passwordType" />
+    </div>
+
+    <div class="form-row">
+        <label for="node-input-folder"><i class="fa fa-folder-open"></i> Folder(s)</label>
+        <input type="text" id="node-input-folder" placeholder="[INBOX]" />
+        <input type="hidden" id="node-input-folderType" />
+    </div>
+
+    <div class="form-row">
+        <label for="node-input-markseen"><i class="fa fa-eye"></i> Mark as seen</label>
+        <input type="text" id="node-input-markseen" />
+        <input type="hidden" id="node-input-markseenType" />
+    </div>
+</script>
+
+<script type="text/html" data-help-name="email-receiver">
+    <p>
+        A Node-RED node that fetches unseen emails from a specified IMAP server. Each fetched email is sent as a
+        separate message on the output.
+    </p>
+
+    <p>
+        All fields can be configured as a <strong>string</strong>, from a <strong>message property (msg)</strong>,
+        <strong>flow</strong> or <strong>global</strong> context, or an <strong>environment variable</strong>.
+    </p>
+
+    <p>
+        <strong>Security Tip:</strong> It's a best practice to avoid storing sensitive information like passwords
+        directly in your Node-RED flow. This prevents them from being exposed in your flow file. Instead, use an
+        <strong>environment variable</strong>. You can define these variables in a <code>.env</code> file, which is
+        especially useful when deploying your application with Docker.
+    </p>
+
+    <p>A <code>.env</code> file should look like this:</p>
+    <pre>
+    EMAIL_SEND_PORT=123
+    EMAIL_SEND_HOST=smtp.gmail.com
+    EMAIL_SEND_USER=myTestMail@company.com
+    EMAIL_SEND_PASSWORD=mySecretPassword
+    </pre
+    >
+
+    <p>
+        To ensure Docker loads these variables from the <code>.env</code> file, you need to add the following line to
+        your <code>docker-compose.yaml</code> file:
+    </p>
+    <pre>
+    services:
+    your_service_name:
+    ...
+    env_file:
+    - .env
+    </pre
+    >
+
+    <p>
+        In your flow, you can then access the password using the environment variable <code>EMAIL_SEND_PASSWORD</code>.
+    </p>
+
+    Inputs
+    <dl class="message-properties">
+        <dt>payload</dt>
+        <dd>
+            The node is triggered by any incoming message. The node's configuration can be overridden by properties of
+            the incoming <code>msg</code> object.
+        </dd>
+    </dl>
+
+    Outputs
+    <dl class="message-properties">
+        <dt>
+            payload
+            <span class="property-type">string</span>
+        </dt>
+        <dd>The text body of the email.</dd>
+    </dl>
+
+    Optional Message Properties
+    <p>
+        You can override default settings by passing the following properties in the incoming <code>msg</code> object:
+    </p>
+    <dl class="message-properties">
+        <dt>
+            msg.imap_connTimeout
+            <span class="property-type">number</span>
+        </dt>
+        <dd>The connection timeout in milliseconds (default: 10000).</dd>
+        <dt>
+            msg.imap_authTimeout
+            <span class="property-type">number</span>
+        </dt>
+        <dd>The authentication timeout in milliseconds (default: 5000).</dd>
+        <dt>
+            msg.imap_keepalive
+            <span class="property-type">boolean</span>
+        </dt>
+        <dd>
+            If set to <code>true</code>, a periodic NOOP command is sent to keep the connection alive (default:
+            <code>true</code>).
+        </dd>
+        <dt>
+            msg.imap_autotls
+            <span class="property-type">string</span>
+        </dt>
+        <dd>Controls STARTTLS behavior. Set to <code>never</code> to disable it (default: <code>never</code>).</dd>
+        <dt>
+            msg.imap_tlsOptions
+            <span class="property-type">object</span>
+        </dt>
+        <dd>An object containing TLS options for the connection.</dd>
+    </dl>
+</script>

package/email-receiver/email-receiver.js

@@ -0,0 +1,250 @@
+module.exports = function (RED) {
+    const Imap = require('node-imap');
+    const mailparser = require('mailparser');
+
+    function EmailReceiverNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        node.on('input', function (msg) {
+            // Retrieve and validate configuration values
+            const imap_host = RED.util.evaluateNodeProperty(config.host, config.hostType, node, msg);
+            const imap_port = RED.util.evaluateNodeProperty(config.port, config.portType, node, msg);
+            const imap_tls = RED.util.evaluateNodeProperty(config.tls, config.tlsType, node, msg);
+            const imap_user = RED.util.evaluateNodeProperty(config.user, config.userType, node, msg);
+            const imap_password = RED.util.evaluateNodeProperty(config.password, config.passwordType, node, msg);
+
+            // Check if the folder is actually an array
+            const imap_folder = RED.util.evaluateNodeProperty(config.folder, config.folderType, node, msg);
+            let folders;
+            if (Array.isArray(imap_folder)) {
+                folders = imap_folder;
+            } else {
+                const errorMsg = "The 'folders' property must be an array of strings.";
+                node.status({ fill: 'red', shape: 'ring', text: errorMsg });
+                node.error(errorMsg, msg);
+                return;
+            }
+            const imap_markSeen = RED.util.evaluateNodeProperty(config.markseen, config.markseenType, node, msg);
+
+            const finalConfig = {
+                host: imap_host,
+                port: typeof imap_port === 'string' ? parseInt(imap_port, 10) : imap_port,
+                tls: imap_tls,
+                user: imap_user,
+                password: imap_password,
+                folders: Array.isArray(imap_folder)
+                    ? imap_folder
+                    : imap_folder
+                          .split(',')
+                          .map((f) => f.trim())
+                          .filter((f) => f.length > 0),
+                markSeen: imap_markSeen,
+                connTimeout: msg.imap_connTimeout || 10000,
+                authTimeout: msg.imap_authTimeout || 5000,
+                keepalive: msg.imap_keepalive !== undefined ? msg.imap_keepalive : true,
+                autotls: msg.imap_autotls || 'never',
+                tlsOptions: msg.imap_tlsOptions || { rejectUnauthorized: false },
+            };
+
+            if (
+                !finalConfig.user ||
+                !finalConfig.password ||
+                !finalConfig.port ||
+                !finalConfig.host ||
+                !finalConfig.folders
+            ) {
+                const missingFields = [];
+                if (!finalConfig.user) missingFields.push('user');
+                if (!finalConfig.password) missingFields.push('password');
+                if (!finalConfig.port) missingFields.push('port');
+                if (!finalConfig.host) missingFields.push('host');
+                if (!finalConfig.folders) missingFields.push('folders');
+
+                const errorMessage = `Missing required IMAP config: ${missingFields.join(', ')}. Aborting.`;
+                node.status({ fill: 'red', shape: 'ring', text: 'missing config' });
+                node.error(errorMessage);
+                return;
+            }
+
+            const fetchEmails = (
+                {
+                    host,
+                    port,
+                    tls,
+                    user,
+                    password,
+                    folders,
+                    markSeen = true,
+                    connTimeout = 10000,
+                    authTimeout = 5000,
+                    keepalive = true,
+                    autotls = 'never',
+                    tlsOptions = { rejectUnauthorized: false },
+                },
+                onMail,
+            ) => {
+                const imap = new Imap({
+                    user,
+                    password,
+                    host,
+                    port,
+                    tls,
+                    connTimeout,
+                    authTimeout,
+                    keepalive,
+                    autotls,
+                    tlsOptions,
+                });
+
+                const state = {
+                    totalFolders: folders.length,
+                    processedFolders: 0,
+                    successes: 0,
+                    failures: 0,
+                    totalMails: 0,
+                    errors: [],
+                };
+
+                // Helper to update Node-RED status
+                const updateStatus = (color, text) => {
+                    node.status({ fill: color, shape: 'dot', text });
+                };
+
+                // Helper to finalize status and clean up
+                const finalizeSession = (error = null) => {
+                    if (error) {
+                        node.error('IMAP session terminated: ' + error.message);
+                        node.status({ fill: 'red', shape: 'ring', text: 'connection error' });
+                    } else if (state.failures > 0) {
+                        node.status({
+                            fill: 'red',
+                            shape: 'dot',
+                            text: `Done, ${state.totalMails} mails from ${state.successes}/${state.totalFolders} folders. ${state.failures} failed.`,
+                        });
+                    } else {
+                        node.status({
+                            fill: 'green',
+                            shape: 'dot',
+                            text: `Done, fetched ${state.totalMails} mails from ${folders.join(', ')}.`,
+                        });
+                    }
+                    if (imap && imap.state !== 'disconnected') {
+                        imap.end();
+                    }
+                };
+
+                const fetchFromFolder = (folder) => {
+                    updateStatus('yellow', `Fetching from "${folder}"...`);
+
+                    imap.openBox(folder, false, (err, box) => {
+                        if (err) {
+                            node.error(`Could not open folder "${folder}": ${err.message}`);
+                            state.failures++;
+                            state.processedFolders++;
+                            return startNextFolder();
+                        }
+
+                        imap.search(['UNSEEN'], (err, results) => {
+                            if (err) {
+                                node.error(`Search failed in folder "${folder}": ${err.message}`);
+                                state.failures++;
+                                state.processedFolders++;
+                                return startNextFolder();
+                            }
+
+                            if (!results || !results.length) {
+                                state.successes++;
+                                state.processedFolders++;
+                                return startNextFolder();
+                            }
+
+                            state.totalMails += results.length;
+
+                            const fetch = imap.fetch(results, { bodies: '' });
+
+                            fetch.on('message', (msg) => {
+                                msg.on('body', (stream) => {
+                                    mailparser.simpleParser(stream, (err, parsed) => {
+                                        if (err) {
+                                            node.error(`Parse error for email from folder "${folder}": ${err.message}`);
+                                            return;
+                                        }
+
+                                        const outMsg = {
+                                            topic: parsed.subject,
+                                            payload: parsed.text,
+                                            html: parsed.html,
+                                            from: parsed.replyTo?.text || parsed.from?.text,
+                                            date: parsed.date,
+                                            folder,
+                                            header: parsed.headers,
+                                            attachments: parsed.attachments.map((att) => ({
+                                                contentType: att.contentType,
+                                                fileName: att.filename,
+                                                transferEncoding: att.transferEncoding,
+                                                contentDisposition: att.contentDisposition,
+                                                generatedFileName: att.cid || att.checksum,
+                                                contentId: att.cid,
+                                                checksum: att.checksum,
+                                                length: att.size,
+                                                content: att.content,
+                                            })),
+                                        };
+                                        onMail(outMsg);
+                                    });
+                                });
+                            });
+
+                            fetch.once('error', (err) => {
+                                node.error(`Fetch error in folder "${folder}": ${err.message}`);
+                            });
+
+                            fetch.once('end', () => {
+                                state.successes++;
+                                state.processedFolders++;
+                                updateStatus('green', `Fetched ${results.length} from "${folder}".`);
+                                startNextFolder();
+                            });
+                        });
+                    });
+                };
+
+                const startNextFolder = () => {
+                    if (state.processedFolders >= state.totalFolders) {
+                        finalizeSession();
+                    } else {
+                        fetchFromFolder(folders[state.processedFolders]);
+                    }
+                };
+
+                // Centralized event listeners for the IMAP connection
+                imap.once('ready', () => {
+                    node.status({ fill: 'green', shape: 'dot', text: 'connected' });
+                    startNextFolder();
+                });
+
+                imap.once('error', (err) => {
+                    finalizeSession(err);
+                });
+
+                imap.once('end', () => {
+                    node.log('IMAP connection ended.');
+                });
+
+                updateStatus('yellow', 'Connecting to IMAP...');
+                imap.connect();
+            };
+
+            fetchEmails(finalConfig, (mail) => {
+                node.send(mail);
+            });
+        });
+    }
+
+    RED.nodes.registerType('email-receiver', EmailReceiverNode, {
+        credentials: {
+            password: { type: 'password' },
+        },
+    });
+};