tdFszCtS

1import Event from "../model/Event";
2import express from "express";
3import ModelEditor from "../model/ModelEditor";
4import ModelCommandHandler from "./ModelCommandHandler";
5import UserCommandHandler from "./UserCommandHandler";
6import SupplierCommandHandler from "./SupplierCommandHandler";
7import ProductCommandHandler from "./ProductCommandHandler";
8import OrderEventHandler from "./OrderEventHandler";
9import { Pool } from "pg";
10
11export default class SubmitHandler {
12
13    handlers: Map<string, ModelCommandHandler> = new Map();
14
15    eventStore: Map<string, Map<string, Event[]>> = new Map();
16
17    modelEditor: ModelEditor;
18
19    connectionString: string = "postgresql://postgres:admin@localhost:5432/testwarehousedb";
20
21
22    constructor() {
23        this.modelEditor = new ModelEditor();
24        this.handlers.set("users", new UserCommandHandler(this));
25        this.handlers.set("suppliers", new SupplierCommandHandler(this));
26        this.handlers.set("products", new ProductCommandHandler(this));
27        this.handlers.set("orders", new OrderEventHandler(this));
28    }
29
30    async init() {
31        await this.createDatabase();
32        await this.createEventTable();
33    }
34
35    //*<--- DataBase stuff start --->
36    async createDatabase() {
37        let dbsconnectionString = "postgresql://postgres:admin@localhost:5432/";
38        const pool = new Pool({
39            connectionString: dbsconnectionString,
40        })
41
42        try {
43            const res = await pool.query("CREATE DATABASE testwarehousedb;");
44            console.log("CREATE testwarehousedb done!");
45        } catch(e) {
46            console.log(e);
47        }
48        await pool.end();
49    }
50
51    async createEventTable() {
52        const pool = new Pool({
53            connectionString: this.connectionString,
54        })
55
56        const sql = `
57            CREATE TABLE IF NOT EXISTS events (
58                topic varchar NOT NULL,
59                id varchar NOT NULL,
60                storetime varchar NOT NULL,
61                json varchar NOT NULL,
62                PRIMARY KEY (topic, id)
63            );`;
64
65        try {
66            const res = await pool.query(sql);
67            console.log("CREATE events TABLE done!");
68        } catch(e) {
69            console.log(e);
70        }
71
72        await pool.end();
73    }
74    //*<--- DataBase stuff end --->
75
76    static lastStoreTime = "";
77
78    static getNewStoreTime() {
79        let newTime = new Date().toISOString();
80        if(newTime <= SubmitHandler.lastStoreTime) {
81            let timeMillis = new Date(this.lastStoreTime).getUTCMilliseconds();
82            timeMillis++;
83            SubmitHandler.lastStoreTime = new Date(timeMillis).toISOString();
84            return this.lastStoreTime;
85        } else {
86            SubmitHandler.lastStoreTime = newTime;
87            return newTime;
88        }
89    }
90
91    async getLatestEvents(topic: string) : Promise<Event[]>
92    {
93        const eventList: Event[] = [];
94
95        const pool = new Pool({
96            connectionString: this.connectionString,
97        })
98
99        const sql = `
100            SELECT topic, id, storetime, json
101            FROM events
102            WHERE topic='${topic}';`
103
104        try {
105            const res = await pool.query(sql);
106            for(var row of res.rows) {
107                const jsonString = row.json;
108                const event = JSON.parse(jsonString);
109                eventList.push(event);
110            }
111        } catch(e) {
112            console.log(e);
113        }
114        await pool.end();
115
116        return eventList;
117    }
118
119    async getEventHistory(topic: string, id: string) : Promise<Event[]> {
120        const eventList: Event[] = [];
121
122        const pool = new Pool({
123            connectionString: this.connectionString,
124        })
125
126        const sql = `
127            SELECT topic, id, storetime, json
128            FROM events
129            WHERE topic='${topic}' AND id='${id}';`
130
131        try {
132            const res = await pool.query(sql);
133            for(var row of res.rows) {
134                const jsonString = row.json;
135                const event = JSON.parse(jsonString);
136                eventList.push(event);
137            }
138        } catch(e) {
139            console.log(e);
140        }
141        await pool.end();
142
143        return eventList;
144    }
145
146    async putIntoEventStore(event: Event) {
147        const pool = new Pool({
148            connectionString: this.connectionString,
149        })
150
151        var storetime = "2021-01-20";
152        var json = JSON.stringify(event, null, 3);
153
154        const sql = `
155        INSERT INTO events (topic, id, storetime, json)
156        VALUES ('${event.topic}', '${event.id}', '${storetime}', '${json}');`
157
158        try {
159            const res = await pool.query(sql);
160        } 
161        catch(e) {
162            const sql = `
163                UPDATE events
164                SET storetime='${storetime}', json='${json}'
165                WHERE topic='${event.topic}' AND id='${event.id}';`
166
167                try {
168                    const res = await pool.query(sql);
169                }
170                catch(e) {
171                }
172        }
173        await pool.end();
174    }
175
176    async handle(req: express.Request, res: express.Response) {
177        const clientData = req.body;
178        console.log(`got clientdata \n${JSON.stringify(clientData, null, 2)}`);
179
180        const event: Event = clientData;
181
182        const handler = await this.handlers.get(event.topic);
183        await handler.handle(event);
184
185        const result = {
186            status: "OK",
187            clientData,
188        };
189
190        res.json(result);
191    }
192}