feat: automatically load previous templates

Author: nishantwrp

src/index.ts

@@ -5,6 +5,7 @@ import { DateAndTimeUtils } from "./utils/dateAndTime";
 import { getTemplateFromId, getUserTemplateSelection, Note } from "./utils/templates";
 import { setDefaultTemplatesView } from "./views/defaultTemplates";
 import { JoplinCommand } from "./types";
+import { loadLegacyTemplates } from "./legacyTemplates";
 
 joplin.plugins.register({
     onStart: async function() {
@@ -35,6 +36,10 @@ joplin.plugins.register({
         const parser = new Parser(dateAndTimeUtils, dialogViewHandle);
 
 
+        // Asynchronously load legacy templates
+        loadLegacyTemplates(dateAndTimeUtils);
+
+
         // Utility Functions
         const executeCommandWithParsedTemplate = async (command: JoplinCommand, template: Note | null) => {
             const parsedTemplate = await parser.parseTemplate(template);

src/legacyTemplates.ts

@@ -0,0 +1,59 @@
+import joplin from "api";
+import { DateAndTimeUtils } from "./utils/dateAndTime";
+import { createFolder } from "./utils/folders";
+import { applyTagToNote, getAnyTagWithTitle } from "./utils/tags";
+
+const README_BODY = (
+    `As the templates feature was removed from the main application and was repackaged in a form a plugin, we noticed that you had some templates previously. We imported those templates for you in this notebook. Here are some quick tips for getting started with the templates plugin.
+
+  - You can rename this notebook if you want. You can infact, shift your templates to any other notebook.
+  - All the notes or to-dos with a tag titled \`template\` are considered as templates.
+  - You can delete this readme or notebook if you've shifted your templates to any other notebook.
+  - Your templates are still present in your templates directory but are renamed from \`.md\` to \`.md.old\`.
+  - For full documentation and features, please refer to the official [readme](https://github.com/joplin/plugin-templates#readme).`);
+
+const createTemplatesFolder = async (utils: DateAndTimeUtils): Promise<string> => {
+    const folderTitle = `Imported Templates - ${utils.getCurrentTime(utils.getDateFormat())}`;
+    return createFolder(folderTitle);
+}
+
+const getTemplatesTag = async (): Promise<string> => {
+    return (await getAnyTagWithTitle("template")).id;
+}
+
+export const loadLegacyTemplates = async (dateAndTimeUtils: DateAndTimeUtils): Promise<void> => {
+    const fs = joplin.require("fs-extra");
+
+    let folderId = null;
+    let templatesTagId = null;
+
+    const profileDir = await joplin.settings.globalValue("profileDir");
+    const templatesDir = `${profileDir}/templates`;
+
+    if (await fs.pathExists(templatesDir)) {
+        try {
+            const directoryContents = await fs.readdir(templatesDir);
+            for (const contentName of directoryContents) {
+                const contentPath = `${templatesDir}/${contentName}`;
+                if (contentName.endsWith(".md") && (await fs.stat(contentPath)).isFile()) {
+                    if (!folderId) folderId = await createTemplatesFolder(dateAndTimeUtils);
+                    if (!templatesTagId) templatesTagId = await getTemplatesTag();
+
+                    const templateBody = await fs.readFile(contentPath, "utf-8");
+
+                    const note = await joplin.data.post(["notes"], null, { title: contentName, body: templateBody, parent_id: folderId });
+                    await applyTagToNote(templatesTagId, note.id);
+
+                    const newPath = `${contentPath}.old`;
+                    await fs.rename(contentPath, newPath);
+                }
+            }
+        } catch (error) {
+            console.error(`Failed to load legacy templates: ${error}`);
+        }
+    }
+
+    if (folderId) {
+        await joplin.data.post(["notes"], null, { title: "README", body: README_BODY, parent_id: folderId });
+    }
+}

src/utils/folders.ts

@@ -14,3 +14,8 @@ export const doesFolderExist = async (folderId: string): Promise<boolean> => {
 export const getAllNotesInFolder = async (folderId: string): Promise<Note[]> => {
     return fetchAllItems(["folders", folderId, "notes"], { fields: ["id", "title", "body"] });
 }
+
+export const createFolder = async (title: string): Promise<string> => {
+    const folder = await joplin.data.post(["folders"], null, { title: title });
+    return folder.id;
+}

src/utils/tags.ts

@@ -1,3 +1,4 @@
+import joplin from "api";
 import { fetchAllItems } from "./dataApi";
 import { Note } from "./templates";
 
@@ -15,6 +16,20 @@ export const getAllTagsWithTitle = async (title: string): Promise<Tag[]> => {
     });
 }
 
+export const getAnyTagWithTitle = async (title: string): Promise<Tag> => {
+    const existingTags = await getAllTagsWithTitle(title);
+    if (existingTags.length) {
+        return existingTags[0];
+    }
+
+    const tag = await joplin.data.post(["tags"], null, { title: title });
+    return tag.id;
+}
+
 export const getAllNotesWithTag = async (tagId: string): Promise<Note[]> => {
     return fetchAllItems(["tags", tagId, "notes"], { fields: ["id", "title", "body"] });
 }
+
+export const applyTagToNote = async (tagId: string, noteId: string): Promise<void> => {
+    await joplin.data.post(["tags", tagId, "notes"], null, { id: noteId });
+}