prepareTemplateCore.js

const fs = require('fs');
const path = require('path');
const replace = require('replace-in-file');
const _ = require('lodash');
const isDebugLogOn=false
function getTemplateFiles(dir) {

    if (isDebugLogOn) console.log(" getTemplateFiles: " + dir);
    let files = fs.readdirSync(dir);
    files = files.map(file => {
        const filePath = path.join(dir, file);
        const stats = fs.statSync(filePath);
        if (stats.isDirectory()) return getTemplateFiles(filePath);
        else if (stats.isFile()) return filePath;
    });
    return files.reduce((all, folderContents) => all.concat(folderContents), []);
}


/// the flow is: From DirectoryToParse to Public Folder to Schema 
function prepareSchemas(directoryToParse) {
    console.log("Copying backend schema files...  : " + directoryToParse);
    try {
        startpreparingSchemas(directoryToParse);
    }
    catch (error) {
        console.trace(error);
    }
}
module.exports = {
    prepareSchemas: prepareSchemas

}



function startpreparingSchemas(directoryToParse) {

    if (isDebugLogOn) console.log("startpreparingSchemas")
    // Get and Copy all template files from backend source to frontend app folders and format as required
    let backEndFiles = getTemplateFiles(directoryToParse);

    if (backEndFiles !== null) {
        if (isDebugLogOn) console.log("getTemplateFiles:", directoryToParse)
        // Copy backend template json files to public/schemas folder in frontend app
        copyFromBackEnd(backEndFiles, directoryToParse);

        // Get all template files from public/schema folder and format as required
        let files = getTemplateFiles('public' + path.sep + 'schemas')
        replaceHosts(files);
        scanFiles(files);
        parseStrategicFiles();
    }


    console.log("Getting definitions from common_schema_templates....");
    let definitionTemplates = getTemplateFiles("build/schemas/common_schema_template");
    console.log(definitionTemplates);
    let definitions = {}, definitionFiles = [];
    for (const definitionTemplate of definitionTemplates) {
        const data = fs.readFileSync(definitionTemplate, 'utf8');
        let definitionSchema = JSON.parse(data);
        if (definitionSchema.schema && definitionSchema.schema.definitions) {
            definitions = { ...definitions, ...definitionSchema.schema.definitions };
            definitionFiles.push(definitionTemplate.substring(definitionTemplate.lastIndexOf("/") + 1));
        }
    }
    if (isDebugLogOn) console.log("... got definitions");
    convertConstraintTemplates(definitions, definitionFiles);
    converTaskTemplates(definitions, definitionFiles);


}
function converTaskTemplates(definitions, definitionFiles) {
    let taskFiles = getTemplateFiles("build/schemas/task_template");

    if (taskFiles !== null) {
        let templates = [];
        let index = 1;
        if (isDebugLogOn) console.log("Getting task_templates");
        for (const file of taskFiles) {

            if (isDebugLogOn) console.log("Working on File:" + file);
            const data = fs.readFileSync(file, 'utf8');
            let taskTemplate = JSON.parse(data);

            taskTemplate.id = index;
            taskTemplate.ref_resolved_schema = { definitions: definitions, properties: taskTemplate.schema["properties"] };
            shortenUrls(taskTemplate);
            if (isDebugLogOn) console.log("added ref_solved_schema for Task template :" + file)
            let stationconfig = taskTemplate?.schema?.properties?.station_configuration;
            if (stationconfig) { taskTemplate.schema.properties.station_configuration["$ref"] = "#/definitions/station_configuration"; }
            if (taskTemplate?.schema?.properties?.QA) taskTemplate.schema.properties.QA["$ref"] = "#/definitions/QA";
            if (taskTemplate?.schema?.properties?.duration) taskTemplate.schema.properties.duration["$ref"] = "#/definitions/duration";
            if (taskTemplate?.schema?.properties?.calibrator) taskTemplate.schema.properties.calibrator["$ref"] = "#/definitions/calibrator";
            if (taskTemplate?.schema?.properties?.correlator) taskTemplate.schema.properties.correlator["$ref"] = "#/definitions/correlator";
            if (taskTemplate?.schema?.properties?.beamformer) { taskTemplate.schema.properties.beamformer["$ref"] = "#/definitions/beamformer"; }
            if (taskTemplate?.schema?.properties?.pointing) { taskTemplate.schema.properties.pointing["$ref"] = "#/definitions/pointing"; }
            
            index++;
            templates.push(taskTemplate);
        }
        templates = JSON.stringify(templates);
        templates = templates.replace(/http:\/\/localhost:3000\/schemas\/common_schema_template\//g, "");
        templates = templates.replace(/"\$ref":\s*"https:\/\/tmss\.lofar\.eu\/api\/schemas\/commonschematemplate\/.*?\/definitions\/(.*?)"/g, '"$ref": "#/definitions/$1"');



        
        for (const defFile of definitionFiles) {
            const fileRegex = new RegExp(defFile, 'g');
            templates = templates.replace(fileRegex, "");
        }
        
        //fs.writeFileSync("src/__mocks__/task_templates.log", templates);
        const jsonObject = JSON.parse(templates);
        //console.log(jsonObject);
        
        if (isDebugLogOn) console.log("Creating task_templates.json ...");
        fs.writeFileSync("src/__mocks__/task_templates.json", JSON.stringify({ templates: jsonObject }, null, 4));
        if (isDebugLogOn) console.log("... Created task_templates.json");
    }
}

function copyFromBackEnd(backEndFiles, directoryToParse) {
    for (let file of backEndFiles) {
        if (file.indexOf(".json") <= 0) { continue; }

        let folderName = file.replace(directoryToParse, "");
        if (isDebugLogOn) console.log("file" + file + " directoryToParse:" + directoryToParse + " foldername:" + folderName);
        folderName = folderName.substring(1, folderName.lastIndexOf(path.sep));
        let fileName = file.substring(file.lastIndexOf(path.sep) + 1);
        const data = fs.readFileSync(file, 'utf8');

        let folderschemapath = "public" + path.sep + "schemas" + path.sep + folderName;
        if (!fs.existsSync(folderschemapath)) {
            console.log("Creating folder ...", folderschemapath);
            fs.mkdirSync(folderschemapath, { recursive: true });
        }
        let filenamewithpath = folderschemapath + path.sep + fileName;
        console.log("filename:" + fileName)
        console.log("folderschemapath:" + folderschemapath)

        console.log("Writing to file...", filenamewithpath);
        fs.writeFileSync(filenamewithpath, data);
    }
}

function parseStrategicFiles() {
    let strategyFiles = getTemplateFiles("build/schemas/scheduling_unit_observing_strategy_template");
    let strategies = [];
    let index = 1;
    if (isDebugLogOn) console.log("Getting observing_strategy_templates");
    for (const file of strategyFiles) {
        if (isDebugLogOn)  console.log("StrategyFiles:" + file);
        const data = fs.readFileSync(file, 'utf8');
        let strategyTemplate = JSON.parse(data);
        strategyTemplate.id = index;
        strategyTemplate.state_value = strategyTemplate.state;
        strategyTemplate.purpose_value = strategyTemplate.purpose;
        index++;
        strategies.push(strategyTemplate);
    }
    if (isDebugLogOn)  console.log("Creating observing_strategy_templates.json ...");
    fs.writeFileSync("src/__mocks__/observing_strategy_templates.json", JSON.stringify({ strategies: strategies }, null, 4));
    if (isDebugLogOn) console.log("... Created observing_strategy_templates.json");
}

function shortenUrls(taskTemplate) {
    if (taskTemplate.name.indexOf("observation") >= 0) {
        taskTemplate.type = "http://localhost:3000/api/task_type/observation";
        taskTemplate.type_value = "observation";
    } else if (taskTemplate.name.indexOf("pipeline") >= 0) {
        taskTemplate.type = "http://localhost:3000/api/task_type/pipeline";
        taskTemplate.type_value = "pipeline";
    } else if (taskTemplate.name.indexOf("cleanup") >= 0) {
        taskTemplate.type = "http://localhost:3000/api/task_type/cleanup";
        taskTemplate.type_value = "cleanup";
    } else if (taskTemplate.name.indexOf("ingest") >= 0) {
        taskTemplate.type = "http://localhost:3000/api/task_type/ingest";
        taskTemplate.type_value = "ingest";
    }
}

function replaceHosts(files) {
    if (isDebugLogOn)  console.log("Replace Hosts...", files);

    if (files !== null) {
        if (isDebugLogOn) console.log("Updating schema ref path...");
        if (isDebugLogOn) console.log(files.join(', '));
        if (isDebugLogOn)  console.log("Replace the host and port address of template apis to localhost");


        const hostReplaceOptions = {
            files: files,
            from: /http:\/\/127.0.0.1:8000\/api/g,
            to: 'http://localhost:3000',
        };
        if (isDebugLogOn) console.log(" \\ hostReplaceOptions (127.0.0.1 to localhost)  ");
        try {
            const results = replace.sync(hostReplaceOptions);
           if (isDebugLogOn) console.log('Replacement Results:', results);
        }
        catch (error) {
            console.error('Replacement Error occurred:', error);
        }

        if (isDebugLogOn) console.log(" / hostReplaceOptions ");
        const hostReplaceOptionslofar = {
            files: files,
            from: /https:\/\/tmss.lofar.eu\/api/g,
            to: 'http://localhost:3000',
        };
        if (isDebugLogOn) console.log(" \\ hostReplaceOptionslofar (tms lofar to localhost)  ");
        try {
            const results = replace.sync(hostReplaceOptionslofar);
            if (isDebugLogOn) console.log('hostReplaceOptionslofar changed files:', results.join(', '));
        }
        catch (error) {
            console.error('hostReplaceOptionslofar Error occurred:', error);
        }


        if (isDebugLogOn) console.log(" /  hostReplaceOptionslofar   ");


        convertVersions(files);
        if (isDebugLogOn) console.log("Past  Replacer One ");
    }
}

function scanFiles(files) {
    for (let file of files) {
        if (file.indexOf(".json") <= 0) { continue; }
        if (isDebugLogOn)  console.log("In Loop, Looking at " + file);

        let folderName = file.substring(file.indexOf("schemas" + path.sep) + 8, file.lastIndexOf(path.sep));
        if (isDebugLogOn) console.log("In Loop, Looking at " + file + " in folder" + folderName);
        // Replae folder name		
        let folderRef = folderName.replace(/_/g, "");
        if (isDebugLogOn) console.log("In Loop, Looking at " + file + " in folder" + folderName + " in text  replaced to " + folderRef);
        let folderRefRegex = new RegExp(folderRef, "g");
        const folderReplaceOptions = {
            files: files,
            from: folderRefRegex,
            to: folderName,
        };

        if (isDebugLogOn) console.log("\\ folderReplaceOptions  file:" + file + ' folder:' + folderRef);
        try {
            const results = replace.sync(folderReplaceOptions);
            if (isDebugLogOn) console.log('folderReplaceOptions Results:', results);
        }
        catch (error) {
            console.error('folderReplaceOptions Error occurred:', error);
        }
        if (isDebugLogOn)  console.log("/ folderReplaceOptions   ");
        copyToBuildFolder(file, folderName);
    }
}

function copyToBuildFolder(file, folderName) {
    console.log("Copy templates to build folder so that it can be referred by the test suites . file" + file);
    const data = fs.readFileSync(file, 'utf8');
    //console.log(data)
    if (!fs.existsSync("build/schemas/" + folderName)) {
        console.log("Creating folder.... build/schemas/" + folderName);
        fs.mkdirSync("build/schemas/" + folderName, { recursive: true });
    }
    console.log("Copying files from ", file, "to", file.replace("public", "build"));
    fs.writeFileSync(file.replace("public", "build"), data);

    // Update the json files in public/schemas folder to contain only the schema object
    const jsonData = JSON.parse(data);
    if (jsonData["schema"]) {
        console.log("Updating schema file...", file);
        fs.writeFileSync(file, JSON.stringify(jsonData["schema"], null, 4));
    } else {
        console.log("Not Updating schema file..., no schema in top node", file);
    }
}

function convertVersions(files) {
    for (const ver of _.range(1, 14)) {
        let verRegx = new RegExp(`/${ver}/#`, 'g');
        let verReplacer = `-${ver}.json#`;
        // Replace db_id with file extension
        const fileReplaceOptions = {
            files: files,
            from: verRegx,
            to: verReplacer
        };

        if (isDebugLogOn)  console.log("\\ fileReplaceOptions   ");
        try {
            const results = replace.sync(fileReplaceOptions);
            if (isDebugLogOn) console.log('fileReplaceOptions Results:', results);
        }
        catch (error) {
            console.error('fileReplaceOptions Error occurred:', error);
        }
        if (isDebugLogOn) console.log("/ fileReplaceOptions   ");

        verRegx = new RegExp(`/${ver}#`, 'g');
        const fileReplaceOptions1 = {
            files: files,
            from: verRegx,
            to: verReplacer
        };


        if (isDebugLogOn) console.log("\\ fileReplaceOptions1   ");
        try {
            const results = replace.sync(fileReplaceOptions1);
            if (isDebugLogOn)  console.log('fileReplaceOfileReplaceOptions1ptions Results:', results);
        }
        catch (error) {
            console.error('fileReplaceOptions1 Error occurred:', error);
        }

    }
}

function convertConstraintTemplates(definitions, definitionFiles) {
    let constrainttemplatefiles = getTemplateFiles("build/schemas/scheduling_constraints_template");


    if (constrainttemplatefiles !== null) {
        let index = 0;
        const constraintDefinitionKeys = ["distance_on_sky", "elevation", "timedelta", "timestamp", "timewindow", "pointing"];
        for (const file of constrainttemplatefiles) {
            const data = fs.readFileSync(file, 'utf8');
            let constraintTemplate = JSON.parse(data);
            constraintTemplate.id = index;
            convertResolved(constraintTemplate, constraintDefinitionKeys, definitions);
            index++;
            constraintTemplate = JSON.stringify(constraintTemplate);
            constraintTemplate = constraintTemplate.replace(/http:\/\/localhost:3000\/schemas\/common_schema_template\//g, "");
            for (const defFile of definitionFiles) {
                const fileRegex = new RegExp(defFile, 'g');
                constraintTemplate = constraintTemplate.replace(fileRegex, "");
            }
            fs.writeFileSync(file, JSON.stringify(JSON.parse(constraintTemplate), null, 4));
            if (isDebugLogOn) console.log("... added ref_resolved_schema to constraints_template:" + file);
        }
    }
}

function convertResolved(Template, DefinitionKeys, definitions) {
    Template.ref_resolved_schema = _.cloneDeep(Template.schema);
    for (const defKey of DefinitionKeys) {

        if (definitions[defKey]) {
            if (isDebugLogOn) console.log("has key" + defKey);
            if (Template.ref_resolved_schema.definition) {
                if (isDebugLogOn)  console.log(" Setting resolved value for ", defKey)
                Template.ref_resolved_schema.definitions[defKey] = definitions[defKey];
            }
        }
    }
}