@intecoag/inteco-cli 0.5.1

package/README.md

@@ -0,0 +1,3 @@
+CLI mit diversen Funktionen für die Arbeit in der Inteco und mit dem WEGAS 
+
+Weitere Informationen: https://inteco.atlassian.net/wiki/x/BYBuAw

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@intecoag/inteco-cli",
+  "version": "0.5.1",
+  "description": "CLI-Tools for Inteco",
+  "main": "src/index.js",
+  "type": "module",
+  "scripts": {
+    "start": "node src/index.js"
+  },
+  "author": "ah1",
+  "license": "ISC",
+  "dependencies": {
+    "7zip-bin": "^5.2.0",
+    "adb-ts": "^2.1.2",
+    "application-config": "^2.0.0",
+    "chalk": "^5.0.1",
+    "cli-meow-help": "^3.1.0",
+    "cli-table3": "^0.6.5",
+    "csv-parser": "^3.0.0",
+    "fuzzysort": "^3.1.0",
+    "graphql": "^16.6.0",
+    "meow": "^10.1.5",
+    "mysql-await": "^2.1.8",
+    "n-readlines": "^1.0.1",
+    "node-7z": "^3.0.0",
+    "ora": "^6.1.0",
+    "prompts": "^2.4.2",
+    "properties-parser": "^0.3.1",
+    "readline": "^1.3.0",
+    "yaml": "^1.10.2"
+  },
+  "bin": {
+    "inteco": "src/index.js"
+  }
+}

package/src/index.js

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+import cliMeowHelp from 'cli-meow-help';
+import meow from 'meow';
+import adb_bridge from './modules/adbBridge.js';
+import adb_intent from './modules/adbIntentSender.js';
+import dumpTableToCSV from './modules/dumpTableToCSV.js';
+import importDB from './modules/importDB.js';
+import rewrite from './modules/rewriteConfig.js';
+import writeCLIConfig from './modules/setCLIConfig.js';
+import t003Rewrite from './modules/t003Rewrite.js';
+import graphqlSchemaExport from './modules/graphqlSchemaExport.js';
+import csvMerge from './modules/csvMerger.js';
+import {dumpDBMand, dumpDB } from './modules/dumpDB.js';
+import deleteDBMand from './modules/deleteDB.js';
+
+import commands from "./ressources/cmds.json" with {type: 'json'};
+import packageJson from "../package.json" with {type: 'json'}
+import extdSearch from './modules/extdSearch.js';
+import syncConfig from './modules/syncConfig.js';
+import bundleProduct from './modules/bundleProduct.js';
+
+const helpText = cliMeowHelp({
+    name: `inteco`,
+    desc: "Version: "+packageJson.version,
+    commands
+});
+
+const cli = meow(helpText, {
+    importMeta: import.meta,
+});
+
+switch (cli.input[0]) {
+    case "config_rewrite":
+        rewrite(cli)
+        break;
+    case "import_db":
+        importDB(cli)
+        break;
+    case "download_db":
+        downloadDB(cli)
+        break;
+    case "t003_rewrite":
+        t003Rewrite(cli)
+        break;
+    case "adb_bridge":
+        adb_bridge()
+        break;
+    case "adb_intent":
+        adb_intent()
+        break;
+    case "set_cli_config":
+        writeCLIConfig()
+        break;
+    case "dump_table_to_csv":
+        dumpTableToCSV()
+        break;
+    case "csv_merge":
+        csvMerge();
+        break;
+    case "graphql_schema_export":
+        graphqlSchemaExport();
+        break;
+    case "dump_db_mand":
+        dumpDBMand(cli);
+        break;
+    case "dump_db":
+        dumpDB(cli);
+        break;
+    case "delete_db_mand":
+        deleteDBMand();
+        break;
+    case "extd_search":
+        extdSearch();
+        break;
+    case "sync_config":
+        syncConfig();
+        break;
+    case "bundle_product":
+        bundleProduct(cli);
+        break;
+    default:
+        cli.showHelp()
+        break;
+}
+

package/src/modules/adbBridge.js

@@ -0,0 +1,52 @@
+import adb from "adb-ts";
+import chalk from "chalk";
+import prompts from "prompts";
+import { Config } from "../utils/config/config.js";
+
+
+export default async function adb_bridge(cli){
+
+    console.log()
+
+    const config = await Config.getConfig();
+
+    const adbClient = new adb.AdbClient({host: "127.0.0.1"})
+
+    adbClient.listDevices()
+    .then(async (devices) => {
+        let success = true;
+        const result = await prompts([
+            {
+                // Ordnerauswahl von vorhandenen Ordner in configIndividual
+                type: 'autocomplete',
+                name: 'device',
+                message: 'Device?',
+                choices: devices.map(dev => {return {title: dev.id+" ("+dev.model+")", value:dev}})
+            },
+            {
+                // Ordnerauswahl von vorhandenen Ordner in configIndividual
+                type: 'number',
+                name: 'port',
+                initial: "3000",
+                message: 'Port?'
+            }
+        ],{
+            onCancel: () => {
+                console.log()
+                console.log(chalk.red("Cancelled ADB Bridge!"))
+                console.log()
+                success = false
+            }
+        })
+
+        if(success){
+            await adbClient.reverse(result.device.id, "tcp:"+result.port, "tcp:"+result.port)
+            console.log()
+            console.log(chalk.green("ADB bridged!"))
+            console.log()
+        }
+    });
+
+    
+
+}

package/src/modules/adbIntentSender.js

@@ -0,0 +1,82 @@
+import adb from "adb-ts";
+import chalk from "chalk";
+import prompts from "prompts";
+import { Config } from "../utils/config/config.js";
+
+
+export default async function adb_intent(cli){
+
+    console.log()
+
+    const config = await Config.getConfig();
+
+    
+
+    const adbClient = new adb.AdbClient({host: "127.0.0.1"})
+
+    adbClient.listDevices()
+    .then(async (devices) => {
+        let success = true;
+        const result = await prompts([
+            {
+                // Ordnerauswahl von vorhandenen Ordner in configIndividual
+                type: 'autocomplete',
+                name: 'device',
+                message: 'Device?',
+                choices: devices.map(dev => {return {title: dev.id+" ("+dev.model+")", value:dev}})
+            },
+            {
+                // Ordnerauswahl von vorhandenen Ordner in configIndividual
+                type: 'autocomplete',
+                name: 'action',
+                message: 'Action?',
+                choices: [
+                    {
+                        "title":"BARCODE_DATA",
+                        "value": "ch.inteco.orderprep.action.BARCODE_DATA"
+                    },
+                ]
+            },
+            {
+                // Ordnerauswahl von vorhandenen Ordner in configIndividual
+                type: 'text',
+                name: 'data',
+                message: 'Data?',
+                initial:"1"
+            },
+            {
+                // Ordnerauswahl von vorhandenen Ordner in configIndividual
+                type: 'autocomplete',
+                name: 'codeId',
+                message: 'Code-Typ?',
+                choices: [
+                    {
+                        "title":"QR-Code",
+                        "value": "s"
+                    },
+                    {
+                        "title":"EAN13",
+                        "value": "d"
+                    }
+                ]
+            }
+        ],{
+            onCancel: () => {
+                console.log()
+                console.log(chalk.red("Cancelled ADB Intent!"))
+                console.log()
+                success = false
+            }
+        })
+
+        if(success){
+            await adbClient.shell(result.device.id, "am broadcast -a "+result.action+" --ei version 1 --es codeId "+result.codeId+" --es data "+result.data)
+            console.log()
+            console.log(chalk.green("Intent sent!"))
+            console.log()
+        }
+    });
+
+    
+
+}

package/src/modules/bundleProduct.js

@@ -0,0 +1,161 @@
+import { existsSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "fs";
+import Seven from 'node-7z'
+import sevenBin from '7zip-bin'
+import { Config } from "../utils/config/config.js";
+import prompts from "prompts";
+import chalk from "chalk";
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+import path from "path";
+import ora from "ora";
+import { cp } from "fs/promises";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+export default async function bundleProduct(cli) {
+    console.log()
+
+    const config = await Config.getConfig();
+
+    let success = true;
+
+    const folders = readdirSync(process.cwd(), { withFileTypes: true }).filter(dirent => !dirent.isFile()).map(dirent => { return { title: dirent.name } })
+
+    const configDirectories = readdirSync(config.configIndividualPathEclipse, { withFileTypes: true }).filter(dirent => dirent.isDirectory()).map(dirent => { return { title: dirent.name } })
+
+
+    const results = await prompts([
+        {
+            // Ordnerauswahl von vorhandenen Ordner in configIndividual
+            type: 'autocomplete',
+            name: 'folder',
+            message: 'Product-Folder?',
+            choices: folders,
+            initial: "eclipse"
+        },
+        {
+            // Ordnerauswahl von vorhandenen Ordner in configIndividual
+            type: 'autocomplete',
+            name: 'configIndividual',
+            message: 'Customer-Config (from Eclipse-Repository)?',
+            choices: configDirectories
+        },
+        {
+            // Ordnerauswahl von vorhandenen Ordner in configIndividual
+            type: 'text',
+            name: 'ram',
+            message: 'Xmx-Value (Max. RAM) in GB?',
+            initial: "8",
+            validate: input => {
+                if (isNaN(input)) {
+                    return "Enter a Number"
+                }
+                return true;
+            }
+        },
+        {
+            // Ordnerauswahl von vorhandenen Ordner in configIndividual
+            type: 'text',
+            name: 'folderName',
+            message: 'Product-Name?',
+            initial: "eclipse"
+        },
+    ], {
+        onCancel: () => {
+            console.log()
+            console.log(chalk.red("Cancelled Import!"))
+            console.log()
+            success = false
+        }
+    })
+
+    if (success) {
+        console.log()
+
+        const spinnerRemoveOld = ora("Removing old configs")
+        const configPath = path.resolve(".", results.folder, "config");
+        const configIndividualPath = path.resolve(".", results.folder, "configIndividual");
+
+        if (existsSync(configPath)) {
+            rmSync(configPath, { recursive: true, force: true });
+        }
+
+        if (existsSync(configIndividualPath)) {
+            rmSync(configIndividualPath, { recursive: true, force: true });
+        }
+
+        spinnerRemoveOld.succeed("Removed old configs")
+
+        const spinnerConfig = ora('Copying config').start();
+
+
+        const sourceConfig = path.resolve(config.configIndividualPathEclipse, '..', "config");
+        const destConfig = path.resolve(".", results.folder, "config")
+
+        await cp(sourceConfig, destConfig, { recursive: true })
+
+        spinnerConfig.succeed("Config copied")
+
+        const spinnerConfigIndividual = ora('Copying configIndividual: ' + results.configIndividual).start();
+
+
+        const sourceConfigIndividual = path.resolve(config.configIndividualPathEclipse, results.configIndividual);
+        const destConfigIndividual = path.resolve(".", results.folder, "configIndividual", results.configIndividual)
+
+        await cp(sourceConfigIndividual, destConfigIndividual, { recursive: true })
+
+        spinnerConfigIndividual.succeed("ConfigIndividual copied: " + results.configIndividual)
+
+        const spinnerIcon = ora('Copying icon').start();
+
+        const sourceIcon = path.resolve(__dirname, "..", "ressources", "wegas_p.ico");
+        const destIcon = path.resolve(".", results.folder, "wegas_p.ico")
+
+        await cp(sourceIcon, destIcon, { recursive: true })
+
+        spinnerIcon.succeed("Icon copied")
+
+        const spinnerIniRewrite = ora('Rewriting wegas.ini: -Xmx' + results.ram + "g").start();
+
+        const iniPath = path.resolve(".", results.folder, "wegas.ini")
+
+        let iniContent = readFileSync(iniPath, 'utf-8');
+        const updatedContent = iniContent.replace(/-Xmx\d+[mgMG]?/, `-Xmx${results.ram}g`);
+        writeFileSync(iniPath, updatedContent);
+
+        spinnerIniRewrite.succeed("wegas.ini rewritten: -Xmx" + results.ram + "g")
+
+        const spinnerRename = ora("Renaming folder: " + results.folder + " -> " + results.folderName).start();
+        renameSync(path.resolve(".", results.folder), path.resolve(".", results.folderName))
+        spinnerRename.succeed("Folder renamed: " + results.folder + " -> " + results.folderName)
+
+        const spinnerZIP = ora('Zipping: ' + results.folderName + ".zip").start();
+
+        const zipPath = path.resolve(".", results.folderName + ".zip")
+        const addPath = path.resolve(".", results.folderName)
+        const add = Seven.add(zipPath, addPath, {
+            $bin: sevenBin.path7za
+        })
+
+        await getPromiseFromEvent(add, "end")
+
+        spinnerZIP.succeed('Zipped: ' + results.folderName + ".zip")
+
+        const spinnerRenameRevert = ora("Renaming folder: " + results.folderName + " -> " + results.folder).start();
+        renameSync(path.resolve(".", results.folderName), path.resolve(".", results.folder))
+        spinnerRenameRevert.succeed("Folder renamed: " + results.folderName + " -> " + results.folder)
+
+
+        console.log()
+    }
+}
+
+function getPromiseFromEvent(item, event) {
+    return new Promise((resolve) => {
+        const listener = (data) => {
+            resolve(data);
+        }
+        item.on(event, listener);
+    })
+}

package/src/modules/csvMerger.js

@@ -0,0 +1,118 @@
+import chalk from 'chalk';
+import csv from 'csv-parser';
+import fs from "fs";
+import prompts from "prompts";
+
+export default async function csvMerge() {
+    console.log()
+
+    let success = true;
+
+    const promptResults = await prompts([
+        {
+            // Output-File
+            type: 'text',
+            name: 'output',
+            message: 'Output-File?',
+            initial: "results.csv"
+        },
+        {
+            // Filterverwendung
+            type: 'toggle',
+            name: 'useFilter',
+            message: 'Use Filter?',
+            initial: false,
+            active: 'yes',
+            inactive: 'no'
+        },
+        {
+            type: prev => prev == true ? "select" : null,
+            name: 'filtertype',
+            message: 'Filter type?',
+            choices: [
+                { title: 'Equal', value: 'eq' },
+                { title: 'Non-Equal', value: 'neq' }
+            ]
+        },
+        {
+            type: prev => prev != "" ? "text" : null,
+            name: 'filterfield',
+            message: 'Filter field?'
+        },
+        {
+            type: prev => prev != "" ? "text" : null,
+            name: 'filtervalue',
+            message: 'Filter value?'
+        },
+    ], {
+        onCancel: () => {
+            console.log()
+            console.log(chalk.red("Cancelled CSV-Merge!"))
+            console.log()
+            success = false
+        }
+    })
+
+
+    if (success) {
+        console.log()
+
+        let files = fs.readdirSync(process.cwd(), { withFileTypes: true }).filter(file => file.isFile && file.name.endsWith(".csv") && file.name != promptResults.output);
+
+        let finalResult = [];
+        let counter = 0;
+
+        files.forEach(file => {
+            const results = [];
+
+            fs.createReadStream(process.cwd() + "/" + file.name)
+                .pipe(csv({ separator: ";", quote: "'" }))
+                .on('data', (data) => results.push(data))
+                .on('end', () => {
+                    const filteredResults = results.map(row => {
+                        const newRow = {}
+                        Object.entries(row).forEach(entry => {
+                            newRow[entry[0].replaceAll("'", "").replaceAll("`", "")] = entry[1]
+                        })
+                        newRow.file = file.name
+                        return newRow
+                    }).filter(row => {
+                        if (promptResults.useFilter) {
+                            switch (promptResults.filtertype){
+                                case "neq":
+                                    if(row[promptResults.filterfield] != promptResults.filtervalue){
+                                        return true
+                                    }
+                                    return false;
+                                case "eq":
+                                    if(row[promptResults.filterfield] == promptResults.filtervalue){
+                                        return true
+                                    }
+                                    return false;    
+                            }
+                            return false;
+                        }
+                        return true;
+                    })
+
+                    finalResult = finalResult.concat(filteredResults)
+                    counter = counter + filteredResults.length
+
+                    let firstLine = true;
+                    fs.writeFileSync(process.cwd() + "/" + promptResults.output, finalResult.map(row => {
+                        let prev = ""
+                        if (firstLine) {
+                            prev = Object.keys(row).map(entry => { return "\"" + entry + "\"" }).join(";") + "\n";
+                            firstLine = false;
+                        }
+                        return prev + Object.values(row).map(entry => { return "\"" + entry + "\"" }).join(";");
+                    }).join("\n"))
+                    console.log(chalk.green(file.name + " merged."))
+                });
+
+        })
+    }
+
+
+
+}

package/src/modules/deleteDB.js

@@ -0,0 +1,84 @@
+import prompts from "prompts"
+import { rmSync } from "fs";
+import ora from "ora";
+import { DB } from "../utils/db/DB.js";
+import chalk from "chalk";
+import path from "path";
+
+
+export default async function deleteDBMand(cli){
+    console.log()
+
+    const databaseNames = await DB.getDatabaseNames();
+
+    let success = true;
+
+    const results = 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 Import!"))
+            console.log()
+            success = false
+        }
+    })
+
+    if(success){
+        console.log()
+
+        const spinner = ora('Deleting in DB').start();
+
+        // Load table names
+        let tables = await DB.executeQueryOnDB("SHOW TABLES;", results.dbName);
+        const tableKey = Object.keys(tables[0])[0];
+        tables = tables.map(row => row[tableKey])
+
+        if(tables == null || tables.length == 0){
+            spinner.fail("Database has no tables: "+results.dbName)
+        }else{
+            // Remove previous dump
+            rmSync("."+path.sep+results.dumpName, {recursive:true, force:true})
+            for(const table of tables){
+                // Check if Mand-Column exists
+                const tableSpinner = ora("Deleting data: "+table).start();
+                const tableCol = table+"_mnr"
+                const columnExists = await DB.executeQueryOnDB("SELECT COUNT(*) FROM INFORMATION_SCHEMA.COLUMNS WHERE table_schema = '"+results.dbName+"' AND table_name = '"+table+"' AND column_name = '"+tableCol+"';")
+
+                if(columnExists [0]['COUNT(*)'] != 0){
+                    // Check if Mand-Data is present
+                    const dataExists = await DB.executeQueryOnDB("SELECT COUNT(*) FROM "+table+" WHERE "+tableCol+" = '"+results.mnr+"';", results.dbName);
+
+                    if(dataExists[0]['COUNT(*)'] != 0){
+                        await DB.executeQueryOnDB("DELETE FROM "+table+" WHERE "+tableCol+" = '"+results.mnr+"';", results.dbName)
+                        tableSpinner.succeed("Data deleted: "+table);
+                    }else{
+                        tableSpinner.info("No data present, Skipping table: "+table)
+                    }
+                }else{
+                    tableSpinner.info("Column "+tableCol+" not found, Skipping table: "+table)
+                }
+            }
+            // Dump mand-table (special field name)
+            const tableSpinner = ora("Deleting mand (custom logic)")
+            await DB.executeQueryOnDB("DELETE FROM mand WHERE mand_mandant = '"+results.mnr+"';", results.dbName)
+            tableSpinner.succeed("Data deleted: mand")
+            spinner.succeed("Mand deleted: "+results.mnr);
+        }
+
+        
+        console.log();
+    }
+}