@jtff/miztemplate-lib 2.0.1

package/index.js

@@ -0,0 +1,26 @@
+const MizTemplateCI = require("./lib/jtff-lib-ci.js");
+const build = require("./scripts/build.js");
+const clean = require("./scripts/clean.js");
+const ftpupload = require("./scripts/ftpupload.js");
+const gdriveupload = require("./scripts/gdrive-upload.js");
+const getmizfiles = require("./scripts/get-mizfiles.js");
+const {setVersion, getVersion} = require("./scripts/getset-version.js");
+const injectScripts = require("./scripts/inject-scripts.js");
+const nextversionPrepare = require("./scripts/prepare-nextversion.js");
+const release = require("./scripts/release.js");
+const templateUpdate = require("./scripts/template-update.js");
+
+module.exports = {
+    MizTemplateCI: MizTemplateCI,
+    build:build,
+    clean:clean,
+    ftpupload:ftpupload,
+    gdriveupload:gdriveupload,
+    getmizfiles:getmizfiles,
+    getVersion:getVersion,
+    setVersion:setVersion,
+    injectScripts:injectScripts,
+    nextversionPrepare:nextversionPrepare,
+    release:release,
+    templateUpdate:templateUpdate
+};

package/lib/jtff-lib-ci.js

@@ -0,0 +1,470 @@
+"use strict";
+
+const jszip = require("jszip");
+const fs = require("fs");
+const path = require("path");
+const { promisify } = require('util');
+const lstat = promisify(fs.lstat);
+const { google } = require("googleapis");
+const { format, parse } = require("lua-json");
+const ftpClient = require('ftp');
+
+class MizTemplateCI{
+
+    constructor(config) {
+        this.config = config
+    }
+
+    injectScripts(tObject, trObject, mrObject, strTitle, scriptFilesArray, timingInSeconds, hexColor) {
+        let nextIndex = Object.keys(trObject).length + 1;
+        if (nextIndex === 1) {
+            tObject['actions'] = {};
+            tObject['func'] = {};
+            tObject['conditions'] = {};
+            tObject['flag'] = {};
+            trObject = {};
+        }
+        let actionSentence = "";
+        let actionsObject = {};
+        for (const [index, scriptFile] of scriptFilesArray.entries()) {
+            actionSentence += "a_do_script_file(getValueResourceByKey(\"" + scriptFile + "\")); "
+            actionsObject[index + 1] = {
+                file: scriptFile,
+                predicate: 'a_do_script_file',
+            };
+            mrObject[scriptFile] = scriptFile;
+        }
+        actionSentence += "mission.trig.func[" + nextIndex + "]=nil;"
+        tObject['actions'][nextIndex] = actionSentence;
+        tObject['func'][nextIndex] = "if mission.trig.conditions[" + nextIndex + "]() then mission.trig.actions[" + nextIndex + "]() end";
+        tObject['conditions'][nextIndex] = "return(c_time_after(" + timingInSeconds + ") )";
+        tObject['flag'][nextIndex] = true;
+        trObject[nextIndex] = {
+            rules: {
+                1: {
+                    coalitionlist: 'red',
+                    seconds: timingInSeconds,
+                    predicate: 'c_time_after',
+                    zone: ''
+                }
+            },
+            eventlist: '',
+            comment: strTitle,
+            actions: actionsObject,
+            predicate: 'triggerOnce',
+            colorItem: hexColor
+        };
+        return { tObject: tObject, trObject: trObject, mrObject: mrObject };
+    }
+
+    getVersion() {
+        return this.getVersionObject(this.config.general.missionVersion);
+    }
+
+    setVersionfromString(strVersion, configFilePath) {
+        return this.setVersion(this.getVersionObject(strVersion), configFilePath)
+    }
+
+    setVersion(versionObject, configFilePath) {
+        this.config.general.missionVersion = this.displayVersion(versionObject);
+        let data = JSON.stringify(this.config, null, 4);
+        fs.writeFileSync(configFilePath, data);
+    }
+
+    displayVersion(versionObject) {
+        return [versionObject.major, versionObject.minor, versionObject.releaseSuffix ? versionObject.patch + '-' + versionObject.releaseSuffix : versionObject.patch].join('.')
+    }
+
+    getVersionObject(strVersion) {
+        const [major, minor, interimPatch] = strVersion.split('.', 3);
+        const [patch, releaseSuffix] = interimPatch.split('-', 2);
+        return {
+            major: parseInt(major),
+            minor: parseInt(minor),
+            patch: parseInt(patch),
+            releaseSuffix: releaseSuffix ? releaseSuffix : null
+        };
+    }
+
+    nextMajor(versionObject) {
+        const newVersionObject = versionObject;
+        newVersionObject.major = newVersionObject.major + 1;
+        return newVersionObject;
+    }
+
+    nextMinor(versionObject) {
+        const newVersionObject = versionObject;
+        newVersionObject.minor = newVersionObject.minor + 1;
+        return newVersionObject;
+    }
+
+    nextPatch(versionObject) {
+        const newVersionObject = versionObject;
+        newVersionObject.patch = newVersionObject.patch + 1;
+        return newVersionObject;
+    }
+
+    async mizOpen(mizPath) {
+        var MizFile = new jszip();
+        const mizData = fs.readFileSync(mizPath);
+        return MizFile.loadAsync(mizData);
+    }
+
+    async mizUpdate(mizPath, copyPath, strTheatreSettings) {
+        const zip = await this.mizOpen(mizPath);
+        this.mizUpdateSrcLuaFiles(zip);
+        this.mizUpdateLibLuaFiles(zip);
+        if (strTheatreSettings === null) {
+            // TODO: Inject fake data
+            console.log("NO THEATRE SPECIFIED. RADIO PRESETS WILL NOT BE AVAILABLE !");
+        } else {
+            await this.mizUpdateRadioPresets(zip, 'resources/radios/' + strTheatreSettings);
+        }
+        this.mizUpdateSettingsLuaFiles(zip, strTheatreSettings);
+        await this.mizUpdateSoundFolders(zip);
+        const inputZip = await zip.generateAsync({
+            type: 'nodebuffer',
+            streamFiles: true,
+            compression: "DEFLATE",
+            compressionOptions: {
+                level: 9
+            }
+        });
+        fs.writeFileSync(copyPath ? copyPath : mizPath, inputZip);
+    }
+
+    async mizInjectMissionDataFile(mizPath, missionObject) {
+        const zip = await this.mizOpen(mizPath);
+        this.mizUpdateMissionDataFile(zip, missionObject);
+        const inputZip = await zip.generateAsync({
+            type: 'nodebuffer',
+            streamFiles: true,
+            compression: "DEFLATE",
+            compressionOptions: {
+                level: 9
+            }
+        });
+        fs.writeFileSync(mizPath, inputZip);
+    }
+
+    async mizInjectSettingsFolder(mizPath, settingsFolder) {
+        const zip = await this.mizOpen(mizPath);
+        for (let file of fs.readdirSync(settingsFolder).filter(file => file.endsWith(".lua"))) {
+            this.mizUpdateLuaFile(zip, [
+                settingsFolder,
+                "/",
+                file].join(""));
+        }
+        const inputZip = await zip.generateAsync({
+            type: 'nodebuffer',
+            streamFiles: true,
+            compression: "DEFLATE",
+            compressionOptions: {
+                level: 9
+            }
+        });
+        fs.writeFileSync(mizPath, inputZip);
+    }
+
+    async mizInjectMapResourceFile(mizPath, mapResourceObject) {
+        const zip = await this.mizOpen(mizPath);
+        this.mizUpdateMapResourceFile(zip, mapResourceObject);
+        const inputZip = await zip.generateAsync({
+            type: 'nodebuffer',
+            streamFiles: true,
+            compression: "DEFLATE",
+            compressionOptions: {
+                level: 9
+            }
+        });
+        fs.writeFileSync(mizPath, inputZip);
+    }
+
+    mizUpdateLuaFile(zip, filePath) {
+        zip.remove("l10n/DEFAULT/" + path.basename(filePath));
+        var stream = fs.createReadStream(filePath);
+        zip.file("l10n/DEFAULT/" + path.basename(filePath), stream);
+    }
+
+    mizUpdateSrcLuaFiles(zip) {
+        for (let file of fs.readdirSync('src').filter(file => file.endsWith(".lua"))) {
+            console.log('updating src/' + file + ' file in miz file');
+            this.mizUpdateLuaFile(zip, "src/" + file);
+        };
+    }
+
+    mizUpdateMissionDataFile(zip, missionObject) {
+        zip.remove("mission");
+        let missionLuaT = format(missionObject, { singleQuote: false })
+        missionLuaT = missionLuaT
+            .split('\n')
+            .slice(1, -1)
+            .join('\n')
+            .slice(0, -1)
+            .replace(/\[\"(\d+)\"\] = /g, "[$1] = ");
+        zip.file("mission", missionLuaT);
+    }
+
+    mizUpdateMapResourceFile(zip, mapResourceObject) {
+        zip.remove("l10n/DEFAULT/mapResource");
+        let mapResourceLuaT = format(mapResourceObject, { singleQuote: false })
+        mapResourceLuaT = mapResourceLuaT
+            .split('\n')
+            .slice(1, -1)
+            .join('\n')
+            .slice(0, -1)
+            .replace(/\[\"(\d+)\"\] = /g, "[$1] = ");
+        zip.file("l10n/DEFAULT/mapResource", mapResourceLuaT);
+    }
+
+    mizOpenMissionData(zipStream) {
+        return zipStream.file("mission").async("string");
+    }
+
+    mizOpenMapResource(zipStream) {
+        return zipStream.file("l10n/DEFAULT/mapResource").async("string");
+    }
+
+    mizUpdateLibLuaFiles(zip) {
+        for (let file of fs.readdirSync('lib').filter(file => file.endsWith(".lua"))) {
+            console.log('updating lib/' + file + ' file in miz file');
+            this.mizUpdateLuaFile(zip, "lib/" + file);
+        };
+    }
+
+    async mizUpdateRadioPresets(zip, preset_folder) {
+        const mission_object = await this.getMissionObjectFromZip(zip);
+        for (let file of fs.readdirSync(preset_folder).filter(file => file.endsWith(".lua"))) {
+            const file_data = fs.readFileSync(preset_folder + '/' + file).toString();
+            const lua_string = file_data.substring(0, file_data.indexOf("radio_descriptor_table =") - 1);
+            const radio_descriptor_table = parse("return {" + lua_string + "}").descriptor;
+
+            console.log('updating radio presets (aircraft: ' + radio_descriptor_table["aircraft"] + ', group_name: ' + radio_descriptor_table["group_name"] + ') with preset in ' + preset_folder + ' folder');
+            const dcs_radio_presets = file_data.substring(file_data.indexOf("radio_descriptor_table =") + 24);
+
+            for (const coalition_key in mission_object.coalition) {
+                const coalition = mission_object.coalition[coalition_key];
+                for (const country_list_key in coalition) {
+                    if (country_list_key != "country") continue;
+                    const country_list = coalition[country_list_key];
+                    for (const country_key in country_list) {
+                        const country = country_list[country_key];
+                        for (const plane_key in country["plane"]) {
+                            const plane = country["plane"][plane_key];
+                            for (const group_key in plane) {
+                                const group = plane[group_key];
+                                if (group["name"].match(radio_descriptor_table["group_name"]) == null) continue;
+                                for (const unit_key in group) {
+                                    if (unit_key != "units") continue;
+                                    const unit = group[unit_key];
+                                    for (const sub_unit_key in unit) {
+                                        const sub_unit = unit[sub_unit_key];
+                                        if (sub_unit["skill"] != "Client") continue;
+                                        if (sub_unit["type"] != radio_descriptor_table["aircraft"]) continue;
+                                        // GROUP FOUND, SET RADIOS
+                                        sub_unit["Radio"] = parse("return " + dcs_radio_presets)
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        };
+        this.mizUpdateMissionDataFile(zip, {mission: mission_object});
+    }
+
+    mizUpdateSettingsLuaFiles(zip, strTheatre) {
+        for (let file of fs.readdirSync('settings/' + strTheatre).filter(file => file.endsWith(".lua"))) {
+            console.log('updating settings/' + strTheatre + '/' + file + ' file in miz file');
+            this.mizUpdateLuaFile(zip, 'settings/' + strTheatre + '/' + file);
+        };
+    }
+
+    async mizUpdateSoundFolders(zip) {
+        const folderArray = fs.readdirSync('resources/sounds');
+        for (const folder of folderArray) {
+            // if(zip.folder(new RegExp(folder)).length > 0 ) {
+            await this.mizUpdateSingleSoundFolder(zip, folder);
+            // }
+        }
+    }
+
+    async mizUpdateSingleSoundFolder(zip, folder) {
+        console.log('adding sound files from resources/sounds/' + folder + ' folder...');
+        zip = zip.remove(folder).folder(folder);
+        await this.addFilesToZip(zip, 'resources/sounds/' + folder, fs.readdirSync('resources/sounds/' + folder));
+    }
+
+    async addFilesToZip(zip, directoryPath, filesToInclude) {
+        const promiseArr = await filesToInclude.map(async file => {
+            const filePath = path.join(directoryPath, file)
+            try {
+                const fileStats = await lstat(filePath)
+                const isDirectory = fileStats.isDirectory()
+                if (isDirectory) {
+                    const directory = zip.remove(file).folder(file)
+                    const subFiles = fs.readdirSync(filePath)
+                    return this.addFilesToZip(directory, filePath, subFiles)
+                } else {
+                    // console.log('added file : '+file);
+                    return zip.file(file, fs.createReadStream(filePath))
+                }
+            } catch (err) {
+                console.log(err)
+                return Promise.resolve()
+            }
+        })
+        return Promise.all(promiseArr)
+    }
+
+    async copyMiz(srcMizPath, dstMizPath) {
+        await fs.createReadStream(srcMizPath).pipe(fs.createWriteStream(dstMizPath));
+    }
+
+    async getMissionObjectFromMiz(MizPath) {
+        let luaTable = 'return { \n' + await this.mizOpenMissionData(await this.mizOpen(MizPath)) + ' }';
+        return parse(luaTable).mission;
+    }
+
+    async getMissionObjectFromZip(zip) {
+        let luaTable = 'return { \n' + await this.mizOpenMissionData(zip) + ' }';
+        return parse(luaTable).mission;
+    }
+
+    async getMapResourceObjectFromMiz(MizPath) {
+        let luaTable = 'return { \n' + await this.mizOpenMapResource(await this.mizOpen(MizPath)) + ' }';
+        return parse(luaTable).mapResource;
+    }
+
+    getDestinationMizFilePaths() {
+        const returnArray = this.config.missionTemplates.map(missionTemplate => {
+            return this.config.general.missionFolder + '/'
+                + this.config.general.missionPrefix + '_'
+                + missionTemplate.theatre + '_'
+                + this.config.general.missionSuffix
+                + '_' + this.config.general.missionVersion + '.miz'
+        });
+        return returnArray;
+    }
+
+    getGeneratedMizFilePaths() {
+        return fs.readdirSync(this.config.general.missionFolder + '/')
+            .filter(file => file.endsWith((".miz")))
+            .map(mizFile => {
+                return this.config.general.missionFolder + '/' + mizFile;
+            });
+    }
+
+    uploadMizFiles(credentials) {
+        const jtffFtpServer = new ftpClient();
+
+        jtffFtpServer.connect({
+            host: credentials.host,
+            secure: false,
+            user: credentials.user,
+            password: credentials.password
+        });
+        jtffFtpServer.on('ready', function () {
+            jtffFtpServer.cwd(credentials.folder, function (err, curDir) {
+                if (err) throw err;
+                Promise.all(
+                    fs.readdirSync(this.config.general.missionFolder)
+                        .filter(file => file.endsWith('.pub.json'))
+                        .map(file => {
+                            return new Promise((resolve, reject) => {
+                                // console.log(this.config.general.missionFolder+'/'+file);
+                                fs.readFile(this.config.general.missionFolder + '/' + file, function (err, data) {
+                                    if (err) reject(err);
+                                    data = JSON.parse(data.toString());
+                                    // console.log(data);
+                                    jtffFtpServer.put(data.mizFiles, path.basename(data.mizFiles), false, function (err) {
+                                        if (err) reject(err);
+                                        console.log('file ' + path.basename(data.mizFiles) + ' uploaded on DCS Server');
+                                        resolve(path.basename(data.mizFiles));
+                                    });
+                                });
+                            })
+                        })
+                ).then(() => {
+                    jtffFtpServer.end();
+                });
+            });
+        });
+    }
+
+    publishMizFiles(credentials) {
+        const jwtClient = new google.auth.JWT(
+            credentials.client_email,
+            null,
+            credentials.private_key,
+            this.config.google.scopes
+        );
+        const configObject = this.config;
+        jwtClient.authorize(function (err, tokens) {
+            if (err) {
+                console.log(err);
+                throw err;
+            } else {
+                console.log("Successfully connected!");
+                const drive = google.drive({ version: 'v3', jwtClient });
+                fs.readdirSync(configObject.general.missionFolder)
+                    .filter(file => file.endsWith('.pub.json'))
+                    .map(file => {
+                        // console.log(this.config.general.missionFolder+'/'+file);
+                        fs.readFile(configObject.general.missionFolder + '/' + file, function (err, data) {
+                            if (err) throw err;
+                            data = JSON.parse(data.toString());
+                            // console.log(data);
+                            drive.files.list({
+                                q: `'${data.gdriveFolder}' in parents and trashed = false and name = '${path.basename(data.mizFiles)}'`,
+                                auth: jwtClient
+                            }).then(rsp => {
+                                // console.log(rsp.data.files);
+                                // console.log(path.basename(data.mizFiles));
+                                const fileMetadata = {
+                                    'name': path.basename(data.mizFiles),
+                                    parents: [data.gdriveFolder]
+                                };
+                                const media = {
+                                    mimeType: 'application/zip',
+                                    body: fs.createReadStream(data.mizFiles)
+                                };
+                                if (rsp.data.files.length > 0) {
+                                    drive.files.update({
+                                        fileId: rsp.data.files[0].id,
+                                        auth: jwtClient,
+                                        media: media
+                                    }, (err, file) => {
+                                        if (err) {
+                                            // Handle error
+                                            console.error(err);
+                                        } else {
+                                            console.log('File updated Id: ', file.id);
+                                        }
+                                    });
+                                } else {
+                                    drive.files.create({
+                                        resource: fileMetadata,
+                                        media: media,
+                                        auth: jwtClient,
+                                        fields: 'id'
+                                    }, (err, file) => {
+                                        if (err) {
+                                            // Handle error
+                                            console.error(err);
+                                        } else {
+                                            console.log('File created Id: ', file.id);
+                                        }
+                                    });
+                                }
+                            });
+                        });
+                    });
+            }
+        });
+    }
+
+}
+
+module.exports = MizTemplateCI;

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@jtff/miztemplate-lib",
+  "version": "2.0.1",
+  "description": "JTFF mission template library",
+  "main": "index.js",
+  "files": [
+    "index.js",
+    "scripts",
+    "lib"
+  ],
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/JTFF-mission-scripts/miztemplate-lib.git"
+  },
+  "keywords": [
+    "DCS",
+    "World",
+    "JTFF"
+  ],
+  "author": "Sebastien LONGO",
+  "license": "GPL-3.0-or-later",
+  "bugs": {
+    "url": "https://github.com/JTFF-mission-scripts/miztemplate-lib/issues"
+  },
+  "homepage": "https://github.com/JTFF-mission-scripts/miztemplate-lib#readme",
+  "dependencies": {
+    "fs": "^0.0.1-security",
+    "ftp": "^0.3.10",
+    "googleapis": "^92.0.0",
+    "jszip": "^3.7.1",
+    "lua-json": "^1.0.0",
+    "path": "^0.12.7",
+    "prompt": "^1.3.0",
+    "util": "^0.12.4"
+  }
+}

package/scripts/build.js

@@ -0,0 +1,40 @@
+const fs = require("fs");
+
+function build(jtffci) {
+    fs.mkdirSync(jtffci.config.general.missionFolder, { recursive: true });
+    jtffci.config.missionTemplates.forEach(async missionTemplate => {
+        await jtffci.mizUpdate([
+            missionTemplate.prefix,
+            '_',
+            missionTemplate.theatre,
+            ".miz"
+        ].join(""), [
+            jtffci.config.general.missionFolder + '/' + jtffci.config.general.missionPrefix,
+            '_',
+            missionTemplate.theatre,
+            '_',
+            jtffci.config.general.missionSuffix,
+            '_',
+            jtffci.displayVersion(jtffci.getVersion()),
+            ".miz"
+        ].join(""), missionTemplate.theatre);
+        let publicationConfig = {
+            theatre: missionTemplate.theatre,
+            mizFiles: [
+                jtffci.config.general.missionFolder + '/' + jtffci.config.general.missionPrefix,
+                '_',
+                missionTemplate.theatre,
+                '_',
+                jtffci.config.general.missionSuffix,
+                '_',
+                jtffci.displayVersion(jtffci.getVersion()),
+                ".miz"
+            ].join(""),
+            gdriveFolder: missionTemplate.destFolderId
+        };
+        fs.writeFileSync(jtffci.config.general.missionFolder + '/' + missionTemplate.theatre + '.pub.json', JSON.stringify(publicationConfig, null, 4));
+    });
+
+}
+
+module.exports = build

package/scripts/clean.js

@@ -0,0 +1,7 @@
+const fs = require("fs");
+
+function clean(config) {
+    fs.rmSync(config.general.missionFolder, { force: true, recursive: true })
+}
+
+module.exports = clean

package/scripts/ftpupload.js

@@ -0,0 +1,13 @@
+function ftpupload(jtffci) {
+    let intRC = 0;
+    if (process.env.JTFF_FTP_SECRET_JSON) {
+        const jtffcreds = JSON.parse(process.env.JTFF_FTP_SECRET_JSON);
+        jtffci.uploadMizFiles(jtffcreds);
+    } else {
+        console.error('no FTP credentials provided in JTFF_FTP_SECRET_JSON variable');
+        intRC=1;
+    }
+    return intRC;
+}
+
+module.exports = ftpupload

package/scripts/gdrive-upload.js

@@ -0,0 +1,13 @@
+function gdriveupload(jtffci) {
+    let intRC = 0;
+    if (process.env.GDRIVE_TOKEN_CACHE_JSON) {
+        const gcreds = JSON.parse(process.env.GDRIVE_TOKEN_CACHE_JSON);
+        jtffci.publishMizFiles(gcreds);
+    } else {
+        console.error('no google drive credentials provided in GDRIVE_TOKEN_CACHE_JSON variable');
+        intRC = 1;
+    }
+    return intRC;
+}
+
+module.exports = gdriveupload

package/scripts/get-mizfiles.js

@@ -0,0 +1,5 @@
+function getMizFile(jtffci) {
+    console.log(JSON.stringify(jtffci.getGeneratedMizFilePaths()));
+}
+
+module.exports = getMizFile;

package/scripts/getset-version.js

@@ -0,0 +1,14 @@
+function getVersion(jtffci) {
+    console.log('getting version...');
+    console.log((jtffci.getVersion()));
+}
+
+function setVersion(jtffci, strVersion, configFilePath) {
+    console.log('setting version to : ' + strVersion);
+    jtffci.setVersionfromString(strVersion, configFilePath);
+}
+
+module.exports = {
+    getVersion:getVersion,
+    setVersion:setVersion
+};