@intecoag/inteco-cli 0.5.1

package/src/modules/importDB.js

@@ -0,0 +1,121 @@
+import prompts from "prompts"
+import { writeFileSync, readFileSync, readdirSync, writeFile, unlinkSync, mkdirSync, renameSync, rmSync, copyFileSync } from "fs";
+import Seven from 'node-7z'
+import ora from "ora";
+import { DB } from "../utils/db/DB.js";
+import { exec, execFile, execFileSync, execSync } from "child_process";
+import { Config } from "../utils/config/config.js";
+import chalk from "chalk";
+import path from "path";
+import sevenBin from '7zip-bin'
+
+
+export default async function importDB(cli) {
+    console.log()
+
+    const config = await Config.getConfig();
+
+    const files = readdirSync(process.cwd(), { withFileTypes: true }).filter(dirent => dirent.isFile()).map(dirent => { return { title: dirent.name } })
+
+    let success = true;
+
+    const results = await prompts([
+        {
+            // Ordnerauswahl von vorhandenen Ordner in configIndividual
+            type: 'autocomplete',
+            name: 'file',
+            message: 'Dump-Name?',
+            choices: files
+        },
+        {
+            // Ordnerauswahl von vorhandenen Ordner in configIndividual
+            type: 'text',
+            name: 'dbName',
+            message: 'DB-Name?'
+        },
+        {
+            type: 'toggle',
+            name: 'dropDB',
+            message: 'Delete and Recreate DB before import?',
+            initial: true,
+            active: 'yes',
+            inactive: 'no'
+        }
+    ], {
+        onCancel: () => {
+            console.log()
+            console.log(chalk.red("Cancelled Import!"))
+            console.log()
+            success = false
+        }
+    })
+
+    if (success) {
+        console.log()
+        rmSync("." + path.sep + "dump", { recursive: true, force: true })
+        mkdirSync("." + path.sep + "/dump", { recursive: true })
+
+        if (await isArchive(results.file)) {
+
+            const spinnerZIP = ora('Unpacking Archive').start();
+
+            const unpack = Seven.extract(results.file, "." + path.sep + "dump", {
+                $bin: sevenBin.path7za
+            })
+
+            unpack.on('end', async () => {
+                const filename = readdirSync("." + path.sep + "dump")[0]
+                renameSync("." + path.sep + "dump" + path.sep + "" + filename, "." + path.sep + "dump" + path.sep + "dump.sql")
+                spinnerZIP.succeed("Archive unpacked")
+
+                await importDBActual(config, results)
+            })
+        }else{
+            const spinnerCopy = ora('Copying Dump').start();
+
+            copyFileSync("."+path.sep+results.file, "." + path.sep + "dump" + path.sep + "dump.sql")
+
+            spinnerCopy.succeed("Dump copied")
+
+            await importDBActual(config, results)
+        }
+    }
+}
+
+function isArchive(file) {
+    return new Promise((resolve, reject) => {
+        const test = Seven.list("."+path.sep+file, {
+            $bin: sevenBin.path7za
+        });
+        test.on('end', (stream) => {
+            resolve(true)
+        })
+        test.on('error', (stream) => {
+            resolve(false)
+        })
+    });
+}
+
+async function importDBActual(config, results) {
+    const spinnerImport = ora('Importing DB').start();
+
+    if (results.dropDB) {
+        await DB.executeQuery("DROP DATABASE IF EXISTS " + results.dbName);
+        await DB.executeQuery("CREATE DATABASE " + results.dbName);
+    }
+
+    exec("mysql -u " + config.dbUser + " -p" + config.dbPassword + " " + results.dbName + " < dump" + path.sep + "dump.sql", (error, stdout, stderr) => {
+        if (error != null) {
+            spinnerImport.fail("Database-Import failed!")
+            console.log(error)
+        } else {
+            spinnerImport.succeed("Database imported")
+
+            const deleteSpinner = ora("Delete temporary dump").start()
+            rmSync("." + path.sep + "dump", { recursive: true, force: true })
+            deleteSpinner.succeed("Dump deleted")
+        }
+
+        console.log()
+    })
+}

package/src/modules/rewriteConfig.js

@@ -0,0 +1,79 @@
+import prompts from "prompts";
+import os from 'os';
+import { createEditor } from "properties-parser";
+import { writeFileSync, readFileSync, readdirSync } from "fs";
+import YAML from 'yaml'
+import chalk from "chalk";
+import { Config } from "../utils/config/config.js";
+import { DB } from "../utils/db/DB.js";
+import path from "path";
+
+
+
+async function configRewrite(cli) {
+    console.log()
+
+    const homedir = os.homedir();
+
+    const config = await Config.getConfig();
+
+    const databaseNames = await DB.getDatabaseNames();
+
+    const configDirectories = readdirSync(config.configIndividualPath, { withFileTypes: true }).filter(dirent => dirent.isDirectory()).map(dirent => { return { title: dirent.name } })
+
+    let success = true;
+
+    const responses = await prompts([{
+        // DB-Auswahl von DB
+        type: 'autocomplete',
+        name: 'dbName',
+        message: 'DB-Name?',
+        choices: databaseNames.map(name => { return { title: name.name } })
+    }, {
+        // Ordnerauswahl von vorhandenen Ordner in configIndividual
+        type: 'autocomplete',
+        name: 'configName',
+        message: 'ConfigIndividual-Name?',
+        choices: configDirectories
+    }, {
+        type: 'number',
+        name: 'mnr',
+        message: 'Mandant?',
+        initial: '1'
+    }], {
+        onCancel: () => {
+            console.log()
+            console.log(chalk.red("Cancelled Rewrite!"))
+            console.log()
+            success = false
+        }
+    });
+
+    if (success) {
+        // Rewrite jwegas.properties
+        const editorJwegasProperties = createEditor(homedir + path.sep+"jwegas.properties")
+        editorJwegasProperties.set("user.mandant", responses.mnr.toString());
+        editorJwegasProperties.save();
+
+        // Rewrite wegas.properties
+        const editorWegasProperties = createEditor(config.configIndividualPath + path.sep+"wegas.properties")
+        editorWegasProperties.set("db.database", responses.dbName);
+        editorWegasProperties.save();
+
+        // Rewrite path.yaml
+        const content = readFileSync(config.configIndividualPath +path.sep+"path.yaml", "utf-8");
+
+        const doc = YAML.parseDocument(content)
+
+        doc.set("pathIndividual", config.configIndividualPathWrite + "\\\\" + responses.configName + "\\\\")
+
+        writeFileSync(config.configIndividualPath +path.sep+"path.yaml", doc.toString());
+
+        console.log()
+        console.log(chalk.green("Config-Rewrite successful!"))
+        console.log()
+    }
+
+}
+
+export default configRewrite;

package/src/modules/setCLIConfig.js

@@ -0,0 +1,33 @@
+import prompts from "prompts";
+import { Config } from "../utils/config/config.js";
+import chalk from "chalk";
+
+export default async function writeCLIConfig(){
+    console.log()
+    
+    let data = await Config.getConfig();
+
+    let keys = Object.keys(data);
+    let success = true;
+    
+    const responses = await prompts(keys.map(key =>  {
+        return {
+        // Ordnerauswahl von vorhandenen Ordner in configIndividual
+        type: 'text',
+        name: key,
+        message: key+":",
+        initial: data[key]
+        }
+    }), {
+        onCancel: () => {
+            console.log()
+            console.log(chalk.red("Cancelled Config!"))
+            console.log()
+            success = false
+        }
+    })
+
+    if(success){
+        Config.setConfig(responses)
+    }
+}

package/src/modules/syncConfig.js

@@ -0,0 +1,264 @@
+import prompts from "prompts";
+import { mkdirSync, existsSync, readdirSync, rmSync } from "fs";
+import path from "path";
+import chalk from "chalk";
+import { Config } from "../utils/config/config.js";
+import { FS } from "../utils/fs/FS.js";
+
+export default async function syncConfig() {
+    console.log()
+
+    const config = await Config.getConfig();
+
+    const configDirectoriesEclipse = readdirSync(config.configIndividualPathEclipse, { withFileTypes: true }).filter(dirent => dirent.isDirectory()).map(dirent => { return { title: dirent.name } })
+
+    const configDirectories = readdirSync(config.configIndividualPath, { withFileTypes: true }).filter(dirent => dirent.isDirectory()).map(dirent => { return { title: dirent.name } })
+
+    let success = true;
+
+    const responses = await prompts([
+        {
+            type: 'select',
+            name: 'direction',
+            message: 'Select Direction:',
+            choices: [
+                { title: 'Import ConfigIndividual (Repository → Work)', value: 'import' },
+                { title: 'Export ConfigIndividual (Work → Repository)', value: 'export' },
+                { title: 'Import Config (Repository → Work)', value: 'import_config' },
+                { title: 'Export Config (Work → Repository)', value: 'export_config' },
+                { title: 'Import Everything (Repository → Work)', value: 'import_all' },
+                { title: 'Export Everything (Work → Repository)', value: 'export_all' },
+                { title: 'Import All ConfigIndividual (Repository → Work)', value: 'import_all_individuals' },
+                { title: 'Export All ConfigIndividual (Work → Repository)', value: 'export_all_individuals' }
+            ]
+        },
+        {
+            type: (prev) => (prev === 'import' || prev === 'export') ? 'autocomplete' : null,
+            name: 'configNameSource',
+            message: (prev, values) => values.direction === 'import'
+                ? 'ConfigIndividual from Repository (Origin)?'
+                : 'ConfigIndividual from Work (Origin)?',
+            choices: (prev, values) => values.direction === 'import'
+                ? configDirectoriesEclipse
+                : configDirectories
+        },
+        {
+            type: (prev, values) => (values.direction === 'import' || values.direction === 'export') ? 'autocomplete' : null,
+            name: 'configNameTarget',
+            message: (prev, values) => values.direction === 'import'
+                ? 'ConfigIndividual in Work (Destination)?'
+                : 'ConfigIndividual in Repository (Destination)?',
+            choices: (prev, values) => values.direction === 'import'
+                ? configDirectories
+                : configDirectoriesEclipse,
+            suggest: (input, choices) => {
+                const filtered = choices.filter(choice =>
+                    choice.title.toLowerCase().includes(input.toLowerCase())
+                );
+                if (input && !choices.some(c => c.title === input)) {
+                    return [...filtered, { title: `Use custom name: "${input}"`, value: input }];
+                }
+                return filtered;
+            }
+        },
+        {
+            type: 'toggle',
+            name: 'dryRun',
+            message: 'Dry run? (show what would happen without making changes)',
+            initial: false,
+            active: 'yes',
+            inactive: 'no'
+        },
+        {
+            type: 'select',
+            name: 'type',
+            message: 'Sync Type?',
+            choices: [
+                { title: 'UPDATE', value: 'UPDATE' },
+                { title: 'OVERWRITE', value: 'OVERWRITE' }
+            ]
+        }
+    ], {
+        onCancel: () => {
+            console.log();
+            console.log(chalk.red("Cancelled Operation!"));
+            console.log();
+            success = false;
+        }
+    });
+
+
+
+    if (success) {
+        let sourcePaths, destPaths;
+
+        switch (responses.direction) {
+            case 'import':
+                sourcePaths = [path.join(config.configIndividualPathEclipse, responses.configNameSource)];
+                destPaths = [path.join(config.configIndividualPath, responses.configNameTarget)];
+                break;
+
+            case 'export':
+                sourcePaths = [path.join(config.configIndividualPath, responses.configNameSource)];
+                destPaths = [path.join(config.configIndividualPathEclipse, responses.configNameTarget)];
+                break;
+
+            case 'import_all':
+                sourcePaths = [path.resolve(config.configIndividualPathEclipse, '..', "config"), config.configIndividualPathEclipse];
+                destPaths = [path.resolve(config.configIndividualPath, '..', "config"), config.configIndividualPath];
+                break;
+
+            case 'export_all':
+                sourcePaths = [path.resolve(config.configIndividualPath, '..', "config"), config.configIndividualPath];
+                destPaths = [path.resolve(config.configIndividualPathEclipse, '..', "config"), config.configIndividualPathEclipse];
+                break;
+
+            case 'import_all_individuals':
+                sourcePaths = [path.resolve(config.configIndividualPathEclipse)];
+                destPaths = [path.resolve(config.configIndividualPath)];
+                break;
+
+            case 'export_all_individuals':
+                destPaths = [path.resolve(config.configIndividualPathEclipse)];
+                sourcePaths = [path.resolve(config.configIndividualPath)];
+                break;
+
+            case 'import_config': {
+                const sourceParent = path.resolve(config.configIndividualPathEclipse, '..');
+                const destParent = path.resolve(config.configIndividualPath, '..');
+
+                sourcePaths = [findConfigDirNamedConfigIn(sourceParent)];
+                destPaths = [findConfigDirNamedConfigIn(destParent)];
+                break;
+            }
+
+            case 'export_config': {
+                const sourceParent = path.resolve(config.configIndividualPath, '..');
+                const destParent = path.resolve(config.configIndividualPathEclipse, '..');
+
+                sourcePaths = [findConfigDirNamedConfigIn(sourceParent)];
+                destPaths = [findConfigDirNamedConfigIn(destParent)];
+                break;
+            }
+        }
+
+        processMultiple(responses, responses.dryRun, sourcePaths, destPaths);
+
+        if (responses.dryRun) {
+            console.log()
+            const confirmationResults = await prompts([
+                {
+                    type: 'confirm',
+                    name: 'confirmation',
+                    message: 'Would you like to execute the dry-run?',
+                    initial: true
+                }
+            ], {
+                onCancel: () => {
+                    console.log();
+                    console.log(chalk.red("Cancelled Operation!"));
+                    console.log();
+                    success = false;
+                }
+            })
+
+            if(confirmationResults.confirmation){
+                processMultiple(responses, false, sourcePaths, destPaths);
+            }
+        }
+        console.log();
+    }
+}
+
+
+function processMultiple(responses, dryRun, sourcePaths, destPaths) {
+    console.log();
+    let summary = {};
+
+    switch (responses.type) {
+        case 'UPDATE':
+            console.log(chalk.yellow(`Updating files from ${sourcePaths.join(', ')} → ${destPaths.join(', ')}`));
+            summary = { added: 0, updated: 0 };
+            for(let i = 0; i < sourcePaths.length && i < destPaths.length; i++) {
+                FS.copyUpdatedFiles(sourcePaths[i], destPaths[i], dryRun, summary, ["wegas.properties", "path.yaml"]);
+            }
+            console.log();
+            console.log(chalk.green(`Summary: ${summary.updated} files added or updated.`));
+            break;
+
+        case 'OVERWRITE':
+            console.log(chalk.red(`Overwriting files from ${sourcePaths.join(', ')} → ${destPaths.join(', ')}`));
+
+            summary = { copied: 0 };
+            let deletedCount = 0;
+            for(let i = 0; i < sourcePaths.length && i < destPaths.length; i++) {
+                if (existsSync(destPaths[i])) {
+                    deletedCount += countAndDeleteDir(destPaths[i], dryRun);
+                    if (!dryRun) {
+                        console.log(chalk.gray(`Deleted existing folder: ${destPaths[i]}`));
+                    }
+                }
+
+                if (!dryRun) {
+                    mkdirSync(destPaths[i], { recursive: true });
+                } else {
+                    console.log(chalk.gray(`[DryRun] Would create directory: ${destPaths[i]}`));
+                }
+
+                FS.copyAllFiles(sourcePaths[i], destPaths[i], dryRun, summary, ["wegas.properties", "path.yaml"]);
+            }
+
+            console.log();
+            console.log(chalk.green(`Summary: Deleted ${deletedCount} items, Copied ${summary.copied} files.`));
+            break;
+    }
+
+    console.log();
+    if (dryRun) {
+        console.log(chalk.yellow("Dry run complete — no changes were made."));
+    } else {
+        console.log(chalk.green("Config sync completed successfully."));
+    }
+}
+
+function countAndDeleteDir(dirPath, dryRun = false) {
+    let deletedCount = 0;
+
+    if (existsSync(dirPath)) {
+        if (dryRun) {
+            console.log(chalk.red(`[DryRun] Would delete directory: ${dirPath}`));
+            // For dry run, recursively count files/directories without deleting
+            const entries = readdirSync(dirPath, { withFileTypes: true });
+            for (const entry of entries) {
+                const entryPath = path.join(dirPath, entry.name);
+                if (entry.isDirectory()) {
+                    deletedCount += countAndDeleteDir(entryPath, dryRun);
+                } else {
+                    deletedCount++;
+                    console.log(chalk.red(`[DryRun] Would delete file: ${entryPath}`));
+                }
+            }
+            deletedCount++; // counting the directory itself
+        } else {
+            rmSync(dirPath, { recursive: true, force: true });
+            // Can't count after delete, so you may skip or count before if desired
+        }
+    }
+    return deletedCount;
+}
+
+function findConfigDirNamedConfigIn(parentPath) {
+    if (!parentPath || typeof parentPath !== 'string') {
+        throw new Error('Invalid or undefined parent path');
+    }
+
+    const candidate = path.join(parentPath, 'config');
+    if (existsSync(candidate)) {
+        return candidate;
+    }
+
+    throw new Error(`No 'config/' directory found directly in ${parentPath}`);
+}
+
+
+

package/src/modules/t003Rewrite.js

@@ -0,0 +1,64 @@
+import chalk from "chalk";
+import prompts from "prompts";
+import { Config } from "../utils/config/config.js";
+import { DB } from "../utils/db/DB.js";
+
+export default async function t003Rewrite(cli) {
+    console.log()
+
+    const config = await Config.getConfig();
+
+    const databaseNames = await DB.getDatabaseNames();
+
+    let success = true;
+
+    const responseDB = await prompts([{
+        // DB-Auswahl von DB
+        type: 'autocomplete',
+        name: 'dbName',
+        message: 'DB-Name?',
+        choices: databaseNames.map(name => { return { title: name.name } })
+    }, {
+        type: 'number',
+        name: 'mnr',
+        message: 'Mandant?',
+        initial: '1'
+    }], {
+        onCancel: () => {
+            console.log()
+            console.log(chalk.red("Cancelled Rewrite!"))
+            console.log()
+            success = false
+        }
+    });
+
+    if (success) {
+
+        const users = await DB.executeQueryOnDB("SELECT t003_pw FROM t003 WHERE t003_mnr = " + responseDB.mnr, responseDB.dbName);
+
+
+        const responses = await prompts([{
+            // Ordnerauswahl von vorhandenen Ordner in configIndividual
+            type: 'autocomplete',
+            name: 'username',
+            message: 'Username?',
+            choices: users.map(entry => { return ({ title: entry.t003_pw }) })
+        }], {
+            onCancel: () => {
+                console.log()
+                console.log(chalk.red("Cancelled Rewrite!"))
+                console.log()
+                success = false
+            }
+        })
+
+        if (success) {
+            console.log()
+
+            await DB.executeQueryOnDB("UPDATE t003 SET t003_pw = '"+config.wegasUsername+"' WHERE t003_mnr = "+responseDB.mnr+" AND t003_pw = '"+responses.username+"'", responseDB.dbName);
+
+            console.log(chalk.green("T003 rewritten!"))
+            console.log()
+        }
+    }
+}

package/src/ressources/cmds.json

@@ -0,0 +1,47 @@
+{
+    "dump_db": {
+        "desc": "Dumps a DB-Export from local MYSQL-Instance (optionally with table selection or data only)."
+    },
+    "import_db": {
+        "desc": "Imports a DB-Export (in Archive) to the local MYSQL-Instance"
+    },
+    "config_rewrite": {
+        "desc": "Rewrites WEGAS-Config"
+    },
+    "sync_config": {
+        "desc": "Synchronize Config/ConfigIndividual-Folders between Work and Repository (Eclipse-Repo)"
+    },
+    "t003_rewrite": {
+        "desc": "Rewrites t003 in DB"
+    },
+    "bundle_product":{
+        "desc": "Bundles the jWEGAS-Product after an Eclipse-Export"
+    },
+    "dump_db_mand": {
+        "desc": "Export a DB-Dump for a single Mandant"
+    },
+    "delete_db_mand": {
+        "desc": "Delete all Mandant-Data from a db"
+    },
+    "extd_search": {
+        "desc": "Search EXTD/EXTI interactively with full text search"
+    },
+    "set_cli_config": {
+        "desc": "Configure the Inteco CLI"
+    },
+    "dump_table_to_csv": {
+        "desc": "Dumps a specific table from multiple SQL-Exports to a CSV"
+    },
+    "csv_merge": {
+        "desc": "Merge multiple CSV-Files (with same headers) into single file (with optional filter)"
+    },
+    "adb_bridge": {
+        "desc": "Activates an ADB-Bridge-Connection to an Android-Device"
+    },
+    "adb_intent": {
+        "desc": "Sends a configurable Intent to an Android-Device"
+    },
+    "graphql_schema_export": {
+        "desc": "Dump the Graph-QL-Schema from an Endpoint"
+    }
+}

package/src/utils/config/config.js

@@ -0,0 +1,70 @@
+import cfg from "application-config"
+import defaultCFG from './default.json' with {type: 'json'};
+
+export class Config{
+    static config = cfg("inteco_cli");
+    static configData;
+
+    static async initConfig(){
+        if(this.configData == null){
+            this.configData = await this.config.read();
+        }
+
+        if(Object.keys(this.configData).length === 0){
+            // Default Configuration
+            this.configData = defaultCFG
+            this.config.write(defaultCFG)
+        }else{
+            let data = this.configData;
+            let hasChange = false;
+            Object.keys(defaultCFG).forEach(key => {
+                // Write new config-entries if not present
+                if(!Object.keys(this.configData).includes(key)){
+                    data[key] = defaultCFG[key];
+                    hasChange = true;
+                }
+            })
+
+            Object.keys(this.configData).forEach(key => {
+                if(!Object.keys(defaultCFG).includes(key)){
+                    delete data[key]
+                    hasChange = true;
+                }
+            })
+
+            if(hasChange){
+                this.configData = data;
+                this.config.write(data);
+            }
+        }
+    }
+
+    static async getConfig(){
+        await this.initConfig()
+
+        return this.configData
+    }
+
+    static async getConfigPath(){
+        await this.initConfig();
+        return this.config.filePath;
+    }
+
+    static async setConfigField(field, value){
+        await this.initConfig();
+
+        let data = this.configData;
+
+        data[field] = value;
+
+        this.configData = data;
+        this.config.write(data);
+    }
+
+    static async setConfig(data){
+        this.configData = data;
+        this.config.write(data);
+    }
+
+
+}

package/src/utils/config/default.json

@@ -0,0 +1,9 @@
+{
+    "configIndividualPath": "C:/Daten/eclipse_mars64_1/eclipse/configIndividual",
+    "configIndividualPathWrite": "C:\\\\Daten\\\\eclipse_mars64_1\\\\eclipse\\\\configIndividual",
+    "configIndividualPathEclipse": "C:/Daten/wegas-ws-mars/ch.inteco.wegas.model/configIndividual",
+    "dbURL": "127.0.0.1",
+    "dbUser": "",
+    "dbPassword": "",
+    "wegasUsername": ""
+}