@5minds/node-red-contrib-processcube-tools 1.0.1-develop-b4cfca-mfdomgtt → 1.0.1-develop-c7d5e6-mfffb5w1

package/email-receiver/email-receiver.html

@@ -0,0 +1,187 @@
+<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,236 @@
+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" }
+        }
+    });
+};

package/package.json

@@ -1,10 +1,11 @@
 {
     "name": "@5minds/node-red-contrib-processcube-tools",
-    "version": "1.0.1-develop-b4cfca-mfdomgtt",
+    "version": "1.0.1-develop-c7d5e6-mfffb5w1",
     "license": "MIT",
     "description": "Node-RED tools nodes for ProcessCube",
     "scripts": {
-        "lint": "prettier --write --config ./.prettierrc.json \"**/*.{html,js}\""
+        "lint": "prettier --write --config ./.prettierrc.json \"**/*.{html,js}\"",
+        "test": "mocha test/unit/ test/integration"
     },
     "authors": [
         {
@@ -14,6 +15,10 @@
         {
             "name": "Robin Lenz",
             "email": "Robin.Lenz@5Minds.de"
+        },
+        {
+            "name": "Diana Stefan",
+            "email": "Diana.Stefan@5Minds.de"
         }
     ],
     "repository": {
@@ -31,12 +36,27 @@
     "node-red": {
         "version": ">=3.1.9",
         "nodes": {
+            "EmailReceiver": "email-receiver/email-receiver.js",
             "HtmlToText": "processcube-html-to-text.js"
         },
         "examples": "examples"
     },
     "dependencies": {
-        "html-to-text": "^9.0.5"
+        "html-to-text": "^9.0.5",
+        "mailparser": "^3.6.8",
+        "node-imap": "^0.9.6",
+        "utf7": "^1.0.2"
+    },
+    "devDependencies": {
+        "chai": "^4.3.4",
+        "mocha": "^11.7.2",
+        "node-red": "^4.1.0",
+        "node-red-node-test-helper": "^0.3.5",
+        "should": "^13.2.3",
+        "sinon": "^11.1.2"
+    },
+    "overrides": {
+        "semver": ">=7.5.2"
     },
     "keywords": [
         "node-red",