1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
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);
});
let storedSessionToken = localStorage.getItem("sessionToken");
export const authorizedSocket = io("/authed", {auth: {token: (storedSessionToken == null) ? "" : storedSessionToken}});
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);
});
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);
|
