joplin-plugin-backup 1.0.3 → 1.1.1

package/.github/workflows/auto-assign-issue.yml

@@ -0,0 +1,14 @@
+name: Issue assignment
+
+on:
+  issues:
+    types: [opened]
+
+jobs:
+  auto-assign:
+    runs-on: ubuntu-latest
+    steps:
+      - name: "Auto-assign issue"
+        uses: pozil/auto-assign-issue@v1.4.0
+        with:
+          assignees: JackGruber

package/README.md

@@ -33,8 +33,7 @@ Go to `Tools > Options > Backup`
 
 | Option                       | Description                                                                                                                                                              | Default                 |
 | ---------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------------------- |
-| `Backup path`                | Where to save the backups to. <br>This path is exclusive for the Joplin backups, there should be no other data in it!                                                    |                         |
-| `Single JEX`                 | Create only one JEX file for all notebooks                                                                                                                               | `false`                 |
+| `Backup path`                | Where to save the backups to. <br>This path is exclusive for the Joplin backups, there should be no other data in it when you disable the `Create Subfolder` settings!   |                         |
 | `Keep x backups`             | How many backups should be kept                                                                                                                                          | `1`                     |
 | `Backups interval in hours`  | Create a backup every X hours                                                                                                                                            | `24`                    |
 | `Only on change`             | Creates a backup at the specified backup interval only if there was a change to a `note`, `tag`, `resource` or `notebook`                                                | `false`                 |
@@ -44,6 +43,9 @@ Go to `Tools > Options > Backup`
 | `Zip compression Level`      | Compression level for zip archive archive                                                                                                                                | `Copy (no compression)` |
 | `Temporary export path`      | The data is first exported into this path before it is copied to the backup `Backup path`.                                                                               | ``                      |
 | `Backup set name`            | Name of the backup set if multiple backups are to be keep. [Available moment tokens](https://momentjs.com/docs/#/displaying/format/), which can be used with `{<TOKEN>}` | `{YYYYMMDDHHmm}`        |
+| `Single JEX`                 | Create only one JEX file for all, this option is recommended to prevent the loss of internal note links or folder structure during a restore!                            | `true`                  |
+| `Create Subfolder`           | Create a sub folder `JoplinBackup` in the configured `Backup path`. Deactivate only if there is no other data in the `Backup path`!                                      | `true`                  |
+| `Backup plugins`             | Backup the plugin folder from the Joplin profile with all installed plugin jpl files.                                                                                    | `true`                  |
 
 ## Keyboard Shortcuts
 
@@ -53,19 +55,20 @@ Under `Options > Keyboard Shortcuts` you can assign a keyboard shortcut for the
 
 ## What is backed up
 
-- Notebooks as JEX export (Empty notbooks are not backed up)
+- Notebooks as JEX export (Empty notebooks are not backed up)
 - The `settings.json` (Joplin settings)
 - The `keymap-desktop.json` (Keyboard shortcuts)
 - The `userchrome.css` (Your Joplin customization)
 - The `userstyle.css` (Your Joplin customization)
 - The `templates` folder (Note templates)
+- The `plugin` folder (All installed plugins, no plugin settings!)
 
 ## Restore
 
 ### Settings
 
 To restore the Settings, copy the desired files from `<Backup Path>\Profile` to the Joplin directory `.config\joplin-desktop`.  
-The exact path can be found in Joplin under `Tools > Options > Generla`:
+The exact path can be found in Joplin under `Tools > Options > General`:
 
 <img src=img/joplin_path_in_gui.jpg>
 
@@ -78,6 +81,27 @@ The notes are imported via `File > Import > JEX - Joplin Export File`.
 The notes are imported additionally, no check for duplicates is performed.
 If the folder in which the note was located already exists in you Joplin, than the folder name is extended by one (1).
 
+## FAQ
+
+### Internal Joplin links betwen notes are lost
+
+If several JEX files are imported and the notes have links to each other, these links will be lost.
+Therefore it is recommended to create a Single JEX Backup!
+
+### Compine multiple JEX Files to one
+
+By combining the JEX files into one, the Joplin internal links will work again after the import.
+
+1. Open one of the JEX files in a ZIP program like 7-Zip
+2. Open a second JEX and add all files to the first JEX
+3. Repeat step 2 for all files
+4. Import first JEX which now contains all notes
+
+## Open a JEX Backup file
+
+A Joplin JEX Backup file is a tar archive which can be opened with any zip program that supports TAR archive.
+The file names in the archive correspond to the Joplin internal IDs.
+
 ## Changelog
 
 See [CHANGELOG.md](CHANGELOG.md)

package/__test__/backup.test.ts

@@ -1,9 +1,9 @@
 import { Backup } from "../src/Backup";
 import * as fs from "fs-extra";
 import * as path from "path";
-import { joplinWrapper } from "../src/joplinWrapper";
 import { when } from "jest-when";
 import { sevenZip } from "../src/sevenZip";
+import joplin from "api";
 
 function getTestPaths(): any {
   const testPath: any = {};
@@ -15,6 +15,7 @@ function getTestPaths(): any {
   );
   testPath.joplinProfile = path.join(testPath.base, "joplin-desktop");
   testPath.templates = path.join(testPath.joplinProfile, "templates");
+  testPath.plugins = path.join(testPath.joplinProfile, "plugins");
   return testPath;
 }
 
@@ -24,12 +25,13 @@ let spyOnLogVerbose = null;
 let spyOnLogInfo = null;
 let spyOnLogWarn = null;
 let spyOnLogError = null;
+let spyOnShowError = null;
 let spyOnSaveBackupInfo = null;
 
-const spyOnsSettingsValue = jest.spyOn(joplinWrapper, "settingsValue");
-const spyOnGlobalValue = jest.spyOn(joplinWrapper, "settingsGlobalValue");
+const spyOnsSettingsValue = jest.spyOn(joplin.settings, "value");
+const spyOnGlobalValue = jest.spyOn(joplin.settings, "globalValue");
 const spyOnSettingsSetValue = jest
-  .spyOn(joplinWrapper, "settingsSetValue")
+  .spyOn(joplin.settings, "setValue")
   .mockImplementation();
 
 async function createTestStructure() {
@@ -38,6 +40,7 @@ async function createTestStructure() {
   fs.emptyDirSync(test.backupBasePath);
   fs.emptyDirSync(test.joplinProfile);
   fs.emptyDirSync(test.templates);
+  fs.emptyDirSync(test.plugins);
 }
 
 const testPath = getTestPaths();
@@ -73,6 +76,10 @@ describe("Backup", function () {
     spyOnLogError = jest
       .spyOn(backup.log, "error")
       .mockImplementation(() => {});
+
+    spyOnShowError = jest
+      .spyOn(backup, "showError")
+      .mockImplementation(() => {});
   });
 
   afterEach(async () => {
@@ -80,6 +87,7 @@ describe("Backup", function () {
     spyOnLogInfo.mockReset();
     spyOnLogWarn.mockReset();
     spyOnLogError.mockReset();
+    spyOnShowError.mockReset();
     spyOnsSettingsValue.mockReset();
     spyOnGlobalValue.mockReset();
     spyOnSaveBackupInfo.mockReset();
@@ -88,29 +96,72 @@ describe("Backup", function () {
   afterAll(async () => {
     fs.removeSync(testPath.base);
   });
-
   describe("Backup path", function () {
-    it(`Backup path != Profile`, async () => {
-      await backup.loadBackupPath();
-      expect(backup.backupBasePath).toBe(testPath.backupBasePath);
-      expect(backup.backupBasePath).not.toBe(testPath.joplinProfile);
-
-      /* prettier-ignore */
-      when(spyOnsSettingsValue)
-      .calledWith("path").mockImplementation(() => Promise.resolve(""));
-      await backup.loadBackupPath();
-      expect(backup.backupBasePath).not.toBe(testPath.joplinProfile);
-      expect(backup.backupBasePath).toBe(null);
+    it(`Path tests`, async () => {
+      const testCases = [
+        {
+          backupPath: testPath.joplinProfile,
+          createSubfolder: false,
+          expectedBackupPath: null,
+          expectedBackupPathExist: null,
+        },
+        {
+          backupPath: testPath.joplinProfile,
+          createSubfolder: true,
+          expectedBackupPath: path.join(testPath.joplinProfile, "JoplinBackup"),
+          expectedBackupPathExist: true,
+        },
+        {
+          backupPath: testPath.backupBasePath,
+          createSubfolder: false,
+          expectedBackupPath: testPath.backupBasePath,
+          expectedBackupPathExist: true,
+        },
+        {
+          backupPath: testPath.backupBasePath,
+          createSubfolder: true,
+          expectedBackupPath: path.join(
+            testPath.backupBasePath,
+            "JoplinBackup"
+          ),
+          expectedBackupPathExist: true,
+        },
+        {
+          backupPath: path.join(testPath.backupBasePath, "NotExisting"),
+          createSubfolder: false,
+          expectedBackupPath: path.join(testPath.backupBasePath, "NotExisting"),
+          expectedBackupPathExist: false,
+        },
+        {
+          backupPath: path.join(testPath.backupBasePath, "NotExisting"),
+          createSubfolder: true,
+          expectedBackupPath: path.join(
+            testPath.backupBasePath,
+            "NotExisting",
+            "JoplinBackup"
+          ),
+          expectedBackupPathExist: false,
+        },
+      ];
 
-      /* prettier-ignore */
-      when(spyOnsSettingsValue)
-      .calledWith("path").mockImplementation(() => Promise.resolve(testPath.joplinProfile));
-      await backup.loadBackupPath();
-      expect(backup.backupBasePath).not.toBe(testPath.joplinProfile);
-      expect(backup.backupBasePath).toBe(null);
+      for (const testCase of testCases) {
+        when(spyOnsSettingsValue)
+          .calledWith("path")
+          .mockImplementation(() => Promise.resolve(testCase.backupPath));
+        backup.createSubfolder = testCase.createSubfolder;
+        await backup.loadBackupPath();
+        expect(backup.backupBasePath).toBe(testCase.expectedBackupPath);
+        expect(backup.backupBasePath).not.toBe(testPath.joplinProfile);
+
+        if (testCase.expectedBackupPathExist !== null) {
+          expect(fs.existsSync(backup.backupBasePath)).toBe(
+            testCase.expectedBackupPathExist
+          );
+        }
 
-      expect(backup.log.error).toHaveBeenCalledTimes(0);
-      expect(backup.log.warn).toHaveBeenCalledTimes(0);
+        expect(backup.log.error).toHaveBeenCalledTimes(0);
+        expect(backup.log.warn).toHaveBeenCalledTimes(0);
+      }
     });
 
     it(`relative paths`, async () => {
@@ -524,6 +575,45 @@ describe("Backup", function () {
   });
 
   describe("Backup retention", function () {
+    it(`file/Folder deletion`, async () => {
+      const backupRetention = 2;
+      const set1 = path.join(testPath.backupBasePath, "202101011630");
+      const set2 = path.join(testPath.backupBasePath, "202101021630.7z");
+      const set3 = path.join(testPath.backupBasePath, "202101031630");
+      const set4 = path.join(testPath.backupBasePath, "202101041630.7z");
+
+      fs.emptyDirSync(set1);
+      fs.closeSync(fs.openSync(set2, "w"));
+      fs.emptyDirSync(set3);
+      fs.closeSync(fs.openSync(set4, "w"));
+
+      const backupInfo = [
+        { name: "202101011630", date: 1609515000 },
+        { name: "202101021630.7z", date: 1609601400 },
+        { name: "202101031630", date: 1609687800 },
+        { name: "202101041630.7z", date: 1609774200 },
+      ];
+
+      when(spyOnsSettingsValue)
+        .calledWith("backupInfo")
+        .mockImplementation(() => Promise.resolve(JSON.stringify(backupInfo)));
+
+      expect(fs.existsSync(set1)).toBe(true);
+      expect(fs.existsSync(set2)).toBe(true);
+      expect(fs.existsSync(set3)).toBe(true);
+      expect(fs.existsSync(set4)).toBe(true);
+      await backup.deleteOldBackupSets(
+        testPath.backupBasePath,
+        backupRetention
+      );
+
+      expect(fs.existsSync(set1)).toBe(false);
+      expect(fs.existsSync(set2)).toBe(false);
+      expect(fs.existsSync(set3)).toBe(true);
+      expect(fs.existsSync(set4)).toBe(true);
+      expect(fs.readdirSync(testPath.backupBasePath).length).toBe(2);
+    });
+
     it(`Backups < retention`, async () => {
       const backupRetention = 3;
       const folder1 = path.join(testPath.backupBasePath, "202101011630");
@@ -536,11 +626,15 @@ describe("Backup", function () {
         { name: "202101011630", date: 1 },
         { name: "202101021630", date: 2 },
       ];
-      /* prettier-ignore */
+
       when(spyOnsSettingsValue)
-            .calledWith("backupInfo").mockImplementation(() => Promise.resolve(JSON.stringify(backupInfo)));
+        .calledWith("backupInfo")
+        .mockImplementation(() => Promise.resolve(JSON.stringify(backupInfo)));
 
-      backup.deleteOldBackupSets(testPath.backupBasePath, backupRetention);
+      await backup.deleteOldBackupSets(
+        testPath.backupBasePath,
+        backupRetention
+      );
 
       const folderAnz = fs
         .readdirSync(testPath.backupBasePath, { withFileTypes: true })
@@ -567,11 +661,15 @@ describe("Backup", function () {
         { name: "202101021630", date: 2 },
         { name: "202101031630", date: 3 },
       ];
-      /* prettier-ignore */
+
       when(spyOnsSettingsValue)
-            .calledWith("backupInfo").mockImplementation(() => Promise.resolve(JSON.stringify(backupInfo)));
+        .calledWith("backupInfo")
+        .mockImplementation(() => Promise.resolve(JSON.stringify(backupInfo)));
 
-      backup.deleteOldBackupSets(testPath.backupBasePath, backupRetention);
+      await backup.deleteOldBackupSets(
+        testPath.backupBasePath,
+        backupRetention
+      );
       const folderAnz = fs
         .readdirSync(testPath.backupBasePath, { withFileTypes: true })
         .filter((dirent) => dirent.isDirectory()).length;
@@ -604,9 +702,10 @@ describe("Backup", function () {
         { name: "202101041630", date: 4 },
         { name: "202101051630", date: 5 },
       ];
-      /* prettier-ignore */
+
       when(spyOnsSettingsValue)
-            .calledWith("backupInfo").mockImplementation(() => Promise.resolve(JSON.stringify(backupInfo)));
+        .calledWith("backupInfo")
+        .mockImplementation(() => Promise.resolve(JSON.stringify(backupInfo)));
 
       await backup.deleteOldBackupSets(
         testPath.backupBasePath,
@@ -786,12 +885,14 @@ describe("Backup", function () {
       const userstyle = path.join(testPath.joplinProfile, "userstyle.css");
       const userchrome = path.join(testPath.joplinProfile, "userchrome.css");
       const keymap = path.join(testPath.joplinProfile, "keymap-desktop.json");
+      const plugin = path.join(testPath.plugins, "test-plugin.jpl");
 
       fs.writeFileSync(template, "template");
       fs.writeFileSync(settings, "settings");
       fs.writeFileSync(userstyle, "userstyle");
       fs.writeFileSync(userchrome, "userchrome");
       fs.writeFileSync(keymap, "keymap");
+      fs.writeFileSync(plugin, "plugin");
 
       fs.emptyDirSync(testPath.activeBackupJob);
 
@@ -821,8 +922,15 @@ describe("Backup", function () {
         "profile",
         "keymap-desktop.json"
       );
+      const backupPlugin = path.join(
+        testPath.activeBackupJob,
+        "profile",
+        "plugins",
+        "test-plugin.jpl"
+      );
 
       backup.activeBackupPath = testPath.activeBackupJob;
+      backup.backupPlugins = true;
       await backup.backupProfileData();
 
       expect(fs.existsSync(backupTemplate)).toBe(true);
@@ -830,6 +938,7 @@ describe("Backup", function () {
       expect(fs.existsSync(backupUserstyle)).toBe(true);
       expect(fs.existsSync(backupUserchrome)).toBe(true);
       expect(fs.existsSync(backupKeymap)).toBe(true);
+      expect(fs.existsSync(backupPlugin)).toBe(true);
 
       expect(backup.log.error).toHaveBeenCalledTimes(0);
       expect(backup.log.warn).toHaveBeenCalledTimes(0);

package/__test__/help.test.ts

@@ -0,0 +1,74 @@
+import { helper } from "../src/helper";
+
+describe("Test helper", function () {
+  it(`validFileName`, async () => {
+    const testCases = [
+      {
+        fileName: "some test file.txt",
+        expected: true,
+      },
+      {
+        fileName: "some ^test file.txt",
+        expected: true,
+      },
+      {
+        fileName: "some :test file.txt",
+        expected: false,
+      },
+      {
+        fileName: "some \\test file.txt",
+        expected: false,
+      },
+      {
+        fileName: "some |test file.txt",
+        expected: false,
+      },
+      {
+        fileName: "some /test file.txt",
+        expected: false,
+      },
+      {
+        fileName: "some *test file.txt",
+        expected: false,
+      },
+      {
+        fileName: "some ?test file.txt",
+        expected: false,
+      },
+      {
+        fileName: "some <test file.txt",
+        expected: false,
+      },
+      {
+        fileName: "some >test file.txt",
+        expected: false,
+      },
+      {
+        fileName: "com9.txt",
+        expected: false,
+      },
+      {
+        fileName: "nul.txt",
+        expected: false,
+      },
+      {
+        fileName: "prn.txt",
+        expected: false,
+      },
+      {
+        fileName: "con.txt",
+        expected: false,
+      },
+      {
+        fileName: "lpt5.txt",
+        expected: false,
+      },
+    ];
+
+    for (const testCase of testCases) {
+      expect(await helper.validFileName(testCase.fileName)).toBe(
+        testCase.expected
+      );
+    }
+  });
+});

package/__test__/pw.test.ts

@@ -0,0 +1,82 @@
+import { Backup } from "../src/Backup";
+import joplin from "api";
+import { when } from "jest-when";
+
+let backup = null;
+
+describe("Password", function () {
+  beforeEach(async () => {
+    backup = new Backup() as any;
+  });
+
+  it(`Check`, async () => {
+    const spyOnsSettingsValue = jest.spyOn(joplin.settings, "value");
+    const spyOnsSettingsSetValue = jest.spyOn(joplin.settings, "setValue");
+
+    const testCases = [
+      {
+        usePassword: false,
+        password: "",
+        passwordRepeat: "",
+        expected: 0,
+        called: 2,
+      },
+      {
+        usePassword: false,
+        password: "test",
+        passwordRepeat: "test",
+        expected: 0,
+        called: 2,
+      },
+      {
+        usePassword: false,
+        password: "testA",
+        passwordRepeat: "testB",
+        expected: 0,
+        called: 2,
+      },
+      {
+        usePassword: true,
+        password: "test",
+        passwordRepeat: "test",
+        expected: 1,
+        called: 0,
+      },
+      {
+        usePassword: true,
+        password: "testA",
+        passwordRepeat: "testB",
+        expected: -1,
+        called: 2,
+      },
+      {
+        usePassword: true,
+        password: " ",
+        passwordRepeat: " ",
+        expected: -1,
+        called: 2,
+      },
+      {
+        usePassword: true,
+        password: "",
+        passwordRepeat: " ",
+        expected: -1,
+        called: 2,
+      },
+    ];
+
+    for (const testCase of testCases) {
+      /* prettier-ignore */
+      when(spyOnsSettingsValue)
+        .mockImplementation(() => Promise.resolve("no mockImplementation"))
+        .calledWith("usePassword").mockImplementation(() => Promise.resolve(testCase.usePassword))
+        .calledWith("password").mockImplementation(() => Promise.resolve(testCase.password))
+        .calledWith("passwordRepeat").mockImplementation(() => Promise.resolve(testCase.passwordRepeat));
+      expect(await backup.checkPassword()).toBe(testCase.expected);
+
+      await backup.enablePassword();
+      expect(spyOnsSettingsSetValue).toBeCalledTimes(testCase.called);
+      spyOnsSettingsSetValue.mockReset();
+    }
+  });
+});

package/__test__/sevenZip.test.ts

@@ -32,7 +32,9 @@ describe("Test sevenZip", function () {
     expect(fs.existsSync(file3)).toBe(true);
     expect(fs.existsSync(zip)).toBe(false);
 
-    expect(await sevenZip.add(zip, testBaseDir + "\\*", "secret")).toBe(true);
+    expect(await sevenZip.add(zip, path.join(testBaseDir, "*"), "secret")).toBe(
+      true
+    );
     expect(fs.existsSync(zip)).toBe(true);
 
     expect(await sevenZip.passwordProtected(zip)).toBe(true);

package/__test__/sevenZipUpdateBinPath.test.ts

@@ -0,0 +1,16 @@
+import { sevenZip, pathTo7zip } from "../src/sevenZip";
+import * as path from "path";
+import joplin from "api";
+
+it(`Set bin from joplin`, async () => {
+  const pathBevor = pathTo7zip;
+  const pathAdd = "addJoplinPath";
+  const pathAfter = path.join(pathAdd, "7zip-bin", pathTo7zip);
+
+  jest.spyOn(joplin.plugins, "installationDir").mockImplementation(async () => {
+    return pathAdd;
+  });
+
+  await sevenZip.updateBinPath();
+  expect(pathTo7zip).toBe(pathAfter);
+});

package/package.json

@@ -1,10 +1,14 @@
 {
   "name": "joplin-plugin-backup",
-  "version": "1.0.3",
+  "version": "1.1.1",
   "scripts": {
     "dist": "webpack --joplin-plugin-config buildMain && webpack --joplin-plugin-config buildExtraScripts && webpack --joplin-plugin-config createArchive",
     "prepare": "npm run dist && husky install",
     "update": "npm install -g generator-joplin && yo joplin --update",
+    "release": "npm test && node ./node_modules/joplinplugindevtools/dist/createRelease.js",
+    "preRelease": "npm test && node ./node_modules/joplinplugindevtools/dist/createRelease.js --prerelease",
+    "gitRelease": "node ./node_modules/joplinplugindevtools/dist/createRelease.js --upload",
+    "gitPreRelease": "node ./node_modules/joplinplugindevtools/dist/createRelease.js --upload --prerelease",
     "test": "jest"
   },
   "license": "MIT",
@@ -14,14 +18,18 @@
   "devDependencies": {
     "@types/jest": "^26.0.23",
     "@types/node": "^14.0.14",
+    "axios": "^0.21.1",
     "chalk": "^4.1.0",
     "copy-webpack-plugin": "^6.1.0",
+    "dotenv": "^10.0.0",
     "fs-extra": "^9.0.1",
     "glob": "^7.1.6",
     "husky": "^6.0.0",
     "jest": "^27.0.4",
     "jest-when": "^3.3.1",
+    "joplinplugindevtools": "^1.0.14",
     "lint-staged": "^11.0.0",
+    "mime": "^2.5.2",
     "on-build-webpack": "^0.1.0",
     "prettier": "2.3.0",
     "tar": "^6.0.5",
@@ -56,11 +64,8 @@
       "js"
     ],
     "moduleNameMapper": {
-      "^api$": "<rootDir>/api",
+      "^api$": "<rootDir>/node_modules/joplinplugindevtools/dist/apiMock.js",
       "^api/types$": "<rootDir>/api/types"
-    },
-    "globals": {
-      "joplin": true
     }
   }
 }

package/publish/io.github.jackgruber.backup.json

@@ -2,7 +2,7 @@
 	"manifest_version": 1,
 	"id": "io.github.jackgruber.backup",
 	"app_min_version": "2.1.3",
-	"version": "1.0.3",
+	"version": "1.1.1",
 	"name": "Simple Backup",
 	"description": "Plugin to create manual and automatic backups.",
 	"author": "JackGruber",
@@ -16,6 +16,6 @@
 		"7zip",
 		"encrypted"
 	],
-	"_publish_hash": "sha256:99f57ce2e8c6fb3b86c825f99493239f643590730356b2a981667586a3ca2b2e",
-	"_publish_commit": "master:ebf47d68156e58af11997df87c7073345785ea83"
+	"_publish_hash": "sha256:616b034ec484e83bf972adab454c9c00d23d9bd0b21574beba7915e42ff7415a",
+	"_publish_commit": "master:98221472e60f34026ac739368c2831193f564654"
 }

package/CHANGELOG.md

@@ -1,84 +0,0 @@
-# Changelog
-
-## not released
-
-## v1.0.3 (2021-08-11)
-
-- Fix: #19 Backups failed from Joplin version v2.2.5 and higher, due to the removed template function
-
-## v1.0.2 (2021-07-19)
-
-- Improved: Use of moments token
-- Fix: #16 Prevent multiple simultaneous backup runs
-- Add: #11 Make zip compression level selectable
-- Fix: Delete old backup set information, if the backup set no longer exists
-
-## v1.0.1 (2021-07-03)
-
-Release for Joplin plugin manager
-
-## v1.0.0 [pre-release] (2021-06-20)
-
-- Add: Option for encrypted backups
-
-> ❗️ Requires at least Joplin `2.1.3` ❗️
-
-## v0.9.0 [pre-release] (2021-06-19)
-
-- Add: Relative path could be used for `Backup Path`
-- Fix: An error with `Only on change`, which was not working properly
-- Add: Option to create zip archive
-- Add: Option to specify the `Backup set name` if multiple backups are to be keep.
-
-## v0.5.3 (2021-04-03)
-
-- Add: Backup settings.json
-- Optimize: #7 Better error message when a backup is created twice in a row in the same minute
-
-## v0.5.2 (2021-02-13)
-
-- Only internal changes
-
-## v0.5.1 (2021-02-07)
-
-- Fix: Incomplete backup.log with only one backup set
-
-## v0.5.0 (2021-02-07)
-
-- Add: Option for Backuplogfile
-- Add: Option to create a backup only if something has changed #3
-
-## v0.4.1 (2021-01-23)
-
-- Optimize: Store profile data in `profile` folder
-
-## v0.4.0 (2021-01-21)
-
-- Add `templates` to backup
-- Optimize: Delete old backups at the end of the backup job
-
-## v0.3.1 (2021-01-21)
-
-- Fix #1: Unsupported characters in filename
-
-## v0.3.0 (2021-01-17)
-
-- Fix: Backup not only the last 50 notebooks
-- Add: Backup userchrome.css and userstyle.css
-- Add: Option to create single file JEX for all notebooks
-
-## v0.2.2 (2021-01-17)
-
-- Fix: Check if keymap-desktop.json exists
-
-## v0.2.1 (2021-01-16)
-
-- remove seconds from folder
-
-## v0.2.0 (2021-01-14)
-
-- Add: Automatic backups every X hours
-
-## v0.1.0 (2021-01-14)
-
-- First version