wirc-backend.git

1) type type_event = {
2) 	timestamp: int;
3) 	kind: string;
4) 	data: any;
5) };
6) 
7) 
8) type type_user = {
9) 	name: string;
10) 	role: string;
11) };
12) 
13) 
14) type type_connection = {
15) 	events: Array<type_event>;
16) 	users: Array<type_user>;
17) 	client: any;
18) };
19) 
20) 

21) function get_timestamp(): int
22) {
23) 	return Math.floor(Date.now()/1000);
24) }
25) 

26) 
27) function log(message: string): void
28) {
29) 	process.stderr.write(`-- ${message}\n`);
30) }
31) 
32) 
33) function generate_id(): string
34) {
35) 	return (Math.random() * (1 << 24)).toFixed(0).padStart(8, '0');
36) }
37) 
38) 
39) var connections: Record<string, type_connection> = {};
40) 
41) 
42) function get_connection(data_in: any): type_connection
43) {
44) 	if (! connections.hasOwnProperty(data_in["id"])) {
45) 		throw (new Error("no connection for ID '" + data_in["id"] + "'"));
46) 	}
47) 	else {
48) 		return connections[data_in["id"]];
49) 	}
50) }
51) 
52) 

53) async function main(): Promise<void>
54) {

55) 	var nm_irc: any = require("irc");

56) 	
57) 	const server: lib_server.class_server = new lib_server.class_server(
58) 		7979,
59) 		(input: string) => {
60) 			const request: lib_http.type_request = lib_http.decode_request(input);
61) 			// process.stderr.write(JSON.stringify(request, undefined, "\t") + "\n");
62) 			const data_in: any = JSON.parse(request.body);

63) 			// log(data_in["action"] + " | " + (data_in["id"] ?? "-") + " | " + JSON.stringify(data_in["data"]));

64) 			let data_out: any;
65) 			let error: (null | Error);
66) 			try {
67) 				switch (data_in["action"]) {

68) 					case "connect": {
69) 						if (data_in.hasOwnProperty("id") && connections.hasOwnProperty(data_in["id"])) {

70) 							throw (new Error("already connected"));
71) 						}
72) 						else {

73) 							const id: string = generate_id();

74) 							const client = new nm_irc.Client(
75) 								data_in["data"]["server"],
76) 								data_in["data"]["nickname"],
77) 								{
78) 									"channels": data_in["data"]["channels"],
79) 									"autoConnect": false,
80) 								}
81) 							);

82) 							const connection: type_connection = {
83) 								"client": client,
84) 								"events": [],
85) 								"users": [],
86) 							};

87) 							client.addListener(
88) 								"message",
89) 								(from, to, message) => {

90) 									connection.events.push({

91) 										"timestamp": get_timestamp(),
92) 										"kind": "channel_message",
93) 										"data": {
94) 											"from": from,
95) 											"to": to,
96) 											"message": message,
97) 										}
98) 									});
99) 								}
100) 							);
101) 							client.addListener(
102) 								"pm",
103) 								(from, message) => {

104) 									connection.events.push({

105) 										"timestamp": get_timestamp(),
106) 										"kind": "private_message",
107) 										"data": {
108) 											"from": from,
109) 											"message": message,
110) 										}
111) 									});
112) 								}
113) 							);
114) 							client.addListener(
115) 								"names",
116) 								(channel, users) => {

117) 									connection.users = Object.entries(users).map(([key, value]) => ({"name": key, "role": value.toString()}));

118) 								}
119) 							);
120) 							client.addListener(
121) 								"error",
122) 								(error) => {

123) 									log("error: " + error.message);

124) 								}
125) 							);
126) 							client.connect(
127) 								3,
128) 								() => {

129) 									connections[id] = connection;

130) 								}
131) 							);

132) 							data_out = id;

133) 						}
134) 						break;

135) 					}
136) 					case "check": {
137) 						try {
138) 							get_connection(data_in);
139) 							data_out = true;

140) 						}

141) 						catch (error) {
142) 							data_out = false;

143) 						}
144) 						break;

145) 					}
146) 					case "disconnect": {
147) 						const connection: type_connection = get_connection(data_in);
148) 						delete connections[data_in["id"]];
149) 						connection.client.disconnect("", () => {});
150) 						data_out = null;

151) 						break;

152) 					}
153) 					case "say": {
154) 						const connection: type_connection = get_connection(data_in);
155) 						connection.client.say(data_in["data"]["channel"], data_in["data"]["message"]);
156) 						data_out = null;
157) 						break;
158) 					}
159) 					case "fetch": {
160) 						const connection: type_connection = get_connection(data_in);
161) 						data_out = {
162) 							"users": connection.users,
163) 							"events": connection.events,
164) 						};
165) 						connection.events = [];

166) 						break;

167) 					}

168) 				}
169) 				error = null;
170) 			}
171) 			catch (error_) {

172) 				process.stderr.write(error_.toString() + "\n");

173) 				error = error_;
174) 			}
175) 			const response: lib_http.type_response = (
176) 				(error !== null)
177) 				? {
178) 					"statuscode": 500,
179) 					"headers": {

180) 						"Content-Type": "text/plain",

181) 						"Access-Control-Allow-Origin": "*",
182) 					},

183) 					"body": error.toString(),

184) 				}
185) 				: {
186) 					"statuscode": 200,
187) 					"headers": {

188) 						"Content-Type": "application/json",