update

desktop@marha.de/sync.js

@@ -0,0 +1,147 @@
+import Gio from 'gi://Gio';
+import GLib from 'gi://GLib';
+import Soup from 'gi://Soup';
+
+import {readJson, writeJson} from './store.js';
+
+// Abgleich mit dem Server. Zugang steht in sync.json im Datenordner:
+//   {"url": "https://planer.marha.de", "token": "...", "interval": 5}
+// Alle paar Sekunden: eigene Änderungen seit dem letzten Lauf hochladen, Änderungen des Servers
+// seit dem letzten Stand holen. Bei Konflikten gewinnt der Eintrag mit dem neueren updated.
+// sync-state.json merkt sich den Server-Stand (cursor) und was zuletzt übertragen wurde (pushed).
+
+const DEFAULT_INTERVAL = 5;
+
+export class Sync {
+    constructor(store) {
+        this._store = store;
+        this._config = readJson(GLib.build_filenamev([store.dir, 'sync.json']), null);
+        this._statePath = GLib.build_filenamev([store.dir, 'sync-state.json']);
+        this._state = readJson(this._statePath, {cursor: 0, pushed: {events: {}, todos: {}, notes: {}}});
+        this._session = new Soup.Session({timeout: 10});
+        this._busy = false;
+        this._failing = false;
+        this._timerId = null;
+    }
+
+    get active() {
+        return Boolean(this._config?.url && this._config?.token);
+    }
+
+    start() {
+        if (!this.active)
+            return;
+        const interval = this._config.interval ?? DEFAULT_INTERVAL;
+        this._timerId = GLib.timeout_add_seconds(GLib.PRIORITY_DEFAULT, interval, () => {
+            this._cycle().catch(e => this._fail(e.message));
+            return GLib.SOURCE_CONTINUE;
+        });
+        this._cycle().catch(e => this._fail(e.message));
+    }
+
+    stop() {
+        if (this._timerId) {
+            GLib.source_remove(this._timerId);
+            this._timerId = null;
+        }
+        this._session.abort();
+    }
+
+    async _cycle() {
+        if (this._busy)
+            return;
+        this._busy = true;
+        try {
+            const payload = this._collect();
+            const response = await this._post(payload);
+            this._apply(response, payload);
+            if (this._failing) {
+                this._failing = false;
+                console.log('desktop-app sync: Verbindung wieder da');
+            }
+        } finally {
+            this._busy = false;
+        }
+    }
+
+    // Alles, was seit dem letzten Lauf lokal geändert wurde.
+    _collect() {
+        const pushed = this._state.pushed;
+        const store = this._store;
+        const changed = (collection, items) => items.filter(item => pushed[collection][item.id] !== item.updated);
+        const notes = changed('notes', store.listNotes()).map(({id, updated}) => ({id, updated, content: store.readNote(store.absolute(id))}));
+        for (const [id, updated] of Object.entries(store.deletedNotes)) {
+            if (pushed.notes[id] !== updated)
+                notes.push({id, updated, deleted: true});
+        }
+        return {
+            since: this._state.cursor,
+            events: changed('events', store.events),
+            todos: changed('todos', store.todos),
+            notes,
+        };
+    }
+
+    _post(payload) {
+        const message = Soup.Message.new('POST', `${this._config.url}/api/sync`);
+        message.request_headers.append('Authorization', `Bearer ${this._config.token}`);
+        message.set_request_body_from_bytes('application/json', new GLib.Bytes(new TextEncoder().encode(JSON.stringify(payload))));
+        return new Promise((resolve, reject) => {
+            this._session.send_and_read_async(message, GLib.PRIORITY_DEFAULT, null, (session, result) => {
+                try {
+                    const bytes = session.send_and_read_finish(result);
+                    if (message.get_status() !== Soup.Status.OK)
+                        throw new Error(`HTTP ${message.get_status()} ${message.get_reason_phrase()}`);
+                    resolve(JSON.parse(new TextDecoder().decode(bytes.get_data())));
+                } catch (e) {
+                    reject(e);
+                }
+            });
+        });
+    }
+
+    // Antwort einarbeiten. Was der Server zurückschickt und wir gerade hochgeladen haben, kennt er jetzt.
+    _apply(response, payload) {
+        const store = this._store;
+        const pushed = this._state.pushed;
+        for (const collection of ['events', 'todos']) {
+            for (const item of payload[collection])
+                pushed[collection][item.id] = item.updated;
+            store.applyRemote(collection, response[collection]);
+            for (const item of response[collection])
+                pushed[collection][item.id] = item.updated;
+        }
+        for (const note of payload.notes)
+            pushed.notes[note.id] = note.updated;
+
+        // Notizen: ganze Datei, neuere Änderungszeit gewinnt. Eine offene Notiz bleibt unangetastet,
+        // dann rückt der Stand nicht vor und der Server liefert sie beim nächsten Lauf erneut.
+        const local = new Map(store.listNotes().map(n => [n.id, n.updated]));
+        let skipped = false;
+        for (const note of response.notes) {
+            if (store.lockedNote === store.absolute(note.id)) {
+                skipped = true;
+                continue;
+            }
+            const mine = local.get(note.id) ?? store.deletedNotes[note.id];
+            if (mine && mine >= note.updated) {
+                pushed.notes[note.id] = mine;
+                continue;
+            }
+            if (note.deleted)
+                store.deleteRemoteNote(note.id);
+            else
+                store.writeRemoteNote(note.id, note.content, note.updated);
+            pushed.notes[note.id] = note.updated;
+        }
+        if (!skipped)
+            this._state.cursor = response.cursor;
+        writeJson(this._statePath, this._state);
+    }
+
+    _fail(message) {
+        if (!this._failing)
+            console.log(`desktop-app sync: ${message}`);
+        this._failing = true;
+    }
+}