From 7bdce37fd3f18e2712e18c4e2c64cac69af0aca1 Mon Sep 17 00:00:00 2001
From: Jakob Stendahl <jakob.stendahl@outlook.com>
Date: Sun, 19 Sep 2021 19:43:11 +0200
Subject: :boom: Introduce new UI based on svelte, and rewrite a lot of the
 node app and the NeoRuntime

---
 src_frontend/stores/socketStore.js | 112 +++++++++++++++++++++++++++++++++++++
 1 file changed, 112 insertions(+)
 create mode 100644 src_frontend/stores/socketStore.js

(limited to 'src_frontend/stores/socketStore.js')

diff --git a/src_frontend/stores/socketStore.js b/src_frontend/stores/socketStore.js
new file mode 100644
index 0000000..d87a075
--- /dev/null
+++ b/src_frontend/stores/socketStore.js
@@ -0,0 +1,112 @@
+import { writable, derived, get } from "svelte/store";
+import { replace } from "svelte-spa-router";
+import { io } from 'socket.io-client';
+import {location, querystring} from 'svelte-spa-router'
+
+export const openSocket = io("/open");
+export let openSocketConnected = writable(false);
+export let openSocketReconnecting = writable(false);
+
+openSocket.on("connect", () => {
+    openSocketConnected.set(true);
+});
+openSocket.on("disconnect", () => {
+    openSocketConnected.set(false);
+});
+openSocket.io.on("reconnect_attempt", () => {
+    openSocketReconnecting.set(true);
+});
+openSocket.io.on("reconnect", () => {
+    openSocketReconnecting.set(false);
+});
+
+export const authorizedSocket = io("/authed", {auth: {token: "te"}});
+export let authorizedSocketConnected = writable(false);
+export let authorizedSocketReconnecting = writable(false);
+export let authorizedSocketConnectError = writable(false);
+export const user = writable({});
+
+authorizedSocket.on("connect_error", (err) => {
+    authorizedSocketConnectError.set(true);
+    authorizedSocketReconnecting.set(false);
+    if ((err.message == "not authorized") &&
+        get(authorizedSocketNeeded) &&
+        (get(location) != "/login")) {
+        replace(`/login?ref=${get(location)}&${get(querystring)}`);
+        authorizedSocketConnected.set(false);
+    }
+});
+authorizedSocket.on("connect", () => {
+    authorizedSocketConnected.set(true);
+    authorizedSocketConnectError.set(false);
+    if (get(location) == "/login") {
+        let searchParams = new URLSearchParams(get(querystring))
+        if (searchParams.has("ref")) {
+            let path = searchParams.get("ref");
+            searchParams.delete("ref");
+            let params = "";
+            if (searchParams.values().length > 0) {
+                params = "?" + searchParams.toString();
+            }
+            replace(`${path}${params}`);
+        } else {
+            replace(`/`);
+        }
+    }
+});
+authorizedSocket.on("disconnect", () => {
+    authorizedSocketConnected.set(false);
+});
+authorizedSocket.io.on("reconnect_attempt", () => {
+    authorizedSocketReconnecting.set(true);
+});
+authorizedSocket.io.on("reconnect", () => {
+    authorizedSocketReconnecting.set(false);
+});
+authorizedSocket.on("user", (userObj) => {
+    user.set(userObj);
+});
+
+
+let storedSessionToken = localStorage.getItem("sessionToken");
+export const isAuthenticating = writable(storedSessionToken != undefined);
+export const sessionToken = writable(storedSessionToken);
+function connectAuthorizedSocket() {
+    authorizedSocket.auth.token = get(sessionToken);
+    authorizedSocket.disconnect().connect();
+}
+sessionToken.subscribe((token) => localStorage.setItem("sessionToken", token));
+sessionToken.subscribe(() => connectAuthorizedSocket());
+
+export const authorizedSocketNeeded = writable(false);
+authorizedSocketNeeded.subscribe((value) => {
+    if (value) { connectAuthorizedSocket(); }
+});
+
+export function authenticate(username, password, callback) {
+    openSocket.emit("authenticate:user", username, password, (res) => {
+        if (res.success) {
+            sessionToken.set(res.token);
+        } else if (res.reason != "Invalid username/password") {
+            console.log(res);
+        }
+        callback(res.success);
+    });
+}
+
+export const connected = writable(false);
+export const reconnecting = writable(false);
+function connectedStateChange() {
+    // console.log(`${get(openSocketConnected)} ${get(authorizedSocketConnectError)} ${get(authorizedSocketReconnecting)}`);
+    connected.set(get(openSocketConnected) 
+                  && (get(authorizedSocketConnectError) 
+                      || get(authorizedSocketConnected)));
+    reconnecting.set(get(openSocketReconnecting) 
+                     && (get(authorizedSocketConnectError) 
+                         || get(authorizedSocketReconnecting)));
+}
+openSocketConnected.subscribe(connectedStateChange);
+openSocketReconnecting.subscribe(connectedStateChange);
+authorizedSocketConnected.subscribe(connectedStateChange);
+authorizedSocketReconnecting.subscribe(connectedStateChange);
+authorizedSocketConnectError.subscribe(connectedStateChange);
-- 
cgit v1.2.3