81 feature frontend for engine configuration group5

src/lib/GlobalCssProperties.json

@@ -95,8 +95,54 @@
 				0.39901960784,
 				0.43823529411
 			],
+			"--engine-ui-underline-color": ["display-p3", 1, 1, 1],
+			"--engine-ui-error-underline-color": [
+				"display-p3",
+				0.82745098039,
+				0.18431372549,
+				0.18431372549
+			],
+			"--engine-ui-input-text-placeholder-color": [
+				"display-p3",
+				0.8,
+				0.8,
+				0.8
+			],
+			"--engine-ui-scrollbar-thumb-background-color": [
+				"display-p3",
+				0.5608,
+				0.498,
+				0.4353
+			],
+			"--engine-ui-scrollbar-thumb-color": [
+				"display-p3",
+				0.7137,
+				0.6941,
+				0.6706
+			],
+			"--engine-ui-text-color": ["display-p3", 1, 1, 1],
+			"--engine-ui-background-color": [
+				"display-p3",
+				0.2862745098,
+				0.34901960784,
+				0.38823529411
+			],
+			"--engine-ui-checkbox-color": [
+				"display-p3",
+				0.2862745098,
+				0.34901960784,
+				0.38823529411
+			],
 			"--settings-danger-button-color": ["srgb", 0.498, 0.0902, 0.0549],
-			"--settings-safe-button-color": ["srgb", 0.3255, 0.498, 0.2667]
+			"--settings-safe-button-color": ["srgb", 0.3255, 0.498, 0.2667],
+			"--dropdown-button-color": ["srgb", 1, 1, 1],
+			"--dropdown-text-color": ["srgb", 0, 0, 0],
+			"--modal-background-color": [
+				"display-p3",
+				0.22745098039,
+				0.27450980392,
+				0.30588235294
+			]
 		},
 		"fontSize": {
 			"--sidebar-fontsize": [1, "rem"],
@@ -206,6 +252,45 @@
 					0.13490196078,
 					0.14666666666,
 					0.17019607843
+				],
+				"--engine-ui-underline-color": ["display-p3", 1, 1, 1],
+				"--engine-ui-error-underline-color": [
+					"display-p3",
+					0.82745098039,
+					0.18431372549,
+					0.18431372549
+				],
+				"--engine-ui-input-text-placeholder-color": [
+					"display-p3",
+					0.7333,
+					0.7333,
+					0.7333
+				],
+				"--engine-ui-scrollbar-thumb-background-color": [
+					"display-p3",
+					0.95,
+					0.95,
+					0.95
+				],
+				"--engine-ui-scrollbar-thumb-color": ["display-p3", 0, 0, 0],
+				"--engine-ui-background-color": [
+					"display-p3",
+					0.08490196078,
+					0.09666666666,
+					0.12019607843
+				],
+				"--engine-ui-checkbox-color": [
+					"display-p3",
+					0.08490196078,
+					0.09666666666,
+					0.12019607843
+				],
+				"--engine-ui-text-color": ["display-p3", 1, 1, 1],
+				"--modal-background-color": [
+					"display-p3",
+					0.0156862745,
+					0.02352941176,
+					0.03529411764
 				]
 			}
 		},

src/lib/classes/engine/Engine.ts

@@ -0,0 +1,113 @@
+import {
+	comparePortRange,
+	validateEndPort,
+	validateIP,
+	validateName,
+	validateStartPort,
+} from "./Validation";
+
+/**
+ * A Reveaal, JEcdar andd API engine definition
+ * It stores the IP and port of an engine
+ * */
+export class Engine {
+	/**
+	 * The #name of the Engine
+	 * */
+	#name: string = "";
+	get name(): string {
+		return this.#name;
+	}
+	set name(setName: string) {
+		if (validateName(setName)) this.#name = setName;
+		else throw new Error("Engine must have a name");
+	}
+	/**
+	 * The IP #address of the engine
+	 * */
+	#address: string = "";
+	get address(): string {
+		return this.#address;
+	}
+	set address(ipAdress: string) {
+		if (validateIP(ipAdress)) this.#address = ipAdress;
+		else throw new Error(ipAdress + " Is an invalid IP address");
+	}
+	/**
+	 * The starting number of the portrange
+	 * */
+	#portRangeStart: number = 0;
+	get portRangeStart(): number {
+		return this.#portRangeStart;
+	}
+	set portRangeStart(portStart: number) {
+		if (validateStartPort(portStart)) this.#portRangeStart = portStart;
+		else throw new Error("Invalid start port");
+	}
+
+	/**
+	 * The last number of the portrange
+	 * */
+	#portRangeEnd: number = 0;
+	get portRangeEnd(): number {
+		return this.#portRangeEnd;
+	}
+	set portRangeEnd(portEnd: number) {
+		if (
+			comparePortRange(this.#portRangeStart, portEnd) &&
+			validateEndPort(portEnd)
+		)
+			this.#portRangeEnd = portEnd;
+		else throw new Error("Invalid end port");
+	}
+
+	/**
+	 * Unique identifier
+	 * */
+	#id: number = 0;
+	get id(): number {
+		return this.#id;
+	}
+	set id(inputId: number) {
+		if (inputId >= 0) this.#id = inputId;
+		else throw new Error("Invalid id");
+	}
+
+	hasBeenChanged: boolean = false;
+
+	#useBundle: boolean = false;
+	get useBundle(): boolean {
+		return this.#useBundle;
+	}
+	set useBundle(useBundle: boolean) {
+		this.#useBundle = useBundle;
+		if (useBundle) this.address = "127.0.0.1";
+	}
+
+	constructor(
+		name: string,
+		address: string,
+		portRangeStart: number,
+		portRangeEnd: number,
+		id: number,
+		useBundle: boolean,
+	) {
+		this.name = name;
+		if (!useBundle) this.address = address;
+		this.portRangeStart = portRangeStart;
+		this.portRangeEnd = portRangeEnd;
+		this.id = id;
+		this.#useBundle = useBundle;
+	}
+
+	toJSON() {
+		return {
+			name: this.#name,
+			address: this.#address,
+			portRangeStart: this.#portRangeStart,
+			portRangeEnd: this.#portRangeEnd,
+			id: this.#id,
+			useBundle: this.#useBundle,
+		};
+	}
+}

src/lib/classes/engine/EngineStorage.ts

@@ -0,0 +1,162 @@
+import type IEngineStorageObject from "$lib/interfaces/IEngineStorageObject";
+import { Engine } from "./Engine";
+/**
+ * Engine storage definition.
+ * Stores an array of Engine instances, and can create, delete or search the array
+ * */
+class EngineStorage {
+	/**
+	 * Array of engines defined
+	 * */
+	engineArray: Array<Engine | undefined> = [];
+
+	/**
+	 * variable used to give unique id to engines
+	 * */
+	#engineId: number = 0;
+
+	get engineId(): number {
+		return (this.engineId = ++this.#engineId); //auto inc
+	}
+	set engineId(id: number) {
+		if (id >= 0) this.#engineId = id;
+		else throw new Error("Invalid engineId");
+	}
+
+	/**
+	 * Array of engines defined
+	 * */
+	#defaultEngine: Engine | undefined;
+	get defaultEngine(): Engine | undefined {
+		return this.#defaultEngine;
+	}
+	set defaultEngine(engine: Engine | undefined) {
+		let index = -1;
+
+		index = this.engineArray.findIndex(
+			(arrayEngine: Engine | undefined) => {
+				return arrayEngine?.id === engine?.id;
+			},
+		);
+		if (engine === undefined || index > -1) this.#defaultEngine = engine;
+		else throw new Error("Failed to set default engine");
+	}
+
+	constructor() {
+		this.engineArray = new Array<Engine>();
+		this.engineId = 0;
+		this.defaultEngine = undefined;
+	}
+
+	/**
+	 * Create an Engine and pushes it to engineArray
+	 */
+	createEngine(
+		name: string,
+		address: string,
+		portRangeStart: number,
+		portRangeEnd: number,
+		useBundle: boolean,
+	) {
+		const newEngine = new Engine(
+			name,
+			address,
+			portRangeStart,
+			portRangeEnd,
+			this.engineId,
+			useBundle,
+		);
+		this.engineArray[this.engineId - 1] = newEngine;
+
+		return newEngine;
+	}
+
+	/**
+	 * Deletes the engine with the given id
+	 */
+	deleteEngine(id: number) {
+		//check for results
+		if (this.engineArray[id]) {
+			//Check if the default engine is being removed
+			if (this.defaultEngine?.id === id) this.defaultEngine = undefined;
+
+			this.engineArray[id] = undefined;
+		} else {
+			throw new Error("Engine Id does not exist");
+		}
+	}
+	/**
+	 * Get engines based on id or name
+	 */
+	getEngine(identifier: number | string): Engine {
+		let returnEngine: undefined | Engine;
+
+		//Find engine based on id
+		if (typeof identifier === "number") {
+			returnEngine = this.engineArray[identifier];
+		}
+		//Find engine based on name
+		else {
+			returnEngine = this.engineArray.find(
+				(engine: Engine | undefined) => {
+					return engine?.name === identifier;
+				},
+			);
+		}
+		if (returnEngine !== undefined) return returnEngine;
+		else throw new Error("Could not find engine");
+	}
+
+	/**
+	 * Returns all engines in the store in the form of an array
+	 */
+	getEngineArray(): Array<Engine> {
+		const filtered: Engine[] = this.engineArray.filter(
+			(element) => element !== undefined,
+		) as Engine[];
+		return filtered;
+	}
+
+	/**
+	 * Coonvert the EngineStorage to a JSON string
+	 */
+	serialize(): string {
+		return JSON.stringify(this);
+	}
+
+	toJSON() {
+		return {
+			engineArray: this.engineArray,
+			engineId: this.#engineId,
+			defaultEngine: this.defaultEngine,
+		};
+	}
+
+	/**
+	 * Reads fields and engines from JSON string, and applies them in the store
+	 */
+	deSerialize(json: string) {
+		const parsedJSON: IEngineStorageObject = JSON.parse(
+			json,
+		) as IEngineStorageObject;
+		this.engineArray = [];
+		this.engineId = parsedJSON.engineId;
+		this.defaultEngine = parsedJSON.defaultEngine;
+
+		//run Engine constructer to validate input.
+		parsedJSON.engineArray.forEach((engine) => {
+			this.engineArray.push(
+				new Engine(
+					engine.name,
+					engine.address,
+					engine.portRangeStart,
+					engine.portRangeEnd,
+					engine.id,
+					engine.useBundle,
+				),
+			);
+		});
+	}
+}
+const engineStorage = new EngineStorage();
+export default engineStorage;