fix: don't create provisional notes/todos while using templates

Author: nishantwrp

.eslintrc

@@ -8,7 +8,7 @@
     "plugin:@typescript-eslint/recommended"
   ],
   "rules": {
-    "indent": ["error", 4],
+    "indent": ["error", 4, { "SwitchCase": 1 }],
     "quotes": ["error", "double"],
     "eol-last": ["error", "always"]
   }

src/actions.ts

@@ -0,0 +1,38 @@
+import joplin from "api";
+import { getSelectedFolder } from "./utils/folders";
+
+export enum TemplateAction {
+    NewNote = "newNote",
+    NewTodo = "newTodo",
+    InsertText = "insertText"
+}
+
+const performInsertTextAction = async (template: string) => {
+    await joplin.commands.execute("insertText", template);
+}
+
+const performNewNoteAction = async (template: string) => {
+    const currentFolder = await getSelectedFolder();
+    const note = await joplin.data.post(["notes"], null, { body: template, parent_id: currentFolder });
+    await joplin.commands.execute("openNote", note.id);
+}
+
+const performNewTodoAction = async (template: string) => {
+    const currentFolder = await getSelectedFolder();
+    const note = await joplin.data.post(["notes"], null, { body: template, parent_id: currentFolder, is_todo: 1 });
+    await joplin.commands.execute("openNote", note.id);
+}
+
+export const performAction = async (action: TemplateAction, template: string): Promise<void> => {
+    switch (action) {
+        case TemplateAction.InsertText:
+            await performInsertTextAction(template);
+            break;
+        case TemplateAction.NewNote:
+            await performNewNoteAction(template);
+            break;
+        case TemplateAction.NewTodo:
+            await performNewTodoAction(template);
+            break;
+    }
+}

src/index.ts

@@ -4,7 +4,7 @@ import { Parser } from "./parser";
 import { DateAndTimeUtils } from "./utils/dateAndTime";
 import { getTemplateFromId, getUserTemplateSelection, Note } from "./utils/templates";
 import { setDefaultTemplatesView } from "./views/defaultTemplates";
-import { JoplinCommand } from "./types";
+import { TemplateAction, performAction } from "./actions";
 import { loadLegacyTemplates } from "./legacyTemplates";
 import * as open from "open";
 
@@ -44,16 +44,16 @@ joplin.plugins.register({
 
 
         // Utility Functions
-        const executeCommandWithParsedTemplate = async (command: JoplinCommand, template: Note | null) => {
+        const performActionWithParsedTemplate = async (action: TemplateAction, template: Note | null) => {
             const parsedTemplate = await parser.parseTemplate(template);
             if (parsedTemplate) {
-                await joplin.commands.execute(command, parsedTemplate);
+                await performAction(action, parsedTemplate);
             }
         }
 
-        const getTemplateAndExecuteCommand = async (command: JoplinCommand) => {
+        const getTemplateAndPerformAction = async (action: TemplateAction) => {
             const template: Note = JSON.parse(await getUserTemplateSelection());
-            await executeCommandWithParsedTemplate(command, template);
+            await performActionWithParsedTemplate(action, template);
         }
 
 
@@ -62,23 +62,23 @@ joplin.plugins.register({
             name: "createNoteFromTemplate",
             label: "Create note from template",
             execute: async () => {
-                await getTemplateAndExecuteCommand(JoplinCommand.NewNote);
+                await getTemplateAndPerformAction(TemplateAction.NewNote);
             }
         });
 
         await joplin.commands.register({
             name: "createTodoFromTemplate",
             label: "Create to-do from template",
             execute: async () => {
-                await getTemplateAndExecuteCommand(JoplinCommand.NewTodo);
+                await getTemplateAndPerformAction(TemplateAction.NewTodo);
             }
         });
 
         await joplin.commands.register({
             name: "insertTemplate",
             label: "Insert template",
             execute: async () => {
-                await getTemplateAndExecuteCommand(JoplinCommand.InsertText);
+                await getTemplateAndPerformAction(TemplateAction.InsertText);
             }
         });
 
@@ -127,7 +127,7 @@ joplin.plugins.register({
             execute: async () => {
                 const template = await getTemplateFromId(await joplin.settings.value("defaultNoteTemplateId"));
                 if (template) {
-                    return await executeCommandWithParsedTemplate(JoplinCommand.NewNote, template);
+                    return await performActionWithParsedTemplate(TemplateAction.NewNote, template);
                 }
                 await joplin.views.dialogs.showMessageBox("No default note template is set.");
             }
@@ -139,7 +139,7 @@ joplin.plugins.register({
             execute: async () => {
                 const template = await getTemplateFromId(await joplin.settings.value("defaultTodoTemplateId"));
                 if (template) {
-                    return await executeCommandWithParsedTemplate(JoplinCommand.NewTodo, template);
+                    return await performActionWithParsedTemplate(TemplateAction.NewTodo, template);
                 }
                 await joplin.views.dialogs.showMessageBox("No default to-do template is set.");
             }

src/types.ts

@@ -1,5 +1,10 @@
 import joplin from "api";
 
+export const getSelectedFolder = async (): Promise<string> => {
+    const folder = await joplin.workspace.selectedFolder();
+    return folder.id;
+}
+
 export const createFolder = async (title: string): Promise<string> => {
     const folder = await joplin.data.post(["folders"], null, { title: title });
     return folder.id;