Completed installation procedure on wizard

manager/javascripts/dcsinstance.js

@@ -0,0 +1,180 @@
+var regedit = require('regedit')
+const shellFoldersKey = 'HKCU\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders'
+const saveGamesKey = '{4C5C32FF-BB9D-43B0-B5B4-2D72E54EAAA4}'
+var fs = require('fs')
+var path = require('path')
+const vi = require('win-version-info');
+const checkPort = require('./net')
+const dircompare = require('dir-compare');
+
+class DCSInstance {
+    static instances = null;
+
+    static async getInstances() {
+        if (this.instances === null) {
+            this.instances = await this.findInstances();
+        }
+        return this.instances;
+    }
+
+    static async findInstances() {
+        let promise = new Promise((res, rej) => {
+            regedit.list(shellFoldersKey, function (err, result) {
+                if (err) {
+                    rej(err);
+                }
+                else {
+                    if (result[shellFoldersKey] !== undefined && result[shellFoldersKey]["exists"] && result[shellFoldersKey]['values'][saveGamesKey] !== undefined && result[shellFoldersKey]['values'][saveGamesKey]['value'] !== undefined) {
+                        const searchpath = result[shellFoldersKey]['values'][saveGamesKey]['value'];
+                        const folders = fs.readdirSync(searchpath);
+                        var instances = [];
+    
+                        folders.forEach((folder) => {
+                            if (fs.existsSync(path.join(searchpath, folder, "Config", "appsettings.lua")) ||
+                                fs.existsSync(path.join(searchpath, folder, "Config", "serversettings.lua"))) {
+                                instances.push(new DCSInstance(path.join(searchpath, folder)));
+                            }
+                        })
+    
+                        res(instances);
+                    } else {
+                        console.error("An error occured while trying to fetch the location of the DCS instances.")
+                        rej("An error occured while trying to fetch the location of the DCS instances.");
+                    }
+                }
+            })
+        });
+    
+        return promise;
+    }
+    
+    folder = "";
+    name = "";
+    clientPort = 3000;
+    backendPort = 3001;
+    backendAddress = "localhost";
+    gameMasterPassword = "";
+    blueCommanderPassword = "";
+    redCommanderPassword = "";
+    installed = false;
+    error = false;
+
+    constructor(folder) {
+        this.folder = folder;
+        this.name = path.basename(folder);
+
+        if (fs.existsSync(path.join(folder, "Config", "olympus.json"))){
+            this.installed = true;
+            const options = { compareContent: true };
+            var err1 = true;
+            var err2 = true;
+            var res1;
+            var res2;
+            try {
+                res1 = dircompare.compareSync(path.join("..", "mod"), path.join(folder, "Mods", "Services", "Olympus"), options);
+                res2 = dircompare.compareSync(path.join("..", "scripts", "OlympusHook.lua"), path.join(folder, "Scripts", "Hooks", "OlympusHook.lua"), options);
+                err1 = res1.differences !== 0;
+                err2 = res2.differences !== 0;
+            } catch(e) {
+                console.log(e);
+            }
+
+            if (err1 || err2) {
+                console.log(res1)
+                console.log(res2)
+                this.error = true;
+            }
+        }
+    }
+ 
+    async setClientPort(newPort) {
+        if (await this.checkClientPort(newPort)) {
+            console.log(`Instance ${this.folder} client port set to ${newPort}`)
+            this.clientPort = newPort;
+            return true;
+        }
+        return false;
+    }
+
+    async setBackendPort(newPort) {
+        if (await this.checkBackendPort(newPort)) {
+            console.log(`Instance ${this.folder} client port set to ${newPort}`)
+            this.backendPort = newPort;
+            return true;
+        }
+        return false;
+    }
+
+    setBackendAddress(newAddress) {
+        this.backendAddress = newAddress;
+    }
+
+    setGameMasterPassword(newPassword) {
+        this.gameMasterPassword = newPassword;
+    }
+
+    setBlueCommanderPassword(newPassword) {
+        this.blueCommanderPassword = newPassword;
+    }
+
+    setRedCommanderPassword(newPassword) {
+        this.redCommanderPassword = newPassword;
+    }
+
+    async checkClientPort(port) {
+        var promise = new Promise((res, rej) => {
+            checkPort(port, async (portFree) => {
+                if (portFree) {
+                    portFree = !(await DCSInstance.getInstances()).some((instance) => {
+                        if (instance !== this) {
+                            if (instance.clientPort === port || instance.backendPort === port) {
+                                console.log(`Port ${port} already selected by other instance`);
+                                return true;
+                            }
+                        } else {
+                            if (instance.backendPort === port) {
+                                console.log(`Port ${port} equal to backend port`);
+                                return true;
+                            }
+                        }
+                        return false;
+                    })  
+                }
+                else {
+                    console.log(`Port ${port} currently in use`);
+                }
+                res(portFree);
+            })
+        })
+        return promise;
+    }
+
+    async checkBackendPort(port) {
+        var promise = new Promise((res, rej) => {
+            checkPort(port, async (portFree) => {
+                if (portFree) {
+                    portFree = !(await DCSInstance.getInstances()).some((instance) => {
+                        if (instance !== this) {
+                            if (instance.clientPort === port || instance.backendPort === port) {
+                                console.log(`Port ${port} already selected by other instance`);
+                                return true;
+                            }
+                        } else {
+                            if (instance.clientPort === port) {
+                                console.log(`Port ${port} equal to client port`);
+                                return true;
+                            }
+                        }
+                        return false;
+                    })
+                } else {
+                    console.log(`Port ${port} currently in use`);
+                }
+                res(portFree);
+            })
+        })
+        return promise;
+    }
+}
+
+module.exports = DCSInstance;

manager/javascripts/filesystem.js

@@ -1,115 +1,148 @@
 const sha256 = require('sha256')
 const createShortcut = require('create-desktop-shortcuts');
+const fs = require('fs');
+const path = require('path');
 
-export function installOlympus(folder) {
-    console.log(`Installing Olympus in ${folder}`);
-    try {
-        fs.cpSync(path.join("..", "mod"), path.join(folder, "Mods", "Services", "Olympus"), { recursive: true });
-        fs.cpSync(path.join("..", "scripts", "OlympusHook.lua"), path.join(folder, "Scripts", "Hooks", "OlympusHook.lua"));
-        fs.cpSync(path.join("..", "olympus.json"), path.join(folder, "Config", "olympus.json"));
-        if (createShortcut({
+async function fixInstances(instances) {
+    var promise = new Promise((res, rej) => {
+        var instancePromises = instances.map((instance) => {
+            var instancePromise = new Promise((instanceRes, instanceErr) => {
+                installMod(instance.folder)
+                    .then(() => installHooks(instance.folder))
+                    .then(() => installShortCuts(instance.folder, instance.name))
+                    .then(() => instanceRes(true), (err) => { instanceErr(err) })
+            })
+            return instancePromise;
+        });
+        console.log(instancePromises);
+        Promise.all(instancePromises).then(() => res(true), (err) => { rej(err) });
+    })
+    console.log(promise);
+    return promise;
+}
+
+async function installMod(folder) {
+    console.log(`Installing mod in ${folder}`)
+    var promise = new Promise((res, rej) => {
+        fs.cp(path.join("..", "mod"), path.join(folder, "Mods", "Services", "Olympus"), { recursive: true }, (err) => {
+            if (err) {
+                console.log(`Error installing mod in ${folder}: ${err}`)
+                rej(err);
+            }
+            else {
+                console.log(`Mod succesfully installed in ${folder}`)
+                res(true);
+            }
+        });
+    })
+    return promise;
+}
+
+async function installHooks(folder) {
+    console.log(`Installing hooks in ${folder}`)
+    var promise = new Promise((res, rej) => {
+        fs.cp(path.join("..", "scripts", "OlympusHook.lua"), path.join(folder, "Scripts", "Hooks", "OlympusHook.lua"), (err) => {
+            if (err) {
+                console.log(`Error installing hooks in ${folder}: ${err}`)
+                rej(err);
+            }
+            else {
+                console.log(`Hooks succesfully installed in ${folder}`)
+                res(true);
+            }
+        });
+    })
+    return promise;
+}
+
+async function installJSON(folder) {
+    console.log(`Installing config in ${folder}`)
+    var promise = new Promise((res, rej) => {
+        fs.cp(path.join("..", "olympus.json"), path.join(folder, "Config", "olympus.json"), (err) => {
+            if (err) {
+                console.log(`Error installing config in ${folder}: ${err}`)
+                rej(err);
+            }
+            else {
+                console.log(`Config succesfully installed in ${folder}`)
+                res(true);
+            }
+        });
+    })
+    return promise;
+}
+
+async function applyConfiguration(folder, instance) {
+    console.log(`Applying configuration to Olympus in ${folder}`);
+    var promise = new Promise((res, rej) => {
+        if (fs.existsSync(path.join(folder, "Config", "olympus.json"))) {
+            var config = JSON.parse(fs.readFileSync(path.join(folder, "Config", "olympus.json")));
+
+            config["client"]["port"] = instance.clientPort;
+            config["server"]["port"] = instance.backendPort;
+            config["server"]["address"] = instance.backendAddress;
+            config["authentication"]["gameMasterPassword"] = sha256(instance.gameMasterPassword);
+            config["authentication"]["blueCommanderPassword"] = sha256(instance.blueCommanderPassword);
+            config["authentication"]["redCommanderPassword"] = sha256(instance.redCommanderPassword);
+
+            fs.writeFile(path.join(folder, "Config", "olympus.json"), JSON.stringify(config, null, 4), (err) => {
+                if (err) {
+                    console.log(`Error applying config in ${folder}: ${err}`)
+                    rej(err);
+                }
+                else {
+                    console.log(`Config succesfully applied in ${folder}`)
+                    res(true);
+                }
+            });
+
+        } else {
+            rej("File does not exist")
+        }
+        res(true);
+    });
+    return promise;
+}
+
+async function installShortCuts(folder, name) {
+    console.log(`Installing shortcuts for Olympus in ${folder}`);
+    var promise = new Promise((res, rej) => {
+        var res1 = createShortcut({
             windows: {
                 filePath: path.resolve(__dirname, '..', '..', 'client', 'client.vbs'),
                 outputPath: folder,
-                name: "DCS Olympus Client",
+                name: `DCS Olympus Client (${name})`,
                 arguments: `"${path.join(folder, "Config", "olympus.json")}"`,
                 icon: path.resolve(__dirname, '..', '..', 'img', 'olympus.ico'),
                 workingDirectory: path.resolve(__dirname, '..', '..', 'client')
             }
-        }) &&
-            createShortcut({
-                windows: {
-                    filePath: path.resolve(__dirname, '..', '..', 'client', 'server.vbs'),
-                    outputPath: folder,
-                    name: "DCS Olympus Server",
-                    arguments: `"${path.join(folder, "Config", "olympus.json")}"`,
-                    icon: path.resolve(__dirname, '..', '..', 'img', 'olympus_server.ico'),
-                    workingDirectory: path.resolve(__dirname, '..', '..', 'client')
-                }
-            })) {
-            console.log("Shorcuts created succesfully")
+        });
+
+        var res2 = createShortcut({
+            windows: {
+                filePath: path.resolve(__dirname, '..', '..', 'client', 'server.vbs'),
+                outputPath: folder,
+                name: `DCS Olympus Server (${name})`,
+                arguments: `"${path.join(folder, "Config", "olympus.json")}"`,
+                icon: path.resolve(__dirname, '..', '..', 'img', 'olympus_server.ico'),
+                workingDirectory: path.resolve(__dirname, '..', '..', 'client')
+            }
+        });
+
+        if (res1 && res2) {
+            res(true);
         } else {
-            return false;
+            rej("An error occurred while creating the shortcuts")
         }
-    } catch (e) {
-        console.error(e);
-        return false;
-    }
-    loadDivs();
-    return true;
+    });
+    return promise;
 }
 
-export function uninstallOlympus(folder) {
-    console.log(`Uninstalling Olympus from ${folder}`);
-    try {
-        fs.rmSync(path.join(folder, "Mods", "Services", "Olympus"), { recursive: true, force: true });
-        fs.rmSync(path.join(folder, "Config", "olympus.json"), {force: true});
-        loadDivs();
-    } catch (e) {
-        console.error(e);
-        return false;
-    }
-    return true;
+module.exports = {
+    applyConfiguration: applyConfiguration,
+    installJSON: installJSON,
+    installHooks: installHooks,
+    installMod: installMod,
+    installShortCuts, installShortCuts,
+    fixInstances: fixInstances
 }
-
-export function applyConfiguration(folder, data) {
-    console.log(`Applying configuration to Olympus from ${folder}`);
-
-    if (fs.existsSync(path.join(folder, "Config", "olympus.json"))) {
-        var config = JSON.parse(fs.readFileSync(path.join(folder, "Config", "olympus.json")));
-
-        config["client"]["port"] = data["clientPort"];
-        config["server"]["port"] = data["backendPort"];
-        config["server"]["address"] = data["backendAddress"];
-        config["authentication"]["gameMasterPassword"] = sha256(data["gameMasterPassword"]);
-        config["authentication"]["blueCommanderPassword"] = sha256(data["blueCommanderPassword"]);
-        config["authentication"]["redCommanderPassword"] = sha256(data["redCommanderPassword"]);
-
-        try {
-            fs.writeFileSync(path.join(folder, "Config", "olympus.json"), JSON.stringify(config, null, 4));
-        } catch (e) {
-            console.error(e);
-            return false;
-        }
-    } else {
-        return false;
-    }
-    return true;
-}
-
-export function updateOlympus(folder) {
-    console.log(`Updating Olympus in ${folder}`);
-    try {
-        fs.cpSync(path.join("..", "mod"), path.join(folder, "Mods", "Services", "Olympus"), { recursive: true });
-        fs.cpSync(path.join("..", "scripts", "OlympusHook.lua"), path.join(folder, "Scripts", "Hook", "OlympusHook.lua"));
-        loadDivs();
-    } catch (e) {
-        console.error(e);
-        return false;
-    }
-    return true;
-}
-
-export function createDesktopShortcuts(folder) {
-    if (createShortcut({
-        windows: {
-            filePath: path.resolve(__dirname, '..', '..', 'client', 'client.vbs'),
-            name: "DCS Olympus Client",
-            arguments: `"${path.join(folder, "Config", "olympus.json")}"`,
-            icon: path.resolve(__dirname, '..', '..', 'img', 'olympus.ico'),
-            workingDirectory: path.resolve(__dirname, '..', '..', 'client')
-        }
-    }) && createShortcut({
-        windows: {
-            filePath: path.resolve(__dirname, '..', '..', 'client', 'server.vbs'),
-            name: "DCS Olympus Server",
-            arguments: `"${path.join(folder, "Config", "olympus.json")}"`,
-            icon: path.resolve(__dirname, '..', '..', 'img', 'olympus_server.ico'),
-            workingDirectory: path.resolve(__dirname, '..', '..', 'client')
-        }
-    })) {
-        showPopup("Shortcuts created successfully!")
-    } else {
-        showPopup("And error occurred while creating the shortcuts.")
-    }
-}

manager/javascripts/managerconnections.js

@@ -0,0 +1,69 @@
+const ManagerPage = require("./managerpage");
+const ejs = require('ejs')
+
+class ManagerConnections extends ManagerPage {
+    onBackClicked;
+    onNextClicked;
+    onCancelClicked;
+    instance;
+
+    constructor(options) {
+        super(options);
+    }
+
+    render(str) {
+        const element = this.getElement();
+        element.innerHTML = str;
+
+        this.element.querySelector(".back").addEventListener("click", (e) => this.onBackClicked(e));
+        this.element.querySelector(".next").addEventListener("click", (e) => this.onNextClicked(e));
+        this.element.querySelector(".cancel").addEventListener("click", (e) => this.onCancelClicked(e));
+
+        this.element.querySelector(".client-port").querySelector("input").addEventListener("change", async (e) => { this.setClientPort(Number(e.target.value)); })
+        this.element.querySelector(".backend-port").querySelector("input").addEventListener("change", async (e) => { this.setBackendPort(Number(e.target.value)); })
+        this.element.querySelector(".backend-address").querySelector("input").addEventListener("change", async (e) => { this.instance.setBackendAddress(e.target.value); })
+    }
+
+    show(instance) {
+        this.instance = instance;
+        this.options["instance"] = instance;
+
+        ejs.renderFile("./ejs/managerconnections.ejs", this.options, {}, (err, str) => {
+            if (!err) {
+                this.render(str);
+                this.setClientPort(this.instance.clientPort);
+                this.setBackendPort(this.instance.backendPort);
+            } else {
+                console.error(err);
+            }
+        });
+
+        super.show();
+    }
+
+    async setClientPort(newPort) {
+        const success = await this.instance.setClientPort(newPort);
+        var successEls = this.element.querySelector(".client-port").querySelectorAll(".success");
+        for (let i = 0; i < successEls.length; i++) {
+            successEls[i].classList.toggle("hide", !success);
+        }
+        var errorEls = this.element.querySelector(".client-port").querySelectorAll(".error");
+        for (let i = 0; i < errorEls.length; i++) {
+            errorEls[i].classList.toggle("hide", success);
+        }
+    }
+
+    async setBackendPort(newPort) {
+        const success = await this.instance.setBackendPort(newPort);
+        var successEls = this.element.querySelector(".backend-port").querySelectorAll(".success");
+        for (let i = 0; i < successEls.length; i++) {
+            successEls[i].classList.toggle("hide", !success);
+        }
+        var errorEls = this.element.querySelector(".backend-port").querySelectorAll(".error");
+        for (let i = 0; i < errorEls.length; i++) {
+            errorEls[i].classList.toggle("hide", success);
+        }
+    }
+}
+
+module.exports = ManagerConnections;

manager/javascripts/managerinstallations.js

@@ -2,30 +2,53 @@ const ManagerPage = require("./managerpage");
 const ejs = require('ejs')
 
 class ManagerInstallations extends ManagerPage {
+    onBackClicked;
+    onNextClicked;
+    onCancelClicked;
+
     constructor(options) {
         super(options);
-
-        ejs.renderFile("./ejs/managerinstallations.ejs", options, {}, (err, str) => {
-            if (!err) {
-                this.render(str);
-            } else {
-                console.error(str);
-            }
-        });
     }
 
     render(str) {
-        const element = this.getElement();
-        element.innerHTML = str;
+        this.element.innerHTML = str;
 
-        var options = element.querySelectorAll(".option");
+        var options = this.element.querySelectorAll(".option");
         for (let i = 0; i < options.length; i++) {
             options[i].onclick = (e) => {this.onOptionClicked(e);}
         }
+
+        this.element.querySelector(".back").addEventListener("click", (e) => this.onBackClicked(e));
+        this.element.querySelector(".next").addEventListener("click", (e) => this.onNextClicked(e));
+        this.element.querySelector(".cancel").addEventListener("click", (e) => this.onCancelClicked(e));
     }    
 
     onOptionClicked(e) {
-        e.target.classList.toggle("selected")
+        var options = this.element.querySelectorAll(".option");
+        for (let i = 0; i < options.length; i++) {
+            options[i].classList.remove("selected");
+        }
+
+        e.target.classList.add("selected");
+    }
+
+    getSelectedInstance() {
+        return this.options.instances.find((instance) => {
+            const selected = this.element.querySelector(".selected");
+            return selected? selected.dataset.folder === instance.folder: false;
+        });
+    }
+
+    show() {
+        ejs.renderFile("./ejs/managerinstallations.ejs", this.options, {}, (err, str) => {
+            if (!err) {
+                this.render(str);
+            } else {
+                console.error(err);
+            }
+        });
+
+        super.show();
     }
 } 
 

manager/javascripts/managerinstances.js

@@ -0,0 +1,55 @@
+const ManagerPage = require("./managerpage");
+const ejs = require('ejs')
+
+class ManagerInstances extends ManagerPage {
+    onBackClicked;
+    onNextClicked;
+    onCancelClicked;
+
+    constructor(options) {
+        super(options);
+    }
+
+    render(str) {
+        this.element.innerHTML = str;
+
+        var options = this.element.querySelectorAll(".option");
+        for (let i = 0; i < options.length; i++) {
+            options[i].onclick = (e) => {this.onOptionClicked(e);}
+        }
+
+        this.element.querySelector(".back").addEventListener("click", (e) => this.onBackClicked(e));
+        this.element.querySelector(".next").addEventListener("click", (e) => this.onNextClicked(e));
+        this.element.querySelector(".cancel").addEventListener("click", (e) => this.onCancelClicked(e));
+    }    
+
+    onOptionClicked(e) {
+        var options = this.element.querySelectorAll(".option");
+        for (let i = 0; i < options.length; i++) {
+            options[i].classList.remove("selected");
+        }
+
+        e.target.classList.add("selected");
+    }
+
+    getSelectedInstance() {
+        return this.options.instances.find((instance) => {
+            const selected = this.element.querySelector(".selected");
+            return selected? selected.dataset.folder === instance.folder: false;
+        });
+    }
+
+    show() {
+        ejs.renderFile("./ejs/managerinstances.ejs", this.options, {}, (err, str) => {
+            if (!err) {
+                this.render(str);
+            } else {
+                console.error(err);
+            }
+        });
+
+        super.show();
+    }
+} 
+
+module.exports = ManagerInstances;

manager/javascripts/managermenu.js

@@ -2,6 +2,10 @@ const ManagerPage = require("./managerpage");
 const ejs = require('ejs')
 
 class ManagerMenu extends ManagerPage {
+    onInstallClicked;
+    onUpdateClicked;
+    onManageClicked;
+
     constructor(options) {
         super(options);
 
@@ -9,7 +13,7 @@ class ManagerMenu extends ManagerPage {
             if (!err) {
                 this.render(str);
             } else {
-                console.error(str);
+                console.error(err);
             }
         });
     }
@@ -17,6 +21,10 @@ class ManagerMenu extends ManagerPage {
     render(str) {
         const element = this.getElement();
         element.innerHTML = str;
+
+        element.querySelector(".install").addEventListener("click", (e) => this.onInstallClicked(e));
+        element.querySelector(".update").addEventListener("click", (e) => this.onUpdateClicked(e))
+        element.querySelector(".manage").addEventListener("click", (e) => this.onManageClicked(e))
     }    
 } 
 

manager/javascripts/managerpage.js

@@ -1,15 +1,24 @@
 class ManagerPage {
     element;
+    options;
 
     constructor(options) {
+        this.options = options ?? {};
         this.element = document.createElement('div');
-        this.element.classList.add("manager-page");
+        this.element.classList.add("manager-page", "hide");
     }
 
     getElement() {
         return this.element;
     }
 
+    show() {
+        this.element.classList.remove("hide");
+    }
+
+    hide() {
+        this.element.classList.add("hide");
+    }
 } 
 
 module.exports = ManagerPage;

manager/javascripts/managerpasswords.js

@@ -0,0 +1,42 @@
+const ManagerPage = require("./managerpage");
+const ejs = require('ejs')
+
+class ManagerPasswords extends ManagerPage {
+    onBackClicked;
+    onNextClicked;
+    onCancelClicked;
+
+    constructor(options) {
+        super(options);
+    }
+
+    render(str) {
+        const element = this.getElement();
+        element.innerHTML = str;
+
+        this.element.querySelector(".back").addEventListener("click", (e) => this.onBackClicked(e));
+        this.element.querySelector(".next").addEventListener("click", (e) => this.onNextClicked(e));
+        this.element.querySelector(".cancel").addEventListener("click", (e) => this.onCancelClicked(e));
+
+        this.element.querySelector(".game-master").querySelector("input").addEventListener("change", async (e) => { this.instance.setGameMasterPassword(e.target.value); })
+        this.element.querySelector(".blue-commander").querySelector("input").addEventListener("change", async (e) => { this.instance.setBlueCommanderPassword(e.target.value); })
+        this.element.querySelector(".red-commander").querySelector("input").addEventListener("change", async (e) => { this.instance.setRedCommanderPassword(e.target.value); })
+    }    
+
+    show(instance) {
+        this.instance = instance;
+        this.options["instance"] = instance;
+
+        ejs.renderFile("./ejs/managerpasswords.ejs", this.options, {}, (err, str) => {
+            if (!err) {
+                this.render(str);
+            } else {
+                console.error(err);
+            }
+        });
+
+        super.show();
+    }
+} 
+
+module.exports = ManagerPasswords;

manager/javascripts/managerresult.js

@@ -0,0 +1,113 @@
+const { installMod, installHooks, installJSON, applyConfiguration, installShortCuts } = require("./filesystem");
+const ManagerPage = require("./managerpage");
+const ejs = require('ejs')
+
+class ManagerResult extends ManagerPage {
+    onBackClicked;
+    onNextClicked;
+    onCancelClicked;
+
+    constructor(options) {
+        super(options);
+    }
+
+    render(str) {
+        const element = this.getElement();
+        element.innerHTML = str;
+
+        this.element.querySelector(".back").addEventListener("click", (e) => this.onBackClicked(e));
+        this.element.querySelector(".cancel").addEventListener("click", (e) => this.onCancelClicked(e));
+    }    
+
+    show(instance) {
+        this.instance = instance;
+        this.options["instance"] = instance;
+
+        ejs.renderFile("./ejs/managerresult.ejs", this.options, {}, (err, str) => {
+            if (!err) {
+                this.render(str);
+            } else {
+                console.error(err);
+            }
+        });
+
+        super.show();
+    }
+
+    startInstallation() {
+        installHooks(this.instance.folder).then(
+            () => {
+                this.applyStepSuccess(".hook");
+            },
+            (err) => {
+                this.applyStepFailure(".hook");
+                return Promise.reject(err);
+            }
+        ).then(() => installMod(this.instance.folder)).then(
+            () => {
+                this.applyStepSuccess(".mod");
+            },
+            (err) => {
+                this.applyStepFailure(".mod");
+                return Promise.reject(err);
+            }
+        ).then(() => installJSON(this.instance.folder)).then(
+            () => {
+                this.applyStepSuccess(".json");
+            },
+            (err) => {
+                this.applyStepFailure(".json");
+                return Promise.reject(err);
+            }
+        ).then(() => applyConfiguration(this.instance.folder, this.instance)).then(
+            () => {
+                this.applyStepSuccess(".config");
+            },
+            (err) => {
+                this.applyStepFailure(".config");
+                return Promise.reject(err);
+            }
+        ).then(() => installShortCuts(this.instance.folder, this.instance.name)).then(
+            () => {
+                this.applyStepSuccess(".shortcuts");
+            },
+            (err) => {
+                this.applyStepFailure(".shortcuts");
+                return Promise.reject(err);
+            }
+        ).then(
+            () => {
+                this.element.querySelector(".summary.success").classList.remove("hide");
+                this.element.querySelector(".summary.error").classList.add("hide");
+                this.element.querySelector(".info.success").classList.remove("hide");
+                this.element.querySelector(".info.error").classList.add("hide");
+                this.element.querySelector(".result .success").classList.remove("hide");
+                this.element.querySelector(".result .error").classList.add("hide");
+                this.element.querySelector(".result .wait").classList.add("hide");
+                this.element.querySelector(".page-header").innerText = "Install successfull!";
+            },
+            () => {
+                this.element.querySelector(".summary.success").classList.add("hide");
+                this.element.querySelector(".summary.error").classList.remove("hide");
+                this.element.querySelector(".result .success").classList.add("hide");
+                this.element.querySelector(".result .error").classList.remove("hide");
+                this.element.querySelector(".result .wait").classList.add("hide");
+                this.element.querySelector(".page-header").innerText = "Install error!";
+            }
+        );
+    }
+
+    applyStepSuccess(step) {
+        this.element.querySelector(step).querySelector(".success").classList.remove("hide");
+        this.element.querySelector(step).querySelector(".error").classList.add("hide");
+        this.element.querySelector(step).querySelector(".wait").classList.add("hide");
+    }
+
+    applyStepFailure(step) {
+        this.element.querySelector(step).querySelector(".success").classList.add("hide");
+        this.element.querySelector(step).querySelector(".error").classList.remove("hide");
+        this.element.querySelector(step).querySelector(".wait").classList.add("hide");
+    }
+} 
+
+module.exports = ManagerResult;

manager/javascripts/net.js

@@ -1,6 +1,6 @@
 const portfinder = require('portfinder')
 
-export function checkPort(port, callback) {
+function checkPort(port, callback) {
     portfinder.getPort({ port: port, stopPort: port }, (err, res) => {
         if (err !== null) {
             console.error(`Port ${port} already in use`);
@@ -10,3 +10,5 @@ export function checkPort(port, callback) {
         }
     });
 }
+
+module.exports = checkPort;

manager/javascripts/popup.js

@@ -0,0 +1,19 @@
+function showPopup(message, onCloseCallback) {
+    document.getElementById("grayout").classList.remove("hide");
+    document.getElementById("popup").classList.remove("hide");
+    document.getElementById("popup").querySelector(".close-popup").addEventListener("click", (e) => {
+        hidePopup();
+        onCloseCallback();
+    })
+    document.getElementById("popup").querySelector(".content").innerText = message;
+}
+
+function hidePopup() {
+    document.getElementById("grayout").classList.add("hide");
+    document.getElementById("popup").classList.add("hide");
+}
+
+module.exports = {
+    showPopup: showPopup,
+    hidePopup: hidePopup
+}

manager/javascripts/preload.js

@@ -1,26 +1,22 @@
-var regedit = require('regedit')
-var fs = require('fs')
-var path = require('path')
-const ejs = require('ejs')
-
 const contextBridge = require('electron').contextBridge;
 const ipcRenderer = require('electron').ipcRenderer;
 
-const vi = require('win-version-info');
-const ManagerMenu  = require("./managermenu");
+const ManagerMenu = require("./managermenu");
 const ManagerInstallations = require('./managerinstallations');
-
-const shellFoldersKey = 'HKCU\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders'
-const saveGamesKey = '{4C5C32FF-BB9D-43B0-B5B4-2D72E54EAAA4}'
-
-var instanceDivs = [];
+const DCSInstance = require('./dcsinstance');
+const ManagerConnections = require('./managerconnections');
+const ManagerPasswords = require('./managerpasswords');
+const { showPopup } = require('./popup');
+const ManagerResult = require('./managerresult');
+const { fixInstances } = require('./filesystem');
+const ManagerInstances = require('./managerinstances');
 
 /* White-listed channels. */
 const ipc = {
     'render': {
         /* From render to main. */
         'send': [
-            'window:minimize', 
+            'window:minimize',
             'window:maximize',
             'window:restore',
             'window:close'
@@ -64,10 +60,153 @@ contextBridge.exposeInMainWorld(
 }
 );
 
-var managerMenu = new ManagerMenu();
-var managerInstallations = new ManagerInstallations({instances: ["asd/asd1", "asd/asd2"]});
+var activeInstance;
 
-window.addEventListener('DOMContentLoaded', () => {
-    //document.body.appendChild(managerMenu.getElement());
+async function setup() {
+    var instances = await DCSInstance.getInstances();
+
+    if (instances.some((instance) => {
+        return instance.installed && instance.error;
+    })) {
+        showPopup("One or more Olympus instances are corrupted or need updating. Press Close to fix this.", async () => {
+            fixInstances(instances.filter((instance) => {
+                return instance.installed && instance.error;
+            })).then(
+                () => { location.reload() },
+                () => { showPopup("An error occurred while trying to fix you installations. Please reinstall Olympus manually") }
+            )
+        })
+    }
+
+    /* Menu */
+    var managerMenu = new ManagerMenu();
+    managerMenu.onInstallClicked = (e) => {
+        managerMenu.hide();
+        managerInstallations.show();
+    }
+    managerMenu.onUpdateClicked = (e) => {
+        managerMenu.hide();
+        managerInstances.show();
+    }
+
+    /* Installations */
+    var managerInstallations = new ManagerInstallations({ instances: instances });
+    managerInstallations.onBackClicked = (e) => {
+        managerInstallations.hide();
+        managerMenu.show();
+    }
+    managerInstallations.onNextClicked = (e) => {
+         activeInstance = managerInstallations.getSelectedInstance();
+        if (activeInstance) {
+            managerInstallations.hide();
+            managerConnections.show(activeInstance);
+        } else {
+            showPopup("Please select the instance you want to install Olympus into.")
+        }
+    }
+    managerInstallations.onCancelClicked = (e) => {
+        managerInstallations.hide();
+        managerMenu.show();
+    }
+
+    /* Instances */
+    var managerInstances = new ManagerInstances({ instances: instances });
+    managerInstances.onBackClicked = (e) => {
+        managerInstances.hide();
+        managerMenu.show();
+    }
+    managerInstances.onNextClicked = (e) => {
+        activeInstance = managerInstances.getSelectedInstance();
+        if (activeInstance) {
+            managerInstances.hide();
+            managerConnections.show(activeInstance);
+        } else {
+            showPopup("Please select the instance you want to manage.")
+        }
+    }
+    managerInstances.onCancelClicked = (e) => {
+        managerInstances.hide();
+        managerMenu.show();
+    }
+
+    /* Connections */
+    var managerConnections = new ManagerConnections();
+    managerConnections.onBackClicked = (e) => {
+        managerConnections.hide();
+        managerInstallations.show();
+    }
+    managerConnections.onNextClicked = async (e) => {
+        if (activeInstance) {
+            if (await activeInstance.checkClientPort(activeInstance.clientPort) && await activeInstance.checkBackendPort(activeInstance.backendPort)) {
+                managerConnections.hide();
+                managerPasswords.show(activeInstance);
+            } else {
+                showPopup("Please make sure the selected ports are not already in use.")
+            }
+        } else {
+            showPopup("An error has occurred, please restart the Olympus Manager.")
+        }
+    }
+
+    managerConnections.onCancelClicked = (e) => {
+        managerConnections.hide();
+        managerMenu.show();
+    }
+
+    /* Passwords */
+    var managerPasswords = new ManagerPasswords();
+    managerPasswords.onBackClicked = (e) => {
+        if (activeInstance) {
+            managerPasswords.hide();
+            managerConnections.show(activeInstance);
+        } else {
+            showPopup("An error has occurred, please restart the Olympus Manager.")
+        }
+    }
+    managerPasswords.onNextClicked = (e) => {
+        if (activeInstance) {
+            if (activeInstance.gameMasterPassword === "" || activeInstance.blueCommanderPassword === "" || activeInstance.redCommanderPassword === "") {
+                showPopup("Please fill all the password inputs.")
+            }
+            else if (activeInstance.gameMasterPassword === activeInstance.blueCommanderPassword || activeInstance.blueCommanderPassword === activeInstance.redCommanderPassword || activeInstance.gameMasterPassword === activeInstance.redCommanderPassword) {
+                showPopup("All the passwords must be different from each other.")
+            } else {
+                managerPasswords.hide();
+                managerResult.show(activeInstance);
+                managerResult.startInstallation();
+            }
+        } else {
+            showPopup("An error has occurred, please restart the Olympus Manager.")
+        }
+
+    }
+    managerPasswords.onCancelClicked = (e) => {
+        managerPasswords.hide();
+        managerMenu.show();
+    }
+
+    /* Result */
+    var managerResult = new ManagerResult();
+    managerResult.onBackClicked = (e) => {
+        managerResult.hide();
+        managerMenu.show();
+    }
+    managerResult.onCancelClicked = (e) => {
+        managerResult.hide();
+        managerMenu.show();
+    }
+
+    document.body.appendChild(managerMenu.getElement());
     document.body.appendChild(managerInstallations.getElement());
+    document.body.appendChild(managerInstances.getElement());
+    document.body.appendChild(managerConnections.getElement());
+    document.body.appendChild(managerPasswords.getElement());
+    document.body.appendChild(managerResult.getElement());
+
+    managerMenu.show();
+}
+
+/* On content loaded */
+window.addEventListener('DOMContentLoaded', () => {
+    setup();
 })