update server adress

src/rtmt/rtmt_websocket.ts

@@ -1,69 +1,70 @@
-import { decode, encode } from "./encode_decode_message"
+import { decode, encode } from "./encode_decode_message";
-import { Bytes, OnMessage, RTMT } from "./rtmt"
+import { Bytes, OnMessage, RTMT } from "./rtmt";
-import { context } from '../context';
 import { server } from "../service/http_service";
 
 export class RTMTWS implements RTMT {
-
+  private messageChannels: Map<String, OnMessage>;
-    private messageChannels: Map<String, OnMessage>
+  private ws: WebSocket;
-    private ws: WebSocket
 
   constructor() {
-        this.messageChannels = new Map<String, OnMessage>()
+    this.messageChannels = new Map<String, OnMessage>();
   }
 
-    initWebSocket(userKey: string, onopen: () => any, onClose: () => any, onError: (event: Event) => any) {
+  initWebSocket(
-        const url = server.wsServerAdress + '?userKey=' + userKey
+    userKey: string,
-        const ws = new WebSocket(url)
+    onopen: () => any,
+    onClose: () => any,
+    onError: (event: Event) => any
+  ) {
+    const url = server.wsServerAdress + "?userKey=" + userKey;
+    const ws = new WebSocket(url);
     ws.binaryType = "arraybuffer"; //for firefox
     ws.onopen = () => {
-            console.log('(RTMT) ws has opened')
+      console.info("(RTMT) ws has opened");
-            this.ws = ws
+      this.ws = ws;
-            onopen()
+      onopen();
-        }
+    };
     ws.onclose = () => {
-            console.log('(RTMT) ws has closed')
+      console.info("(RTMT) ws has closed");
       //this.ws = undefined
-            onClose()
+      onClose();
-        }
+    };
 
     ws.onmessage = (event: MessageEvent) => {
-            this.onWebSocketMessage(this, event)
+      this.onWebSocketMessage(this, event);
-        }
+    };
 
-        ws.addEventListener("error", ev => {
+    ws.addEventListener("error", (ev) => {
-            console.log({ ws_error: ev });
+      console.error({ ws_error: ev });
-            onError(ev)
+      onError(ev);
-        })
+    });
   }
 
   sendMessage(channel: string, message: Object) {
-        console.log("(RTMT) Sending message to channel " + channel);
     if (this.ws === undefined) {
-            console.log('(RTMT) ws is undefined')
+      console.error("(RTMT) ws is undefined");
-            return
+      return;
     }
-        const data = encode(channel, message)
+    const data = encode(channel, message);
-        this.ws.send(data)
+    this.ws.send(data);
   }
 
   listenMessage(channel: string, callback: OnMessage) {
-        this.messageChannels.set(channel, callback)
+    this.messageChannels.set(channel, callback);
   }
 
   onWebSocketMessage(rtmt: RTMTWS, event: MessageEvent) {
-        const { channel, message } = decode(event.data)
+    const { channel, message } = decode(event.data);
-        console.log("(RTMT) " + { channel, message });
+    rtmt.onMessage(channel, message);
-        rtmt.onMessage(channel, message)
   }
 
   onMessage(channel: string, message: Bytes) {
-        const callback = this.messageChannels.get(channel)
+    const callback = this.messageChannels.get(channel);
 
     if (callback) {
-            callback(message)
+      callback(message);
     } else {
-            console.log("(RTMT) Channel callback not found!" + channel);
+      console.warn("(RTMT) Channel callback not found!" + channel);
     }
   }
 }

src/service/http_service.ts

@@ -1,33 +1,30 @@
 export type Server = {
-    serverAdress: string
+  serverAdress: string;
-    wsServerAdress: string
+  wsServerAdress: string;
-}
+};
 
 export const server: Server = {
-    serverAdress: "https://segin.one/mancala-backend",
+  serverAdress: "https://segin.one/mancala-backend-beta",
-    wsServerAdress: "wss://segin.one/mancala-backend/",
+  wsServerAdress: "wss://segin.one/mancala-backend-beta/",
-}
+};
 
-const useLocal = false
+const useLocal = false;
 
 if (useLocal) {
-    server.serverAdress = "http://localhost:5000"
+  server.serverAdress = "http://localhost:5000";
-    server.wsServerAdress = "ws://localhost:5000"
+  server.wsServerAdress = "ws://localhost:5000";
 }
 
-
 interface HttpService {
-    get: (route: string, succes: () => any, error: () => any) => any
+  get: (route: string, succes: () => any, error: () => any) => any;
 }
 
 class HttpServiceImpl implements HttpService {
-    public serverAdress: string
+  public serverAdress: string;
 
   constructor(serverAdress: string) {
-        this.serverAdress = serverAdress
+    this.serverAdress = serverAdress;
   }
 
-    public get(route: string, succes: () => any, error: () => any): any {
+  public get(route: string, succes: () => any, error: () => any): any {}
-
-    }
 }