week 6 & 7& 8

package.json

@@ -18,6 +18,7 @@
     "@typescript-eslint/parser": "^5.30.7",
     "chalk": "^4.1.0",
     "copy-webpack-plugin": "^6.1.0",
+    "cross-blob": "^2.0.0",
     "eslint": "^8.20.0",
     "eslint-config-google": "^0.14.0",
     "fs-extra": "^9.0.1",
@@ -35,6 +36,7 @@
   "dependencies": {
     "imap": "^0.8.19",
     "net": "^1.0.2",
+    "postal-mime": "^1.0.13",
     "tls": "^0.0.1"
   }
 }

src/constants.ts

@@ -2,3 +2,4 @@ export const SECTION_NAME = 'Email_Plugin';
 export const EXPORT_TYPE = 'Export_Type';
 export const ATTACHMENTS = 'Attachments';
 export const PLUGIN_ICON = 'fa fa-envelope';
+export const CONVERTED_MESSAGES = 'Converted_Messages';

src/core/emailParser.ts

@@ -0,0 +1,36 @@
+const postalMime = require('postal-mime/dist/node').postalMime.default;
+import {EmailContent} from '../model/emailContent.model';
+
+
+export default class EmailParser extends postalMime {
+    emailContent: EmailContent;
+    constructor() {
+        super();
+    }
+
+    // Email in RFC 822 format.
+    async parse(message: string): Promise<EmailContent> {
+        // A message is invalid if it starts with a space.
+        message = message.trim();
+
+        try {
+            this.emailContent = await super.parse(message);
+            this.emailContent.subject = this.subject;
+            this.emailContent.html = this.html;
+            this.emailContent.attachments = this.emailContent.attachments;
+
+            return (this.emailContent);
+        } catch (err) {
+            throw err;
+        }
+    }
+
+    get subject() {
+        return this.emailContent.subject || 'No Subject';
+    }
+
+    get html() {
+        return this.emailContent.html || '<div><h1>This Email Has No Body</h1></div>\n';
+    }
+}
+

src/core/imap.ts

@@ -1,13 +1,21 @@
 import * as Imap from 'imap';
 import {ImapConfig} from '../model/imapConfig.model';
 import {Query} from '../model/Query.model';
+import joplin from 'api';
+import {CONVERTED_MESSAGES} from '../constants';
+import {PostNote} from './postNote';
+import EmailParser from './emailParser';
+import {EmailContent} from '../model/emailContent.model';
 
 export class IMAP {
     private imap = null;
     private monitorId = null;
     private query: Query = null;
     private delayTime = 1000 * 5;
 
+    // To check if there is a query not completed yet.
+    private pending = false;
+
     constructor(config: ImapConfig) {
         this.imap = new Imap({
             ...config,
@@ -51,7 +59,7 @@ export class IMAP {
         });
     }
 
-    search(criteria) {
+    search(criteria): Promise<number[]> {
         return new Promise((resolve, reject) => {
             this.imap.search(criteria, (err, messages) => {
                 if (err) {
@@ -83,6 +91,81 @@ export class IMAP {
         });
     }
 
+    fetchAll(messages: number[], structure: object) {
+        return new Promise<string[]>((resolve, reject) => {
+            const fetch = this.imap.fetch(messages, structure);
+            const convertedMessages: string[] = [];
+
+            // For each message
+            fetch.on('message', (message, seqno) => {
+                let data = '';
+
+                message.on('body', (stream) => {
+                    stream.on('data', function(chunk) {
+                        // push data
+                        data += chunk;
+                    });
+                });
+
+                message.once('end', async () => {
+                    convertedMessages.push(data);
+                });
+            });
+
+            // All messages have been fetched of type RFC 822.
+            fetch.on('end', () => {
+                resolve(convertedMessages);
+            });
+
+            this.imap.once('error', function(err: Error) {
+                reject(err);
+            });
+        });
+    }
+
+    newMessages(messages: number[]): Promise<number[]> {
+        return new Promise(async (resolve, reject)=>{
+            if (messages.length === 0) {
+                return resolve([]);
+            }
+
+            try {
+                const value = await joplin.settings.value(CONVERTED_MESSAGES);
+                const email = this.imap._config.user;
+
+                // Each email has a list of messages ids, which have been converted to notes before.
+                if (!(email in value)) {
+                    value[email] = {
+                        ['from']: [],
+                    };
+                    await joplin.settings.setValue(CONVERTED_MESSAGES, value);
+                }
+
+                const converted = value[email]['from'];
+                const newMessages = messages.filter((x) => !converted.includes(x));
+
+                return resolve(newMessages);
+            } catch (err) {
+                return reject(err);
+            }
+        });
+    }
+
+    updateConvertedMessages(newMessages: number[]): Promise<void> {
+        return new Promise(async (resolve, reject)=>{
+            try {
+                const value = await joplin.settings.value(CONVERTED_MESSAGES);
+                const email = this.imap._config.user;
+
+                value[email]['from'].push(...newMessages);
+                await joplin.settings.setValue(CONVERTED_MESSAGES, value);
+                resolve();
+            } catch (err) {
+                return reject(err);
+            }
+        });
+    }
+
     monitor() {
         let mailBox = null;
         let criteria = null;
@@ -100,11 +183,31 @@ export class IMAP {
 
                     const messages = await this.search(criteria);
 
-                    console.log(messages);
+                    const newMessages = await this.newMessages(messages);
+
+                    console.log(newMessages);
+
+                    if (newMessages.length && !this.pending) {
+                        this.pending = true;
+                        const data = await this.fetchAll(newMessages, {bodies: ''});
+
+                        for (let i = 0; i < data.length; i++) {
+                            const email = new EmailParser();
+                            const emailContent: EmailContent = await email.parse(data[i]);
+
+                            // for test
+                            const note = new PostNote();
+                            await note.post(emailContent, ['joplin'], []);
+                        }
+                        /* to save the id of converted messages */
+                        await this.updateConvertedMessages(newMessages);
+                        this.pending = false;
+                    }
                 } catch (err) {
                     // Revoke the query
                     this.query = null;
                     alert(err);
+                    throw err;
                 }
             }
         }, this.delayTime);

src/core/postAttachments.ts

@@ -0,0 +1,52 @@
+import {tmpdir} from 'os';
+import {sep} from 'path';
+import joplin from 'api';
+import {Attachment} from '../model/attachment.model';
+import {AttachmentProperties} from '../model/attachmentProperties.mode';
+const fs = joplin.require('fs-extra');
+
+export class Attachments {
+    tempFolder: string = `${tmpdir}${sep}joplin-email-plugin${sep}`;
+    attachments: Attachment[];
+
+    constructor(attachments: Attachment[]) {
+        this.attachments = attachments.filter((e: Attachment)=>e.filename !== '');
+    }
+
+
+    async postAttachments(): Promise<AttachmentProperties[]> {
+        const attachmentsProp: AttachmentProperties[] = [];
+        const tempFolder = this.tempFolder;
+
+        try {
+            // for each attachment will create an actual file of the attachment and posting to Joplin.
+            for (let i = 0; i < this.attachments.length; i++) {
+                const {contentId, filename} = this.attachments[i];
+                const path = `${tempFolder}${this.attachments[i].filename}`;
+
+                // to create a file
+                fs.writeFileSync(path, Buffer.from(this.attachments[i].content));
+
+                // To post a file to Joplin
+                const resource = await joplin.data.post(
+                    ['resources'],
+                    null,
+                    {title: filename}, // Resource metadata
+                    [
+                        {
+                            path: path, // Actual file
+                        },
+                    ],
+                );
+
+                attachmentsProp.push({contentId: contentId, id: resource.id});
+            }
+
+            return attachmentsProp;
+        } catch (err) {
+            throw err;
+        }
+    }
+}
+
+