odsl-javascript-sdk 1.0.3 → 1.0.5

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "odsl-javascript-sdk",
-  "type": "module",
-  "version": "1.0.3",
+  "type": "commonjs",
+  "version": "1.0.5",
   "description": "Javascript SDK for OpenDataDSL",
   "main": "src/sdk.js",
   "scripts": {
@@ -26,11 +26,14 @@
   },
   "homepage": "https://github.com/OpenDataDSL/odsl-javascript-sdk#readme",
   "dependencies": {
+    "@azure/identity": "^4.13.0",
     "@azure/msal-node": "^2.6.6",
+    "@azure/service-bus": "^7.9.5",
+    "node-fetch": "^3.3.2",
     "xmlhttprequest": "^1.8.0"
   },
   "devDependencies": {
-    "mocha": "^10.4.0",
-    "dotenv": "^16.4.5"
+    "dotenv": "^16.4.5",
+    "mocha": "^10.4.0"
   }
 }

package/src/odsl.js

@@ -0,0 +1,122 @@
+'use strict';
+const { ConfidentialClientApplication } = require("@azure/msal-node");
+const { PublicClientApplication } = require("@azure/msal-browser");
+const { XMLHttpRequest } = require("xmlhttprequest");
+
+const msalConfig = {
+	"auth": {
+		"clientId": "d3742f5f-3d4d-4565-a80a-ebdefaab8d08",
+		"authority": "https://login.microsoft.com/common"
+	}
+};
+
+module.exports = class ODSL {
+	token = null;
+	// host = "https://odsl-dev.azurewebsites.net/api/";
+	host = "http://localhost:7071/api/";
+	constructor(loginResponse) {
+		this.token = loginResponse.accessToken;
+	}
+	static async login() {
+		try {
+			let msalInstance = new pcbrowser(msalConfig);
+			console.log("Initialising");
+			await msalInstance.initialize();
+			console.log("Logging In");
+			const loginResponse = await msalInstance.loginPopup(loginRequest);
+			return new ODSL(loginResponse);
+		} catch (err) {
+			console.log("Token Acquisition Failed: " + err);
+		}
+	}
+	static async loginWithSecret(config) {
+		try {
+			let loginRequest = {
+				scopes: ["api://opendatadsl/.default"]
+			}
+			let msalInstance = new ConfidentialClientApplication(config);
+			console.log("Logging In");
+			const loginResponse = await msalInstance.acquireTokenByClientCredential(loginRequest);
+			return new ODSL(loginResponse);
+		} catch (err) {
+			console.log("Token Acquisition Failed: " + err);
+		}
+	}
+	static loginWithToken(token) {
+		return new ODSL({accessToken:token});
+	}
+	get(service, source, id) {
+		try {
+			var xhttp = new XMLHttpRequest();
+			id = encodeURIComponent(id);
+			var url = new URL(this.host + service + "/v1/" + source + "/" + id);
+			xhttp.open("GET", url, false);
+			xhttp.setRequestHeader("Authorization", "Bearer " + this.token);
+			xhttp.responseType = "json";
+			xhttp.send();
+			if (xhttp.status < 200 || xhttp.status >= 300) {
+				throw xhttp.getResponseHeader("x-odsl-error");
+			}
+			return JSON.parse(xhttp.responseText);
+		} catch (err) {
+			console.log("GET request Failed: " + err);			
+		}
+	}
+	getAsync(service, source, id, callback) {
+		try {
+			var xhttp = new XMLHttpRequest();
+			id = encodeURIComponent(id);
+			var url = new URL(this.host + service + "/v1/" + source + "/" + id);
+			xhttp.open("GET", url);
+			xhttp.setRequestHeader("Authorization", "Bearer " + this.token);
+			xhttp.responseType = "json";
+			xhttp.send();
+			xhttp.onload = function() {
+				if (xhttp.status < 200 || xhttp.status >= 300) {
+					throw xhttp.getResponseHeader("x-odsl-error");
+				} else {
+					callback(JSON.parse(xhttp.responseText));
+				}
+			}
+		} catch (err) {
+			console.log("GET request Failed: " + err);			
+		}
+	}
+	list(service, source, params) {
+		try {
+			var xhttp = new XMLHttpRequest();
+			var url = new URL(this.host + service + "/v1/" + source);
+			if (params != undefined) {
+				for (let key of Object.keys(params)) {
+					url.searchParams.set(key, params[key]);
+				}
+			}
+			xhttp.open("GET", url, false);
+			xhttp.setRequestHeader("Authorization", "Bearer " + this.token);
+			xhttp.responseType = "json";
+			xhttp.send();
+			if (xhttp.status < 200 || xhttp.status >= 300) {
+				throw xhttp.getResponseHeader("x-odsl-error");
+			}
+			return JSON.parse(xhttp.responseText);
+		} catch (err) {
+			console.log("GET request Failed: " + err);			
+		}
+	}
+	update(service, source, body) {
+		try {
+			var xhttp = new XMLHttpRequest();
+			var url = new URL(this.host + service + "/v1/" + source);
+			xhttp.open("POST", url, false);
+			xhttp.setRequestHeader("Authorization", "Bearer " + this.token);
+			xhttp.responseType = "json";
+			xhttp.send(JSON.stringify(body));
+			if (xhttp.status < 200 || xhttp.status >= 300) {
+				throw xhttp.getResponseHeader("x-odsl-error");
+			}
+			return JSON.parse(xhttp.responseText);
+		} catch (err) {
+			console.log("GET request Failed: " + err);			
+		}
+	}
+}

package/src/process.js

@@ -0,0 +1,90 @@
+const { ServiceBusClient, ServiceBusMessage } = require("@azure/service-bus");
+
+module.exports = class PROCESS {
+	constructor(p, task) {
+		this.process = p;
+		this.task = task;
+		var cstr = process.env.ODSL_SB_CPM;
+		this.serviceBusClient = new ServiceBusClient(cstr);
+		this.started = false;
+		this.queue_name = process.env.ODSL_STAGE + "/process-execution";
+	}
+
+	async startProcess() {
+		if (!this.started) {
+			console.log("Starting process for task: " + this.task._id);
+			var message = new ProcessMessage(this.process, this.task);
+			message.status = "start";
+			message.message = "Initialising Process";
+			await this.updateProcess(message);
+		}
+	}
+
+	async endProcess(status, mess) {
+		var message = new ProcessMessage(this.process, this.task);
+		message.status = status;
+		message.message = mess;
+		console.log(mess);
+		await this.updateProcess(message);
+	}
+
+	async startPhase(name) {
+		this.phase = new ProcessMessage(this.process, this.task);
+		this.phase.status = "running";
+		this.phase.message = "Initialising Phase: " + name;
+		this.phase.setPhase(name);
+		await this.updateProcess(this.phase);
+	}
+
+	async endPhase(status, mess) {
+		this.phase.status = status;
+		this.phase.message = mess;
+		this.phase.timestamp = new Date().toISOString().substring(0,19);
+		let level = status == "failed" ? "fatal" : "info"
+		let lm = new Date().toISOString() + " " + level + " " + mess;
+		this.phase.log.push(lm);
+		await this.updateProcess(this.phase);
+	}
+
+	async logMessage(level, mess) {
+		let lm = new Date().toISOString() + " " + level + " " + mess;
+		console.log(lm);
+		this.phase.log.push(lm);
+		await this.updateProcess(this.phase);
+	}
+
+	async updateProcess(message) {
+		var sbm = {
+			body: message,
+			applicationProperties:{
+				tenantid: this.task.tid,
+				environment: this.task.environment
+			}
+		}
+		var sender = this.serviceBusClient.createSender(this.queue_name);
+		await sender.sendMessages(sbm);
+	}
+}
+
+class ProcessMessage {
+	constructor(p, t) {
+		this.log = [];
+		this.timestamp = new Date().toISOString().substring(0,19);
+		this.type = "ProcessMessage";
+		this.id = t._id;
+		this.tenantid = t.tid;
+		this.service = p.service;
+		this.name = p.name;
+		this.stage = process.env.ODSL_STAGE;
+		this.environment = t.environment;
+		this.trigger = t.trigger;
+		this.triggerTime = t.triggerTime;
+		this.reason = t.reason;
+		this.status = "triggered";
+		this.message = "";		
+	}
+
+	setPhase(name) {
+		this.phase = name;
+	}
+}

package/src/sdk.js

@@ -42,7 +42,7 @@ export default class ODSL {
 			console.log("Token Acquisition Failed: " + err);
 		}
 	}
-	static async loginWithToken(token) {
+	static loginWithToken(token) {
 		return new ODSL({accessToken:token});
 	}
 	get(service, source, id) {