Add interface logic for reverting page to previous version

src/app/components/version-modal/version-modal.component.html

@@ -1,6 +1,14 @@
 <div class="container">
     <div class="header">
         <div class="title">Page Versions</div>
+        <button
+            *ngIf="selectedVersion && !selectedVersion.currentVersion"
+            title="Revert to this version"
+            class="revert"
+            (click)="revertToVersion()"
+        >
+            Revert
+        </button>
         <button title="Close" class="close" (click)="dismiss()">
             <i class="fa fa-times"></i>
         </button>

src/app/components/version-modal/version-modal.component.scss

@@ -19,6 +19,11 @@
       background: #ff6666;
       color: white;
     }
+
+    .revert {
+      color: red;
+      background: #eaeaea;
+    }
   }
 
   .contents {

src/app/components/version-modal/version-modal.component.ts

@@ -29,8 +29,30 @@ export class VersionModalComponent implements OnInit {
         this.onVersionClick(this.pageVersions[0]);
     }
 
-    dismiss() {
+    dismiss(reload = false) {
-        this.modals.dismiss();
+        this.modals.dismiss(reload);
+    }
+
+    async revertToVersion() {
+        const alert = await this.alerts.create({
+            header: 'Revert page?',
+            message: `This will revert the current version of the page to version ${this.selectedVersion.versionNum}. Continue?`,
+            buttons: [
+                {
+                    text: 'Keep It',
+                    role: 'cancel',
+                },
+                {
+                    text: 'Revert It',
+                    handler: async () => {
+                        await this.editorService.revertPageToVersion(this.pageId, this.selectedVersion.versionNum);
+                        this.dismiss(true);
+                    },
+                },
+            ],
+        });
+
+        await alert.present();
     }
 
     async onVersionClick(version: PageVersionRecord) {

src/app/pages/editor/editor.page.ts

@@ -168,6 +168,12 @@ export class EditorPage implements OnInit {
       cssClass: 'modal-big',
     });
 
+    modal.onDidDismiss().then(reload => {
+      if ( reload ) {
+        this.editorService.startEditing(this.pageId);
+      }
+    });
+
     await modal.present();
   }
 }

src/app/service/api.service.ts

@@ -11,8 +11,8 @@ import {Database} from './db/Database';
 import {DatabaseColumn} from './db/DatabaseColumn';
 import {DatabaseEntry} from './db/DatabaseEntry';
 import {FileGroup} from './db/FileGroup';
-import {Page} from "./db/Page";
+import {Page} from './db/Page';
-import {PageNode} from "./db/PageNode";
+import {PageNode} from './db/PageNode';
 
 export class ResourceNotAvailableOfflineError extends Error {
   constructor(msg = 'This resource is not yet available offline on this device.') {

src/app/service/editor.service.ts

@@ -634,6 +634,51 @@ export class EditorService {
         });
     }
 
+    async revertPageToVersion(pageId: string, versionNum: number): Promise<PageRecord> {
+        return new Promise(async (res, rej) => {
+            const existingLocalPage = await this.db.pages.where({ UUID: pageId }).first() as Page;
+
+            if ( this.api.isOffline ) {
+                return rej(new ResourceNotAvailableOfflineError());
+            }
+
+            this.api.post(`/page/${pageId}/versions/revert`, { version_num: versionNum }).subscribe({
+                next: async result => {
+                    const page = new PageRecord(result.data);
+
+                    if ( existingLocalPage ) {
+                        existingLocalPage.fillFromRecord(result.data);
+                        existingLocalPage.needsServerUpdate = 0;
+                        await existingLocalPage.save();
+                    } else {
+                        const newLocalPage = new Page(
+                            page.UUID,
+                            page.Name,
+                            page.OrgUserId,
+                            page.IsPublic,
+                            page.IsVisibleInMenu,
+                            page.ParentId,
+                            page.NodeIds,
+                            String(page.CreatedAt),
+                            String(page.UpdatedAt),
+                            true,
+                            page.CreatedUserId,
+                            page.UpdateUserId,
+                            page.ChildPageIds,
+                            result.data.noDelete,
+                            result.data.virtual,
+                        );
+
+                        await newLocalPage.save();
+                    }
+
+                    res(page);
+                },
+                error: rej,
+            });
+        });
+    }
+
     async loadNodes(pageId: string, version?: number): Promise<HostRecord[]> {
         return new Promise(async (res, rej) => {
             const existingNodes = await this.db.pageNodes.where({ PageId: pageId }).toArray() as PageNode[];