@hyperbytes/wappler-imap-manager 1.0.4 → 1.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@hyperbytes/wappler-imap-manager",
-    "version": "1.0.4",
+    "version": "1.0.6",
     "description": "IMAP eMail Management for Wappler",
     "license": "MIT",
     "author": {
@@ -10,13 +10,17 @@
         "wappler-extension",
         "server-connect",
         "IMAP",
-        "email"
+        "email",
+        "wappler",
+        "node"
     ],
     "dependencies": {
         "imap": "^0.8.0",
         "mailparser": "^3.7.2",
         "imap-simple": "^5.1.0",
         "mailtrap": "^4.1.0",
-        "mailcomposer": "^1.0.0"
+        "mailcomposer": "^1.0.0",
+        "mime-types": "^3.0.1",
+        "mime-db": "^1.54.0"
     }
 }

package/server_connect/modules/imapgetattachments.hjson

@@ -10,23 +10,23 @@ groupIcon : 'fas fa-envelope comp-general',
   usedModules : {
     node: {
       'imap' : '^0.8.19',
-       'mailparser' : '^3.7.2'
+       'mailparser' : '^3.7.2',
+              'mime-lookup' : '^0.0.2',
+        'mime-db' : '^1.54.0'
     }
       },
   dataScheme:[
-        {name: 'savedFiles', type:'array', sub:[
-                  {name: '$value', type:'text'}
-        ]},
-        {name: 'message', type:'text'},
+    {name: 'status', type:'number'},
         {name: 'url', type:'text'},
         {name: 'path', type:'text'},
-        {name: 'status', type:'text'},
-                      {name: 'pathschema', type:'array', sub:[
-              {name: '$value', type:'text'}
+        {name: 'uploads', type:'file', sub:[
+            {name: 'name', type:'text'},
+            {name: 'path', type:'text'},
+            {name: 'url', type:'text'},
+            {name: 'type', type:'text'},
+            {name: 'size', type:'number'}
         ]},
-             {name: 'systempath', type:'array', sub:[
-                  {name: '$value', type:'text'}
-        ]}
+             
       ],
 
 

package/server_connect/modules/imapgetattachments.js

@@ -3,6 +3,9 @@ const fs = require('fs');
 const { simpleParser } = require('mailparser');
 const path = require('path');
 const { toSystemPath } = require("../../../lib/core/path");
+const mime = require('mime-types');
+const mimeDb = require('mime-db');
+
 
 exports.imapgetattachments = async function (options, name) {
     const IMAP_USER = process.env.IMAP_USER;
@@ -15,8 +18,8 @@ exports.imapgetattachments = async function (options, name) {
     const mailbox = this.parseRequired(options.mailbox, '*', "No mailbox specified");
     let sentPath = this.parseRequired(options.path, '*', 'No path Specified');
     const returnPath = sentPath.split('/').slice(2).join('/');
-    savePath = toSystemPath(sentPath);
-
+    //savePath = toSystemPath(sentPath);
+    savePath = sentPath;
     // Ensure the directory exists or create it
     if (!fs.existsSync(savePath)) {
         fs.mkdirSync(savePath, { recursive: true });
@@ -68,17 +71,39 @@ exports.imapgetattachments = async function (options, name) {
                                     console.log(`Saved attachment: ${filePath}`);
                                 });
                                 const savedFilesExt = [];
-                                const savedFilesSystem = []
+
                                 parsed.attachments.forEach(att => {
                                     const filePath = path.join(savePath, att.filename);
+                                    // Replace backslashes with forward slashes
+                                    let correctedPath = filePath.replace(/\\/g, "/");
+                                    // Remove the "public" prefix
+                                    correctedPathURL = correctedPath.replace(/^\/?public\//, "/");
+
+
                                     fs.writeFileSync(filePath, att.content);
-                                    savedFilesExt.push(sentPath + att.filename);
-                                    savedFilesSystem.push(toSystemPath(sentPath + att.filename));
-                                    console.log(`Saved attachment Extemded: ${filePath}`);
+                                    let mimetype = mime.lookup(att.filename)
+                                    const fs2 = require('fs');
+
+                                    //const filePath = 'example.txt';
+                                    const stats = fs2.statSync(filePath);
+                                    console.log(`File size: ${stats.size} bytes`);
+                                    savedFilesExt.push({
+                                        name: att.filename,
+                                        path: correctedPath,
+                                        url: correctedPathURL,
+                                        type: mimetype,
+                                        size: stats.size
+
+                                    });
+
+                                    console.log(`Saved attachment Extended: ${filePath}`);
                                 });
 
+                                // Output JSON
+                                console.log(JSON.stringify(savedFilesExt, null, 2));
+
                                 imap.end();
-                                resolve({ savedFiles, message: savedFiles.join(", "), url: returnPath, path: sentPath, status: 200, pathschema: savedFilesExt, systemschema: savedFilesSystem });
+                                resolve({ status: 200, url: returnPath, path: sentPath, uploads: savedFilesExt });
 
                             } catch (parseError) {
                                 imap.end();

package/server_connect/modules/imapmailcontent.js

@@ -1,6 +1,7 @@
 const Imap = require('imap');
 const { simpleParser } = require('mailparser');
 
+
 exports.imapmailcontent = async function (options, name) {
     return new Promise((resolve, reject) => {
         const IMAP_USER = process.env.IMAP_USER;

package/server_connect/modules/imapsaveasdraft-copy.js

@@ -0,0 +1,184 @@
+const Imap = require('imap-simple');
+const nodemailer = require('nodemailer');
+const mailcomposer = require('mailcomposer');
+const { simpleParser } = require('mailparser'); // Used for debugging email content
+
+exports.imapsaveasdraft = async function (options) {
+    console.log('Starting IMAP draft save process...');
+
+    // Parse IMAP configuration
+    const IMAP_HOST = this.parseOptional(options.imap_host, '*', process.env.IMAP_HOST);
+    const IMAP_PASSWORD = this.parseOptional(options.imap_password, '*', process.env.IMAP_PASSWORD);
+    const IMAP_USER = this.parseOptional(options.imap_user, '*', process.env.IMAP_USER);
+    const IMAP_PORT = this.parseOptional(options.imap_port, '*', process.env.IMAP_PORT);
+    const imap_tlsstring = this.parseOptional(options.imap_tls, '*', process.env.IMAP_TLS).toLowerCase();
+    const IMAP_TLS = (imap_tlsstring === 'true');
+
+    // Validate essential IMAP configuration
+    if (!IMAP_HOST || !IMAP_USER || !IMAP_PASSWORD) {
+        console.error('IMAP host, user, or password not configured.');
+        return {
+            status: 401,
+            message: 'IMAP configuration incomplete.',
+            error: 'IMAP host, user, or password not configured.',
+            uid: '',
+            folder: this.parseOptional(options.mailbox, '*', 'Drafts')
+        };
+    }
+
+    // Parse email details
+    const to = this.parseOptional(options.to, "*", "");
+    console.log('To: ' + to);
+    const mailfrom = this.parseOptional(options.from, "*", "");
+    console.log('From: ' + mailfrom);
+    const cc = this.parseOptional(options.cc, "*", "");
+    console.log('CC: ' + cc);
+    const bcc = this.parseOptional(options.bcc, "*", "");
+    console.log('BCC: ' + bcc);
+    const subject = this.parseOptional(options.mailsubject, "*", "default subject");
+    console.log('Subject: ' + subject);
+    const body = this.parseOptional(options.body, "*", ""); // Assuming this is HTML body
+    console.log('Body: ' + body);
+    const attachments = this.parseOptional(options.attachments, '*', []);
+    console.log('Attachments: ' + attachments);
+    let folder = this.parseOptional(options.mailbox, '*', 'Drafts'); // Default to 'Drafts'
+    console.log('Folder: ' + folder);
+
+    // Check if a UID is provided – meaning the draft is to be updated
+    const providedUid = this.parseOptional(options.uid, "*", "");
+    console.log('UID: ' + providedUid);
+    console.log(`Attempting to save draft to folder: ${folder}`);
+
+    const imapConfig = {
+        imap: {
+            user: IMAP_USER,
+            password: IMAP_PASSWORD,
+            host: IMAP_HOST,
+            port: IMAP_PORT,
+            tls: IMAP_TLS,
+            tlsOptions: { rejectUnauthorized: false },
+            authTimeout: 5000
+        }
+    };
+
+    let connection;
+
+    try {
+        // 1. Construct the email message using mailcomposer
+        const mailOptions = {
+            from: mailfrom,
+            to: to,
+            cc: cc,
+            bcc: bcc,
+            subject: subject,
+            html: body, // Use 'text' if it's plain text
+            attachments: attachments
+        };
+
+        const mail = mailcomposer(mailOptions);
+
+        const rawEmail = await new Promise((resolve, reject) => {
+            mail.build((err, message) => {
+                if (err) {
+                    console.error('Error building email:', err);
+                    return {
+                        status: 400,
+                        message: 'Error building email.',
+                        uid: '',
+                        folder: folder
+                    };
+                }
+                resolve(message);
+            });
+        });
+
+        console.log('Raw email constructed.');
+
+        // Debug: Parse the raw email to verify its content
+        const parsedEmail = await simpleParser(rawEmail);
+        console.log('Parsed Email Content:', {
+            subject: parsedEmail.subject,
+            text: parsedEmail.text,
+            html: parsedEmail.html,
+            headers: parsedEmail.headers
+        });
+
+        // 2. Connect to IMAP server
+        console.log(`Connecting to IMAP server ${IMAP_HOST}:${IMAP_PORT}...`);
+        connection = await Imap.connect(imapConfig);
+        console.log('Successfully connected to IMAP server.');
+
+        // 3. Open the target mailbox
+        await connection.openBox(folder);
+        console.log(`Mailbox "${folder}" opened.`);
+        // Retrieve UID validity of the destination mailbox (if available)
+
+
+        // 4. If a UID is provided, update the existing draft; otherwise, append a new one.
+        if (providedUid) {
+            console.log(`UID provided (${providedUid}). Updating existing draft...`);
+            // Attempt to delete the existing draft for that UID
+            try {
+                await connection.deleteMessage(providedUid);
+                console.log(`Existing draft with UID ${providedUid} deleted.`);
+            } catch (delErr) {
+                console.warn(`Could not delete existing draft with UID ${providedUid}: ${delErr}`);
+                // You might decide to abort here if deletion is mandatory
+            }
+            // Append the new draft (note: the server will normally assign a new UID,
+            // but we are returning the provided UID per the requirement).
+            console.log(`Appending updated draft to folder: ${folder}...`);
+            const updateAppendResult = await connection.append(rawEmail, {
+                mailbox: folder,
+                flags: ['\\Draft']
+            });
+            console.log('Updated draft appended.', updateAppendResult);
+
+            return {
+                status: 200,
+                message: 'Draft updated successfully.',
+                uid: providedUid,
+                folder: folder
+            };
+        } else {
+            console.log(`Appending email as a draft to folder: ${folder}...`);
+            const appendResult = await connection.append(rawEmail, {
+                mailbox: folder,
+                flags: ['\\Draft']
+            });
+            console.log('Email appended to drafts folder.', appendResult);
+
+            // Retrieve UID of the saved message
+            const searchResult = await connection.search(['ALL'], { bodies: ['HEADER.FIELDS (MESSAGE-ID)'] });
+            const uid = searchResult.length > 0 ? searchResult[searchResult.length - 1].attributes.uid : '';
+
+            return {
+                status: 200,
+                message: 'Draft saved successfully.',
+                uid: uid,
+                folder: folder
+            };
+        }
+
+    } catch (err) {
+        console.error('IMAP draft save failed:', err);
+        return {
+            status: 400,
+            message: 'Failed to save draft.',
+            error: err.toString(),
+            uid: '',
+            folder: folder
+        };
+    } finally {
+        if (connection) {
+            try {
+                await connection.end();
+                console.log('IMAP connection closed.');
+            } catch (endErr) {
+                console.error('Error ending IMAP connection:', endErr);
+            }
+        }
+    }
+};
+
+

package/server_connect/modules/imapsendmail.hjson

@@ -11,7 +11,9 @@
     node: {
       'imap' : '^0.8.19',
        'mailparser' : '^3.7.2',
-       'nodemailer' : '^6.10.1'
+       'nodemailer' : '^6.10.1',
+       'mime-lookup' : '^0.0.2',
+        'mime-db' : '^1.54.0'
     }
       },
         dataScheme: [
@@ -164,11 +166,11 @@
            },
           { name: 'attachments', 
           optionName: 'attachments', 
-          title: 'The eMail attachments', 
+          title: 'eMail attachments sent from client', 
           type: 'text', 
           defaultValue: "", 
           serverDataBindings: true,
-           help: 'The email attachments'
+           help: 'eMail attachments sent from client via upload action'
            },
           { name: 'save_to_send', 
           optionName: 'save_to_send', 

package/server_connect/modules/imapsendmail.js

@@ -6,7 +6,13 @@ const path = require("path");
 const { toSystemPath } = require("../../../lib/core/path");
 
 exports.imapsendmail = async function (options) {
-    const upload = this.parseOptional(options.attachments, '*', '');
+    const upload = this.parseOptional(options.attachments, '*', []);
+    console.log("Attachments: " + JSON.stringify(upload))
+    const upload2 = this.parseOptional(options.server_attachments, '*', []);
+    console.log("Server_Attachments: " + JSON.stringify(upload2))
+    const combinedJson = { "attachments": [upload, upload2] };
+    console.log('CombinedJson: ' + JSON.stringify(combinedJson))
+
 
     // Ensure attachments are properly formatted and converted to system paths
     const attachmentList = Array.isArray(upload)
@@ -58,8 +64,8 @@ exports.imapsendmail = async function (options) {
                 user: smtpConfig.username,
                 pass: smtpConfig.password,
             },
-            logger: true, // Enable logging
-            debug: true,  // Enable debugging
+            logger: false, // Enable logging
+            debug: false,  // Enable debugging
 
         });
 
@@ -77,7 +83,9 @@ exports.imapsendmail = async function (options) {
             subject: subject,
             text: body,
             html: body,
-            attachments: formattedAttachments,
+            attachments: formattedAttachments
+
+
         };
 
         console.log("Final Attachments List:", formattedAttachments);