Introducing the new client service provider and removing the old obsolete statistics service

package.json

@@ -109,6 +109,7 @@
     "remarkable": "^2.0.1",
     "resize-observer-polyfill": "^1.5.1",
     "sdp-transform": "^2.14.0",
+    "simple-jsonp-promise": "^1.1.0",
     "simplebar-react": "^2.2.0",
     "twemoji": "^13.0.0",
     "url-knife": "^3.1.3",

shared/js/clientservice/GeoLocation.ts

@@ -0,0 +1,173 @@
+import * as loader from "tc-loader";
+import {Stage} from "tc-loader";
+import {LogCategory, logTrace} from "tc-shared/log";
+import jsonp from 'simple-jsonp-promise';
+
+interface GeoLocationInfo {
+    /* The country code */
+    country: string,
+
+    city?: string,
+    region?: string,
+    timezone?: string
+}
+
+interface GeoLocationResolver {
+    name() : string;
+    resolve() : Promise<GeoLocationInfo>;
+}
+
+const kLocalCacheKey = "geo-info";
+type GeoLocationCache = {
+    version: 1,
+
+    timestamp: number,
+    info: GeoLocationInfo,
+}
+
+class GeoLocationProvider {
+    private readonly resolver: GeoLocationResolver[];
+    private currentResolverIndex: number;
+
+    private cachedInfo: GeoLocationInfo | undefined;
+    private lookupPromise: Promise<GeoLocationInfo>;
+
+    constructor() {
+        this.resolver = [
+            new GeoResolverIpInfo(),
+            new GeoResolverIpData()
+        ];
+        this.currentResolverIndex = 0;
+    }
+
+    loadCache() {
+        this.doLoadCache();
+        if(!this.cachedInfo) {
+            this.lookupPromise = this.doQueryInfo();
+        }
+    }
+
+    private doLoadCache() : GeoLocationInfo {
+        try {
+            const rawItem = localStorage.getItem(kLocalCacheKey);
+            if(!rawItem) {
+                return undefined;
+            }
+
+            const info: GeoLocationCache = JSON.parse(rawItem);
+            if(info.version !== 1) {
+                throw tr("invalid version number");
+            }
+
+            if(info.timestamp + 2 * 24 * 60 * 60 * 1000 < Date.now()) {
+                throw tr("cache is too old");
+            }
+
+            if(info.timestamp + 2 * 60 * 60 * 1000 > Date.now()) {
+                logTrace(LogCategory.GENERAL, tr("Geo cache is less than 2hrs old. Don't updating."));
+                this.lookupPromise = Promise.resolve(info.info);
+            } else {
+                this.lookupPromise = this.doQueryInfo();
+            }
+
+            this.cachedInfo = info.info;
+        } catch (error) {
+            logTrace(LogCategory.GENERAL, tr("Failed to load geo resolve cache: %o"), error);
+        }
+    }
+
+    async queryInfo(timeout: number) : Promise<GeoLocationInfo | undefined> {
+        return await new Promise<GeoLocationInfo>(resolve => {
+            if(!this.lookupPromise) {
+                resolve(this.cachedInfo);
+                return;
+            }
+
+            const timeoutId = typeof timeout === "number" ? setTimeout(() => resolve(this.cachedInfo), timeout) : -1;
+            this.lookupPromise.then(result => {
+                clearTimeout(timeoutId);
+                resolve(result);
+            });
+        });
+    }
+
+
+    private async doQueryInfo() : Promise<GeoLocationInfo | undefined> {
+        while(this.currentResolverIndex < this.resolver.length) {
+            const resolver = this.resolver[this.currentResolverIndex++];
+            try {
+                const info = await resolver.resolve();
+                logTrace(LogCategory.GENERAL, tr("Successfully resolved geo info from %s: %o"), resolver.name(), info);
+
+                localStorage.setItem(kLocalCacheKey, JSON.stringify({
+                    version: 1,
+                    timestamp: Date.now(),
+                    info: info
+                } as GeoLocationCache));
+                return info;
+            } catch (error) {
+                logTrace(LogCategory.GENERAL, tr("Geo resolver %s failed: %o. Trying next one."), resolver.name(), error);
+            }
+        }
+
+        logTrace(LogCategory.GENERAL, tr("All geo resolver failed."));
+        return undefined;
+    }
+}
+
+class GeoResolverIpData implements GeoLocationResolver {
+    name(): string {
+        return "ipdata.co";
+    }
+
+    async resolve(): Promise<GeoLocationInfo> {
+        const response = await fetch("https://api.ipdata.co/?api-key=test");
+        const json = await response.json();
+
+        if(!("country_code" in json)) {
+            throw tr("missing country code");
+        }
+
+        return {
+            country: json["country_code"],
+            region: json["region"],
+            city: json["city"],
+            timezone: json["time_zone"]["name"]
+        }
+    }
+
+}
+
+class GeoResolverIpInfo implements GeoLocationResolver {
+    name(): string {
+        return "ipinfo.io";
+    }
+
+    async resolve(): Promise<GeoLocationInfo> {
+        const response = await jsonp("http://ipinfo.io");
+        if(!("country" in response)) {
+            throw tr("missing country");
+        }
+
+        return {
+            country: response["country"],
+
+            city: response["city"],
+            region: response["region"],
+            timezone: response["timezone"]
+        }
+    }
+
+}
+
+export let geoLocationProvider: GeoLocationProvider;
+
+/* The client services depend on this */
+loader.register_task(Stage.JAVASCRIPT_INITIALIZING, {
+    priority: 35,
+    function: async () => {
+        geoLocationProvider = new GeoLocationProvider();
+        geoLocationProvider.loadCache();
+    },
+    name: "geo services"
+});

shared/js/clientservice/Index.ts

@@ -0,0 +1,442 @@
+import * as loader from "tc-loader";
+import {Stage} from "tc-loader";
+import {LogCategory, logDebug, logError, logInfo, logTrace, logWarn} from "tc-shared/log";
+import {Registry} from "tc-shared/events";
+import {
+    CommandSessionInitializeAgent, CommandSessionUpdateLocale,
+    Message,
+    MessageCommand,
+    MessageCommandResult,
+    MessageNotify,
+    NotifyClientsOnline
+} from "./messages";
+import {config, tr} from "tc-shared/i18n/localize";
+import {geoLocationProvider} from "tc-shared/clientservice/GeoLocation";
+import translation_config = config.translation_config;
+import {getBackend} from "tc-shared/backend";
+
+const kApiVersion = 1;
+const kVerbose = true;
+
+type ConnectionState = "disconnected" | "connecting" | "connected" | "reconnect-pending";
+type PendingCommand = {
+    resolve: (result: MessageCommandResult) => void,
+    timeout: number
+};
+
+interface ClientServiceConnectionEvents {
+    notify_state_changed: { oldState: ConnectionState, newState: ConnectionState },
+    notify_notify_received: { notify: MessageNotify }
+}
+
+let tokenIndex = 0;
+class ClientServiceConnection {
+    readonly events: Registry<ClientServiceConnectionEvents>;
+    readonly verbose: boolean;
+    readonly reconnectInterval: number;
+
+    private reconnectTimeout: number;
+    private connectionState: ConnectionState;
+    private connection: WebSocket;
+
+    private pendingCommands: {[key: string]: PendingCommand} = {};
+
+    constructor(reconnectInterval: number, verbose: boolean) {
+        this.events = new Registry<ClientServiceConnectionEvents>();
+        this.reconnectInterval = reconnectInterval;
+        this.verbose = verbose;
+    }
+
+    destroy() {
+        this.disconnect();
+        this.events.destroy();
+    }
+
+    getState() : ConnectionState {
+        return this.connectionState;
+    }
+
+    private setState(newState: ConnectionState) {
+        if(this.connectionState === newState) {
+            return;
+        }
+
+        const oldState = this.connectionState;
+        this.connectionState = newState;
+        this.events.fire("notify_state_changed", { oldState, newState })
+    }
+
+    connect() {
+        this.disconnect();
+
+        this.setState("connecting");
+
+        let address;
+        address = "client-services.teaspeak.de:27791";
+        //address = "localhost:1244";
+
+        this.connection = new WebSocket(`wss://${address}/ws-api/v${kApiVersion}`);
+        this.connection.onclose = event => {
+            if(this.verbose) {
+                logInfo(LogCategory.STATISTICS, tr("Lost connection to statistics server (Connection closed). Reason: %s"), event.reason ? `${event.reason} (${event.code})` : event.code);
+            }
+
+            this.handleConnectionLost();
+        };
+
+        this.connection.onopen = () => {
+            if(this.verbose) {
+                logDebug(LogCategory.STATISTICS, tr("Connection established."));
+            }
+
+            this.setState("connected");
+        }
+
+        this.connection.onerror = () => {
+            if(this.connectionState === "connecting") {
+                if(this.verbose) {
+                    logDebug(LogCategory.STATISTICS, tr("Failed to connect to target server."));
+                }
+
+                this.handleConnectFail();
+            } else {
+                if(this.verbose) {
+                    logWarn(LogCategory.STATISTICS, tr("Received web socket error which indicates that the connection has been closed."));
+                }
+
+                this.handleConnectionLost();
+            }
+        };
+
+        this.connection.onmessage = event => {
+            if(typeof event.data !== "string") {
+                if(this.verbose) {
+                    logWarn(LogCategory.STATISTICS, tr("Receved non text message: %o"), event.data);
+                }
+
+                return;
+            }
+
+            this.handleServerMessage(event.data);
+        };
+    }
+
+    disconnect() {
+        if(this.connection) {
+            this.connection.onclose = undefined;
+            this.connection.onopen = undefined;
+            this.connection.onmessage = undefined;
+            this.connection.onerror = undefined;
+
+            this.connection.close();
+            this.connection = undefined;
+        }
+
+        for(const command of Object.values(this.pendingCommands)) {
+            command.resolve({ type: "ConnectionClosed" });
+        }
+        this.pendingCommands = {};
+
+        clearTimeout(this.reconnectTimeout);
+        this.reconnectTimeout = undefined;
+
+        this.setState("disconnected");
+    }
+
+    cancelReconnect() {
+        clearTimeout(this.reconnectTimeout);
+        this.reconnectTimeout = undefined;
+
+        if(this.connectionState === "reconnect-pending") {
+            this.setState("disconnected");
+        }
+    }
+
+    async executeCommand(command: MessageCommand) : Promise<MessageCommandResult> {
+        if(this.connectionState !== "connected") {
+            return { type: "ConnectionClosed" };
+        }
+
+        const token = "tk-" + ++tokenIndex;
+        try {
+            this.connection.send(JSON.stringify({
+                type: "Command",
+                token: token,
+                command: command
+            } as Message));
+        } catch (error) {
+            if(this.verbose) {
+                logError(LogCategory.STATISTICS, tr("Failed to send command: %o"), error);
+            }
+
+            return { type: "GenericError", error: tr("Failed to send command") };
+        }
+
+        return await new Promise(resolve => {
+            const proxiedResolve = (result: MessageCommandResult) => {
+                clearTimeout(this.pendingCommands[token]?.timeout);
+                delete this.pendingCommands[token];
+                resolve(result);
+            };
+
+            this.pendingCommands[token] = {
+                resolve: proxiedResolve,
+                timeout: setTimeout(() => proxiedResolve({ type: "ConnectionTimeout" }), 5000)
+            };
+        });
+    }
+
+    private handleConnectFail() {
+        this.disconnect();
+        this.executeReconnect();
+    }
+
+    private handleConnectionLost() {
+        this.disconnect();
+        this.executeReconnect();
+    }
+
+    private executeReconnect() {
+        if(!this.reconnectInterval) {
+            return;
+        }
+
+        if(this.verbose) {
+            logInfo(LogCategory.STATISTICS, tr("Scheduling reconnect in %dms"), this.reconnectInterval);
+        }
+
+        this.reconnectTimeout = setTimeout(() => this.connect(), this.reconnectInterval);
+        this.setState("reconnect-pending");
+    }
+
+    private handleServerMessage(message: string) {
+        let data: Message;
+        try {
+            data = JSON.parse(message);
+        } catch (_error) {
+            if(this.verbose) {
+                logWarn(LogCategory.STATISTICS, tr("Received message which isn't parsable as JSON."));
+            }
+            return;
+        }
+
+        if(data.type === "Command") {
+            if(this.verbose) {
+                logWarn(LogCategory.STATISTICS, tr("Received message of type command. The server should not send these. Message: %o"), data);
+            }
+
+            /* Well this is odd. We should never receive such */
+        } else if(data.type === "CommandResult") {
+            if(data.token === null) {
+                if(this.verbose) {
+                    logWarn(LogCategory.STATISTICS, tr("Received general error: %o"), data.result);
+                }
+            } else if(this.pendingCommands[data.token]) {
+                /* The entry itself will be cleaned up by the resolve callback */
+                this.pendingCommands[data.token].resolve(data.result);
+            } else if(this.verbose) {
+                logWarn(LogCategory.STATISTICS, tr("Received command result for unknown token: %o"), data.token);
+            }
+        } else if(data.type === "Notify") {
+            this.events.fire("notify_notify_received", { notify: data.notify });
+        } else if(this.verbose) {
+            logWarn(LogCategory.STATISTICS, tr("Received message with invalid type: %o"), (data as any).type);
+        }
+    }
+}
+
+export class ClientServices {
+    private connection: ClientServiceConnection;
+
+    private sessionInitialized: boolean;
+    private retryTimer: number;
+
+    private initializeAgentId: number;
+    private initializeLocaleId: number;
+
+    constructor() {
+        this.initializeAgentId = 0;
+        this.initializeLocaleId = 0;
+
+        this.sessionInitialized = false;
+        this.connection = new ClientServiceConnection(5000, kVerbose);
+        this.connection.events.on("notify_state_changed", event => {
+            if(event.newState !== "connected") {
+                this.sessionInitialized = false;
+                return;
+            }
+
+            logInfo(LogCategory.STATISTICS, tr("Connected successfully. Initializing session."));
+            this.executeCommandWithRetry({ type: "SessionInitialize", payload: { anonymize_ip: false }}, 2500).then(result => {
+                if(result.type !== "Success") {
+                    if(result.type === "ConnectionClosed") {
+                        return;
+                    }
+
+                    if(kVerbose) {
+                        logError(LogCategory.STATISTICS, tr("Failed to initialize session. Retrying in 120 seconds. Result: %o"), result);
+                    }
+
+                    this.scheduleRetry(120 * 1000);
+                    return;
+                }
+
+                this.sendInitializeAgent().then(undefined);
+                this.sendLocaleUpdate();
+            });
+        });
+
+        this.connection.events.on("notify_notify_received", event => {
+            switch (event.notify.type) {
+                case "NotifyClientsOnline":
+                    this.handleNotifyClientsOnline(event.notify.payload);
+                    break;
+
+                default:
+                    return;
+            }
+        });
+    }
+
+    start() {
+        this.connection.connect();
+    }
+
+    stop() {
+        this.connection.disconnect();
+        clearTimeout(this.retryTimer);
+
+        this.initializeAgentId++;
+        this.initializeLocaleId++;
+    }
+
+    private scheduleRetry(time: number) {
+        this.stop();
+
+        this.retryTimer = setTimeout(() => this.connection.connect(), time);
+    }
+
+    /**
+     * Returns as soon the result indicates that something else went wrong rather than transmitting.
+     * @param command
+     * @param retryInterval
+     */
+    private async executeCommandWithRetry(command: MessageCommand, retryInterval: number) : Promise<MessageCommandResult> {
+        while(true) {
+            const result = await this.connection.executeCommand(command);
+            switch (result.type) {
+                case "ServerInternalError":
+                case "CommandEnqueueError":
+                case "ClientSessionUninitialized":
+                    const shouldRetry = await new Promise<boolean>(resolve => {
+                        const timeout = setTimeout(() => {
+                            listener();
+                            resolve(true);
+                        }, 2500);
+
+                        const listener = this.connection.events.on("notify_state_changed", event => {
+                            if(event.newState !== "connected") {
+                                resolve(false);
+                                clearTimeout(timeout);
+                            }
+                        })
+                    });
+
+                    if(shouldRetry) {
+                        continue;
+                    } else {
+                        return result;
+                    }
+
+                default:
+                    return result;
+            }
+        }
+    }
+
+    private async sendInitializeAgent() {
+        const taskId = ++this.initializeAgentId;
+        const payload: CommandSessionInitializeAgent = {
+            session_type: __build.target === "web" ? 0 : 1,
+            architecture: null,
+            platform_version: null,
+            platform: null,
+            client_version: null,
+            ui_version: __build.version
+        };
+
+        if(__build.target === "client") {
+            const info = getBackend("native").getVersionInfo();
+
+            payload.client_version = info.version;
+            payload.architecture = info.os_architecture;
+            payload.platform = info.os_platform;
+            payload.platform_version = info.os_platform_version;
+        } else {
+            const os = window.detectedBrowser.os;
+            const osParts = os.split(" ");
+            if(osParts.last().match(/^[0-9]+$/)) {
+                payload.platform_version = osParts.last();
+                osParts.splice(osParts.length - 1, 1);
+            }
+
+            payload.platform = osParts.join(" ");
+            payload.architecture = window.detectedBrowser.name;
+            payload.client_version = window.detectedBrowser.version;
+        }
+
+        if(this.initializeAgentId !== taskId) {
+            /* We don't want to send that stuff any more */
+            return;
+        }
+
+        this.executeCommandWithRetry({ type: "SessionInitializeAgent", payload }, 2500).then(result => {
+            if(kVerbose) {
+                logTrace(LogCategory.STATISTICS, tr("Agent initialize result: %o"), result);
+            }
+        });
+    }
+
+    private async sendLocaleUpdate() {
+        const taskId = ++this.initializeLocaleId;
+
+        const payload: CommandSessionUpdateLocale = {
+            ip_country: null,
+            selected_locale: null,
+            local_timestamp: Date.now()
+        };
+
+        const geoInfo = await geoLocationProvider.queryInfo(2500);
+        payload.ip_country = geoInfo?.country?.toLowerCase() || null;
+
+        const trConfig = translation_config();
+        payload.selected_locale = trConfig?.current_translation_url || null;
+
+        if(this.initializeLocaleId !== taskId) {
+            return;
+        }
+
+        this.connection.executeCommand({ type: "SessionUpdateLocale", payload }).then(result => {
+            if(kVerbose) {
+                logTrace(LogCategory.STATISTICS, tr("Agent local update result: %o"), result);
+            }
+        });
+    }
+
+    private handleNotifyClientsOnline(notify: NotifyClientsOnline) {
+        logInfo(LogCategory.GENERAL, tr("Received user count update: %o"), notify);
+    }
+}
+
+export let clientServices: ClientServices;
+
+loader.register_task(Stage.JAVASCRIPT_INITIALIZING, {
+    priority: 30,
+    function: async () => {
+        clientServices = new ClientServices();
+        clientServices.start();
+
+        (window as any).clientServices = clientServices;
+    },
+    name: "client services"
+});

shared/js/clientservice/messages.d.ts

@@ -0,0 +1,38 @@
+/* Basic message declarations */
+export type Message =
+    | { type: "Command"; token: string; command: MessageCommand }
+    | {     type: "CommandResult"; token: string | null; result:     MessageCommandResult }
+    | { type: "Notify"; notify: MessageNotify };
+
+export type MessageCommand =
+    | { type: "SessionInitialize"; payload: CommandSessionInitialize }
+    | { type: "SessionInitializeAgent"; payload: CommandSessionInitializeAgent }
+    | { type: "SessionUpdateLocale"; payload: CommandSessionUpdateLocale };
+
+export type MessageCommandResult =
+    | { type: "Success" }
+    | { type: "GenericError"; error: string }
+    | { type: "ConnectionTimeout" }
+    | { type: "ConnectionClosed" }
+    | { type: "ClientSessionUninitialized" }
+    | { type: "ServerInternalError" }
+    | { type: "ParameterInvalid"; parameter: string }
+    | { type: "CommandParseError"; error: string }
+    | { type: "CommandEnqueueError" }
+    | { type: "CommandNotFound" }
+    | { type: "SessionAlreadyInitialized" }
+    | { type: "SessionAgentAlreadyInitialized" }
+    | { type: "SessionNotInitialized" };
+
+export type MessageNotify =
+    | { type: "NotifyClientsOnline"; payload: NotifyClientsOnline };
+
+/* All commands */
+export type CommandSessionInitialize = { anonymize_ip: boolean };
+
+export type CommandSessionInitializeAgent = {     session_type: number; platform: string | null; platform_version:     string | null; architecture: string | null; client_version: string |     null; ui_version: string | null };
+
+export type CommandSessionUpdateLocale = {     ip_country: string | null; selected_locale: string | null;     local_timestamp: number };
+
+/* Notifies */
+export type NotifyClientsOnline = {     users_online: { [key: number]: number }; unique_users_online:     { [key: number]: number }; total_users_online: number;     total_unique_users_online: number };

shared/js/main.tsx

@@ -2,7 +2,6 @@ import * as loader from "tc-loader";
 import * as bipc from "./ipc/BrowserIPC";
 import * as sound from "./sound/Sounds";
 import * as i18n from "./i18n/localize";
-import * as stats from "./stats";
 import * as fidentity from "./profiles/identities/TeaForumIdentity";
 import * as aplayer from "tc-backend/audio/player";
 import * as ppt from "tc-backend/ppt";
@@ -46,6 +45,7 @@ import "./ui/frames/menu-bar/MainMenu";
 import "./ui/modal/connect/Controller";
 import "./ui/elements/ContextDivider";
 import "./ui/elements/Tab";
+import "./clientservice";
 import {initializeKeyControl} from "./KeyControl";
 
 let preventWelcomeUI = false;
@@ -89,6 +89,7 @@ async function initializeApp() {
     }
 }
 
+/* Used by the native client... We can't refactor this yet */
 export function handle_connect_request(properties: ConnectRequestData, connection: ConnectionHandler) {
     const profile = findConnectProfile(properties.profile) || defaultConnectProfile();
     const username = properties.username || profile.connectUsername();
@@ -183,16 +184,6 @@ function main() {
     fidentity.update_forum();
     initializeKeyControl();
 
-    stats.initialize({
-        verbose: true,
-        anonymize_ip_addresses: true,
-        volatile_collection_only: false
-    });
-
-    stats.registerUserCountListener(status => {
-        logInfo(LogCategory.STATISTICS, tr("Received user count update: %o"), status);
-    });
-
     checkForUpdatedApp();
 
     if(settings.getValue(Settings.KEY_USER_IS_NEW) && !preventWelcomeUI) {

shared/js/stats.ts

@@ -1,239 +0,0 @@
-import {LogCategory, logDebug, logInfo, logTrace, logWarn} from "./log";
-import { tr } from "./i18n/localize";
-
-enum CloseCodes {
-    UNSET = 3000,
-    RECONNECT = 3001,
-    INTERNAL_ERROR = 3002,
-
-    BANNED = 3100,
-}
-
-enum ConnectionState {
-    CONNECTING,
-    INITIALIZING,
-    CONNECTED,
-    UNSET
-}
-
-export class SessionConfig {
-    /*
-     * All collected statistics will only be cached by the stats server.
-     * No data will be saved.
-     */
-    volatile_collection_only?: boolean;
-
-    /*
-     * Anonymize all IP addresses which will be provided while the stats collection.
-     * This option is quite useless when volatile_collection_only is active.
-     */
-    anonymize_ip_addresses?: boolean;
-}
-
-export class Config extends SessionConfig {
-    verbose?: boolean;
-
-    reconnect_interval?: number;
-}
-
-export interface UserCountData {
-    online_users: number;
-    unique_online_users: number;
-}
-
-export type UserCountListener = (data: UserCountData) => any;
-
-let reconnect_timer: number;
-let current_config: Config;
-
-let last_user_count_update: number;
-let user_count_listener: UserCountListener[] = [];
-
-const DEFAULT_CONFIG: Config = {
-    verbose: true,
-    reconnect_interval: 5000,
-    anonymize_ip_addresses: true,
-    volatile_collection_only: false
-};
-
-function initialize_config_object(target_object: any, source_object: any) : any {
-    for(const key of Object.keys(source_object)) {
-        if(typeof(source_object[key]) === 'object')
-            initialize_config_object(target_object[key] || (target_object[key] = {}), source_object[key]);
-
-        if(typeof(target_object[key]) !== 'undefined')
-            continue;
-
-        target_object[key] = source_object[key];
-    }
-
-    return target_object;
-}
-
-export function initialize(config: Config) {
-    current_config = initialize_config_object(config || {}, DEFAULT_CONFIG);
-    if(current_config.verbose)
-        logInfo(LogCategory.STATISTICS, tr("Initializing statistics with this config: %o"), current_config);
-
-    connection.start_connection();
-}
-
-export function registerUserCountListener(listener: UserCountListener) {
-    user_count_listener.push(listener);
-}
-
-export function unregisterUserCountListener(listener: UserCountListener) {
-    user_count_listener.remove(listener);
-}
-
-namespace connection {
-    let connection: WebSocket;
-    export let connection_state: ConnectionState = ConnectionState.UNSET;
-
-    export function start_connection() {
-        cancel_reconnect();
-        close_connection();
-
-        connection_state = ConnectionState.CONNECTING;
-
-        connection = new WebSocket('wss://web-stats.teaspeak.de:27790');
-        if(!connection) {
-            connection = new WebSocket('wss://localhost:27788');
-        }
-
-        {
-            const connection_copy = connection;
-            connection.onclose = (event: CloseEvent) => {
-                if(connection_copy !== connection) return;
-
-                if(current_config.verbose)
-                    logWarn(LogCategory.STATISTICS, tr("Lost connection to statistics server (Connection closed). Reason: %o. Event object: %o"), CloseCodes[event.code] || event.code, event);
-
-                if(event.code != CloseCodes.BANNED)
-                    invoke_reconnect();
-            };
-
-            connection.onopen = () => {
-                if(connection_copy !== connection) return;
-
-                if(current_config.verbose)
-                    logDebug(LogCategory.STATISTICS, tr("Successfully connected to server. Initializing session."));
-
-                connection_state = ConnectionState.INITIALIZING;
-                initialize_session();
-            };
-
-            connection.onerror = (event: ErrorEvent) => {
-                if(connection_copy !== connection) return;
-
-                if(current_config.verbose)
-                    logWarn(LogCategory.STATISTICS, tr("Received an error. Closing connection. Object: %o"), event);
-
-                connection.close(CloseCodes.INTERNAL_ERROR);
-                invoke_reconnect();
-            };
-
-            connection.onmessage = (event: MessageEvent) => {
-                if(connection_copy !== connection) return;
-
-                if(typeof(event.data) !== 'string') {
-                    if(current_config.verbose)
-                        logWarn(LogCategory.STATISTICS, tr("Received an message which isn't a string. Event object: %o"), event);
-                    return;
-                }
-
-                handle_message(event.data as string);
-            };
-        }
-    }
-
-    export function close_connection() {
-        if(connection) {
-            const connection_copy = connection;
-            connection = undefined;
-
-            try {
-                connection_copy.close(3001);
-            } catch(_) {}
-        }
-    }
-
-    function invoke_reconnect() {
-        close_connection();
-
-        if(reconnect_timer) {
-            clearTimeout(reconnect_timer);
-            reconnect_timer = undefined;
-        }
-
-        if(current_config.verbose)
-            logInfo(LogCategory.STATISTICS, tr("Scheduled reconnect in %dms"), current_config.reconnect_interval);
-
-        reconnect_timer = setTimeout(() => {
-            if(current_config.verbose)
-                logInfo(LogCategory.STATISTICS, tr("Reconnecting"));
-            start_connection();
-        }, current_config.reconnect_interval);
-    }
-
-    export function cancel_reconnect() {
-        if(reconnect_timer) {
-            clearTimeout(reconnect_timer);
-            reconnect_timer = undefined;
-        }
-    }
-
-    function send_message(type: string, data: any) {
-        connection.send(JSON.stringify({
-            type: type,
-            data: data
-        }));
-    }
-
-    function initialize_session() {
-        const config_object = {};
-        for(const key in SessionConfig) {
-            if(SessionConfig.hasOwnProperty(key))
-                config_object[key] = current_config[key];
-        }
-
-        send_message('initialize', {
-            config: config_object
-        })
-    }
-
-    function handle_message(message: string) {
-        const data_object = JSON.parse(message);
-        const type = data_object.type as string;
-        const data = data_object.data;
-
-        if(typeof(handler[type]) === 'function') {
-            if(current_config.verbose)
-                logTrace(LogCategory.STATISTICS, tr("Handling message of type %s"), type);
-            handler[type](data);
-        } else if(current_config.verbose) {
-            logWarn(LogCategory.STATISTICS, tr("Received message with an unknown type (%s). Dropping message. Full message: %o"), type, data_object);
-        }
-    }
-
-    namespace handler {
-        interface NotifyUserCount extends UserCountData { }
-
-        function handle_notify_user_count(data: NotifyUserCount) {
-            last_user_count_update = Date.now();
-            for(const listener of [...user_count_listener])
-                listener(data);
-        }
-
-        interface NotifyInitialized {}
-        function handle_notify_initialized(json: NotifyInitialized) {
-            if(current_config.verbose)
-                logInfo(LogCategory.STATISTICS, tr("Session successfully initialized."));
-
-            connection_state = ConnectionState.CONNECTED;
-        }
-
-        handler["notifyinitialized"] = handle_notify_initialized;
-        handler["notifyusercount"] = handle_notify_user_count;
-    }
-}

shared/js/ui/modal/global-settings-editor/Controller.tsx

@@ -26,7 +26,7 @@ function initializeController(events: Registry<ModalGlobalSettingsEditorEvents>)
                 key: setting.key,
                 description: setting.description,
                 type: setting.valueType,
-                defaultValue: "defaultValue" in setting ? setting.defaultValue : undefined
+                defaultValue: "defaultValue" in setting ? (setting as any).defaultValue : undefined
             });
         }
 
@@ -54,7 +54,7 @@ function initializeController(events: Registry<ModalGlobalSettingsEditorEvents>)
                 key: setting.key,
                 description: setting.description,
                 type: setting.valueType,
-                defaultValue: "defaultValue" in setting ? setting.defaultValue : undefined
+                defaultValue: "defaultValue" in setting ? (setting as any).defaultValue : undefined
             },
             value: settings.getValue(setting, undefined)
         });

shared/tsconfig/tsconfig.declarations.json

@@ -21,6 +21,7 @@
   ],
   "include": [
     "../js/proto.ts",
+    "../js/main.tsx",
     "../backend.d",
     "../js/**/*.ts",
     "../../webpack/build-definitions.d.ts"

web/app/connection/WrappedWebSocket.ts

@@ -1,4 +1,3 @@
-import * as log from "tc-shared/log";
 import {LogCategory, logWarn} from "tc-shared/log";
 import {ConnectionStatistics} from "tc-shared/connection/ConnectionBase";
 import { tr } from "tc-shared/i18n/localize";
@@ -46,8 +45,9 @@ export class WrappedWebSocket {
         let result = "";
         result += this.address.secure ? "wss://" : "ws://";
         result += this.address.host + ":" + this.address.port;
-        if(this.address.path)
+        if(this.address.path) {
             result += (this.address.path.startsWith("/") ? "" : "/") + this.address.path;
+        }
         return result
     }