Webserver und Datenbank starten sowie Datenabrufen von ioBroker

Server/server/DataHandler.ts

@@ -0,0 +1,51 @@
+import { cfg } from "./Config";
+import { Database } from "./LocalDatabase";
+
+export class DataHandler {
+    private db: &Database;
+
+    constructor(db: &Database) {
+        this.db = db;
+    }
+
+    valid_uri(uri: string) {
+        let found: boolean = false;
+        for(const key of Object.keys(cfg)) {
+            if(cfg[key].uri == uri) {
+                found = true;
+                break;
+            }
+        }
+        return found;
+    }
+
+    get_data_json(uri: string): string {
+        let found: boolean = false;
+        let data: string = '{';
+        let dp;
+        for(const key of Object.keys(cfg)) {
+            if(cfg[key].uri == uri) {
+                found = true;
+                dp = cfg[key];
+                break;
+            }
+        }
+
+        let add_comma: boolean = false;
+        let o = Object.keys(dp);
+        o.forEach(d => {
+            let s = this.db.get(dp[d]);
+            if(s != null) {
+                if(add_comma) {
+                    data += ","
+                }
+                data += '"' + d + '":"' + s + '"';
+                add_comma = true;
+            }
+        });
+
+        data += '}';
+
+        return data;
+    }
+}

Server/server/DataRequester.ts

@@ -0,0 +1,27 @@
+import { IncomingMessage, request } from "http";
+import { Database } from "./LocalDatabase";
+
+export function request_data(id: string, self: &Database): void {
+    let url: string = 'http://192.168.178.34:8082/getBulk/' + id;
+    let data: string = "";
+
+    let req = request(url, (res: IncomingMessage) => {
+        res.setEncoding('utf8');
+
+        res.on('data', (chunk) => {
+          data += chunk;
+        });
+        
+        res.on('end', () => {
+          let d = JSON.parse(data);
+          d.forEach(element => {
+            self.add(element.id, element.val)
+          });
+        });
+    });
+
+    req.on('error', (e) => {
+        console.error(`problem with request: ${e.message}`);
+      });
+    req.end();
+}

Server/server/FileHandler.ts

@@ -1,21 +1,10 @@
 import { existsSync, readFileSync } from 'node:fs';
-import { www_folder, index_alias } from './Webserver';
 
-class Mapping {
+interface Mapping {
     ending: string;
     encoding: string;
 }
 
-const mappings: Mapping[] = [
-    { ending: 'html', encoding: 'text/html' },
-    { ending: 'js', encoding: 'text/javascript' },
-    { ending: 'css', encoding: 'text/css' },
-    { ending: 'json', encoding: 'application/json' },
-    { ending: 'ico', encoding: 'image/x-icon' },
-    { ending: 'svg', encoding: 'image/svg+xml' },
-    { ending: 'txt', encoding: 'text/plain' },
-]
-
 export class File {
     type: string;
     content: Buffer;
@@ -26,37 +15,55 @@ export class File {
     }
 }
 
-export function file_allowed(url: string): boolean { 
+export class FileHandler {
-    let allowed: boolean = false;
-    let m = url.match('\\.\\.');
-    if (m == null) {
-        allowed = true;
-    }
-    return allowed;
-}
 
-export function file_exists(url: string): boolean {
+    private www_folder: string = '/home/carsten/Dokumente/SmartHomeDashboard/html/';
-    if(url == '/') {
+    private index_alias: string = 'index.html';
-        url = index_alias;
-    }
-    return existsSync(www_folder + url);
-}
 
-export function file_get(url: string): File {
+    private mappings: Mapping[] = [
-    if(url == '/') {
+        { ending: 'html', encoding: 'text/html' },
-        url = index_alias;
+        { ending: 'js', encoding: 'text/javascript' },
-    }
+        { ending: 'css', encoding: 'text/css' },
-    return new File(get_type(url), readFileSync(www_folder + url));
+        { ending: 'json', encoding: 'application/json' },
-}
+        { ending: 'ico', encoding: 'image/x-icon' },
+        { ending: 'svg', encoding: 'image/svg+xml' },
+        { ending: 'txt', encoding: 'text/plain' },
+    ]
 
-function get_type(url: string): string {
+
-    if(url == '/') {
+
-        url = index_alias;
+    file_allowed(url: string): boolean { 
+        let allowed: boolean = false;
+        let m = url.match('\\.\\.');
+        if (m == null) {
+            allowed = true;
+        }
+        return allowed;
     }
-    let type: string = 'application/octet-stream';
+
-    let m: Mapping = mappings.find((e) => e.ending == url.split('.').pop());
+    file_exists(url: string): boolean {
-    if(m != undefined) {
+        if(url == '/') {
-        type = m.encoding;
+            url = this.index_alias;
+        }
+        return existsSync(this.www_folder + url);
+    }
+
+    file_get(url: string): File {
+        if(url == '/') {
+            url = this.index_alias;
+        }
+        return new File(this.get_type(url), readFileSync(this.www_folder + url));
+    }
+
+    private get_type(url: string): string {
+        if(url == '/') {
+            url = this.index_alias;
+        }
+        let type: string = 'application/octet-stream';
+        let m: Mapping = this.mappings.find((e) => e.ending == url.split('.').pop());
+        if(m != undefined) {
+            type = m.encoding;
+        }
+        return type;
     }
-    return type;
 }

Server/server/LocalDatabase.ts

@@ -0,0 +1,63 @@
+import { Config, cfg } from "./Config";
+import { request_data } from "./DataRequester";
+
+export class Database {
+    private db: Datapoint[] = [];
+
+    constructor() {
+        let groups = Object.keys(cfg);
+        groups.forEach(group => {
+            let members = Object.keys(cfg[group]);
+            members.forEach(member => {
+                if((member != "text") && (member != "uri")) {
+                    this.add(cfg[group][member])
+                }
+            });
+        });
+    }
+
+    add(id: string, value?: string, type?: string): void {
+        let found: boolean = false;
+        this.db.forEach(element => {
+                if(element.id == id) {
+                    element.value = value;
+                    element.type = type
+                    found = true;
+                }
+        });
+        if(!found) {
+            this.db.push(new Datapoint(id, value, type));
+        }
+    }
+
+    get(id: string): string {
+        for(const el of this.db) {
+            if(el.id == id) {
+                return el.value;
+            }
+        }
+        return null;
+    }
+
+    start(): void {
+        setInterval(this.cyclic_requets, 1000, this);
+    }
+
+    cyclic_requets(self: &Database): void {
+            self.db.forEach(element => {
+                request_data(element.id, self)
+        });
+    }
+}
+
+class Datapoint {
+    id: string;
+    value: string;
+    type: string;
+
+    constructor(id: string, value: string, type: string) {
+        this.id = id;
+        this.type = type;
+        this.value = value;
+    }
+}

Server/server/RequestHandler.ts

@@ -1,19 +1,35 @@
 import { IncomingMessage, ServerResponse } from "node:http";
-import { file_allowed, file_exists, file_get, File } from "./FileHandler";
+import { FileHandler, File } from "./FileHandler";
+import { DataHandler } from "./DataHandler";
+import { Database } from "./LocalDatabase";
 
-export function new_request(req: IncomingMessage, res: ServerResponse): void {
+export class RequestHandler {
-    if(file_allowed(req.url)) {
+    static dh: DataHandler;
-        if(file_exists(req.url)) {
+    private fh: FileHandler;
-            res.statusCode = 200;
+
-            let f: File = file_get(req.url)
+    constructor(db: &Database) {
-            res.setHeader('Content-Type', f.type);
+        RequestHandler.dh = new DataHandler(db);
-            res.end(f.content);
+    }
-        } else {
+
-            res.statusCode = 404;
+    new_request(req: IncomingMessage, res: ServerResponse): void {
-        }
+        if(RequestHandler.dh.valid_uri(req.url)) {
-    } else {
+            res.statusCode = 200;
-        res.statusCode = 403;
+            res.setHeader('Content-Type', 'application/json');
+            res.end(RequestHandler.dh.get_data_json(req.url));
+        }
+        else if(this.fh.file_allowed(req.url)) {
+            if(this.fh.file_exists(req.url)) {
+                res.statusCode = 200;
+                let f: File = this.fh.file_get(req.url)
+                res.setHeader('Content-Type', f.type);
+                res.end(f.content);
+            } else {
+                res.statusCode = 404;
+            }
+        } else {
+            res.statusCode = 403;
+        }
+        console.log(req.url, res.statusCode);
+        res.end();
     }
-    console.log(req.url, res.statusCode);
-    res.end();
 }

Server/server/Webserver.ts

@@ -1,18 +1,22 @@
 import { createServer } from 'node:http'
-import { new_request } from './RequestHandler';
+import { RequestHandler } from './RequestHandler';
+import { Database } from './LocalDatabase';
 
+export class Webserver {
+    private port: number = 8080;
+    private hostname: string = '0.0.0.0';
+    private rh: RequestHandler;
 
-export const www_folder: string = '/home/carsten/Dokumente/SmartHomeDashboard/html/';
+    constructor(db: &Database) {
-export const index_alias: string = 'index.html';
+        this.rh = new RequestHandler(db);
-const port: number = 8080;
+    }
-const hostname: string = '0.0.0.0';
 
+    start_server(): void {
 
-export function start_server(): void {
+        const server = createServer(this.rh.new_request);
-    const server = createServer(new_request);
-
-    server.listen(port, hostname, () => {
-        console.log('Server running at http://' + hostname  + ':' + port);
-    });
-}
 
+        server.listen(this.port, this.hostname, () => {
+            console.log('Server running at http://' + this.hostname  + ':' + this.port);
+        });
+    }
+}

Server/server/main.ts

@@ -1,4 +1,11 @@
-import { start_server } from "./Webserver";
+import { Webserver } from "./Webserver";
+import { Database } from "./LocalDatabase";
 
-start_server();
+let db = new Database();
+let ws = new Webserver(db);
+
+ws.start_server();
 console.log("Server started");
+
+db.start();
+console.log("DB started");