node-red-contrib-teamogy-api 0.0.2 → 0.0.6

package/teamogy-client.js

@@ -1,7 +1,75 @@
 function isEmpty(value) { return (value == null || (typeof value === "string" && value.trim().length === 0)); }
 
 module.exports = function(RED) {
-	
+
+	if (typeof globalNextAvailableSlot === 'undefined') {
+		var globalNextAvailableSlot = Date.now();
+	}
+
+	async function fetchWithRetry(url, options, retries, delay, node, limit) {
+
+		const minInterval = 60000 / limit;
+
+		for (let i = 0; i <= retries; i++) {
+			try {
+				let now = Date.now();
+				let waitTime = 0;
+
+				let scheduledTime = Math.max(now, globalNextAvailableSlot);
+				globalNextAvailableSlot = scheduledTime + minInterval;
+
+				waitTime = scheduledTime - now;
+
+				if (waitTime > 0) {
+					await new Promise(resolve => setTimeout(resolve, waitTime));
+				}
+
+				if (node.closingId == node.id) {
+					return { status: 0 };
+				}
+
+				const response = await fetch(url, options);
+
+				if (response.status >= 200 && response.status < 300) {
+					return response;
+				}
+
+				let o = {
+					status: response.status,
+					message: await response.text() ?? '',
+					attempt: i + 1,
+					delay: delay / 1000
+				};
+				node.warn(o);
+
+				await new Promise(resolve => setTimeout(resolve, delay));
+
+			} catch (error) {
+				let o = {
+					status: 0,
+					message: 'Request failed: ' + error.message,
+					attempt: i + 1,
+					delay: delay / 1000
+				};
+				node.warn(o);
+				await new Promise(resolve => setTimeout(resolve, delay));
+			}
+		}
+		return null;
+	}
+
+	function getConfigId(name) {
+        var configNodes = [];
+        RED.nodes.eachNode(function(node) {
+            if (node.type === "teamogy-config") {
+                configNodes.push(node);
+            }
+        });
+
+		const configId = configNodes.find(item => item.name === name)?.id;
+		return configId;
+	}
+
 	function ConnectionNode(n) {
 		try {
 			RED.nodes.createNode(this, n);
@@ -19,12 +87,16 @@ module.exports = function(RED) {
 				let cache = []
 				this.context().global.set('cache_' + this.host, cache)
 			}
+			
+			if(typeof this.context().global.get('count_' + this.host ) == 'undefined') {
+				this.context().global.set('count_' + this.host, 0)
+			}
 		
 		} catch (e) {
-			node.error(e);
+			this.error(e.message);
 		}
 	}
-  
+
 	RED.nodes.registerType('teamogy-config', ConnectionNode, {
 		credentials: {
 			token: {type: 'password'}
@@ -34,7 +106,9 @@ module.exports = function(RED) {
 	function teamogyClient(data) {
 		try {
 			var node = this;
-
+			
+			node.closingId = '';
+			
 			RED.nodes.createNode(node,data);
 
 			this.config = RED.nodes.getNode(data.configuration);
@@ -42,9 +116,12 @@ module.exports = function(RED) {
 			let token = this.config.credentials.token
 			let host = this.config.host.replace(/^https?:\/\//, '').split('/')[0];
 			let unit = this.config.unit
+			let connName = this.config.name
+			let apiLimit = this.config.apilimit
 		
 			let clientid = data.id
 			let c = this.context().global.get('cache_' + host)
+			let ct = this.context().global.get('count_' + host)
 			let st = null;
 
 			async function sendmsg(mesg) {
@@ -56,7 +133,12 @@ module.exports = function(RED) {
 					let mlimit = 0
 					let mpaging = 1000
 					let moffset = 0
-					
+					let entity = '' 
+					let method = 'GET'
+					let delay = 0;
+					let repeat = 5;
+					let rdelay = 30;
+
 					if(data.source=='dynamic') {
 						if(typeof msg.params == 'string') { mparams = msg.params }
 						if(typeof msg.params == 'object') {
@@ -74,11 +156,30 @@ module.exports = function(RED) {
 						if(typeof msg[data.bodysource] == 'string') { body = msg[data.bodysource] }
 						if(typeof msg[data.bodysource] == 'object') { body = JSON.stringify(msg[data.bodysource]) }
 
-						if(typeof msg.merge == 'boolean') { mmerge = msg.merge }
-						if(typeof msg.limit == 'number') { mlimit = msg.limit }
-						if(typeof msg.paging == 'number') { mpaging = msg.paging }
-						if(typeof msg.offset == 'number') { moffset = msg.offset }
+						if(typeof msg.merge == 'boolean') { mmerge = msg.merge } 
+						if(typeof msg.limit == 'number') { mlimit = msg.limit } 
+						if(typeof msg.paging == 'number') { mpaging = msg.paging } 
+						if(typeof msg.offset == 'number') { moffset = msg.offset } 
+						if(typeof msg.unit == 'number') { unit = msg.unit } 
+						if(typeof msg.entity == 'string') { entity = msg.entity } else { entity = data.entity }
+						if(typeof msg.method == 'string') { method = msg.method } else { method = data.method }
+						if(typeof msg.delay == 'number') { delay = msg.delay * 1000 } else { delay = data.delay * 1000 }
+						if(typeof msg.repeat == 'number') { repeat = msg.repeat ?? 5 } else { repeat = data.repeat ?? 5 }
+						if(typeof msg.rdelay == 'number') { rdelay = msg.rdelay * 1000 } else { rdelay = data.rdelay * 1000 }
 	
+						if(typeof msg.connection == 'string') {
+							if(msg.connection) {
+								const customConfig = RED.nodes.getNode(getConfigId(msg.connection));
+								if(customConfig) {
+									token = customConfig.credentials.token;
+									host = customConfig.host.replace(/^https?:\/\//, '').split('/')[0];
+									unit = customConfig.unit;
+								} else {
+									node.warn("Specified connection not found: " + msg.connection + ", using default: " + connName);
+								}
+							}
+						}
+					
 					}
 					
 					if(data.source=='static') {
@@ -95,50 +196,54 @@ module.exports = function(RED) {
 						mlimit = data.limit
 						mpaging = data.paging
 						moffset = data.offset
+						entity = data.entity
+						method = data.method
+						delay = data.delay * 1000
+						repeat = data.repeat ?? 5
+						rdelay = data.rdelay * 1000
 					}
-					
+
 					const headers = {
 						'Authorization': 'Bearer ' + token,
 						'Accept': 'application/json',
 						'Content-type': 'application/json'
 					};
-					
+
 					let url = `https://${host}/rest/v1/${unit}/`
 
-					if(data.entity.split('_')[0] == 'v') { url = url + 'views/'}
+					if(entity.split('_')[0] == 'v') { url = url + 'views/'}
 					
-					url = url + data.entity.split('_')[1].replaceAll('-','.')
+					url = url + entity.substring(entity.indexOf('_') + 1).replaceAll('-','.')
 					
 					if(!isEmpty(mparams)) { url = url + '?' + mparams }
-
+					
 					const doAsyncJobs = async () => {
 						try {
 							
-							let newMsg = JSON.parse(JSON.stringify(mesg.msg));
-							
 							let metadata = {};
 							metadata.count = 0
 							metadata.limit = 0
 							let rdata = [];
 							
-							let method = data.method
 							let offset = moffset
 							
 							if(method == 'GET') { body = null }
 							
-							if(data.entity.split('_')[0] == 'v') { 
+							if(entity.split('_')[0] == 'v') { 
 								if(isEmpty(mparams)) { url = url + '?' } else { url = url + '&' }
 								
-								while (offset != null) {
+								const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+								
+								while (offset != null && node.closingId != clientid) {
 									
 									if(parseInt(mlimit) == 0) { mlimit = 1000000000}
 									if(parseInt(mlimit) < parseInt(mpaging)) { mpaging = mlimit }
 
 									eurl = encodeURI(url + 'limit=' + mpaging +'&offset=' + offset)
 
-									const response = await fetch(eurl, {headers, method, body});
+                                    const response = await fetchWithRetry(eurl, { headers, method, body }, repeat, rdelay, node, apiLimit);
 							
-									if(response.status >= 200 && response.status < 300) {
+									if(response && response.status >= 200 && response.status < 300) {
 										
 										const body = await response.json();
 										offset = body?.metadata?.nextOffset
@@ -149,9 +254,9 @@ module.exports = function(RED) {
 										if(mlimit - metadata.count < mpaging) { mpaging = mlimit - metadata.count}
 
 										if(mmerge == false) {
-											newMsg.payload=body;
-											newMsg.payload.count=body.data.length;
-											node.send(JSON.parse(JSON.stringify(newMsg)));	
+											msg.payload = body;
+											msg.count = body.data.length;
+											node.send(msg);	
 										} 
 										
 										if(mmerge == true) {
@@ -161,10 +266,22 @@ module.exports = function(RED) {
 										} 
 										
 										if(mlimit <= metadata.count) { break; }
-			
+
+										if (offset != null && delay > 0) { await sleep(delay); }
+										
 									} else {
-										node.error('Response status: ' + response.status);
-										node.error('Response status: ' + await response.text());
+                                        if (!response) {
+											msg.error = 'Request failed after all attempts.'
+											msg.payload = null;
+											if(msg.res){
+												msg.payload = JSON.stringify('Request failed after all attempts.');
+												msg.statusCode = 500;
+											}
+											node.send(msg);
+                                        } else if(response.status != 0) {
+                                            node.error('Response status: ' + response.status);
+                                            node.error('Response text: ' + await response.text());
+                                        }
 										break;
 									}	
 								} 
@@ -174,38 +291,44 @@ module.exports = function(RED) {
 									metadata.limit = parseInt(data.paging)
 									body.metadata = metadata
 									body.data = rdata
-									body.count = rdata.length
-									newMsg.payload = body
-									node.send(JSON.parse(JSON.stringify(newMsg)));	
+									msg.payload = body
+									msg.count = rdata.length
+									node.send(msg);	
 								}
 							}
 							
-							if(data.entity.split('_')[0] == 'r') { 
+							if(entity.split('_')[0] == 'r') { 
 
-								const response = await fetch(encodeURI(url), {headers, method, body});
+                                const response = await fetchWithRetry(encodeURI(url), { headers, method, body }, repeat, rdelay, node, apiLimit);
 
-								if(response.status >= 200 && response.status < 300) {
+								if(response && response.status >= 200 && response.status < 300) {
 									const body = await response.json();
-									newMsg.payload = body
-									node.send(JSON.parse(JSON.stringify(newMsg)));	
+									msg.payload = body
+									node.send(msg);	
 								} else {
-									let payload = {}
-									payload.status = response.status
-									payload.text = await response.text()
-
-									newMsg.payload = payload
-									node.send(JSON.parse(JSON.stringify(newMsg)));	
+									if (!response) {
+                                        msg.error = 'Request failed after all attempts.'
+										msg.payload = null;
+										if(msg.res){
+											msg.payload = JSON.stringify('Request failed after all attempts.');
+											msg.statusCode = 500;
+										}
+										node.send(msg);
+                                    } else if(response.status != 0) {
+										node.error('Response status: ' + response.status);
+                                        node.error('Response text: ' + await response.text());
+                                    }
 								}
 							}
 						} catch (e) {
-							node.error(e);
+							node.error(e.message);
 						} 
 					}
 					
-					const r = await doAsyncJobs()
+					await doAsyncJobs();
 					
 				} catch (e) {
-					node.error(e);
+					node.error(e.message);
 				}
 			}
 			
@@ -216,12 +339,20 @@ module.exports = function(RED) {
 					});
 					return na.length
 				} catch (e) {
-					node.error(e);
+					node.error(e.message);
 				} 
 			}
 
 			async function setTimer(host) {
 				try {
+					if(node.closingId == clientid) {
+						for (let i = c.length - 1; i >= 0; i--) {
+							if (c[i].clientid === clientid) {
+								c.splice(i, 1); 
+							}
+						}
+					}
+					
 					if(c.length > 0) {
 						let nd = new Date()
 						if(nd.getTime() > c[0].stime) {
@@ -239,16 +370,17 @@ module.exports = function(RED) {
 							node.status({fill: "yellow", shape: "dot", text: fal + " waiting messages"});
 						}
 					} else {
+						node.status({fill: "green", shape: "dot", text: "0 waiting messages"});
 						clearInterval(st) 
 						st = null
 					}
 				}
 				catch (e) {
-					node.error(e);
+					node.error(e.message);
 				}
 			}
 
-			node.on('input', async function(msg) {
+			node.on('input', async function(msg, send, done) {
 				try {
 					if(st == null){ st = setInterval(function () { setTimer(host) }, 1000)}
 
@@ -273,16 +405,27 @@ module.exports = function(RED) {
 					} else {
 						node.send(msg)
 					}
+					if (done) {
+						done();
+					}
 				}
 				catch (e) {
-					node.error(e);
+					node.error(e.message);
 				}
 			});
 		
 		} catch (e) {
-			node.error(e);
+			node.error(e.message);
 		}
+		
+		node.on('close', function(done) {
+			node.closingId = this.id;
+
+            if (done) {
+                done();
+            }
+        });
 	}
 	
 	RED.nodes.registerType("teamogy-client",teamogyClient);
-}
+}