@cyklang/cli 0.2.2 → 0.3.0

package/build/AssetCommand.js

@@ -30,7 +30,8 @@ const DBClient_1 = require("./DBClient");
 const fs = __importStar(require("fs"));
 const path_1 = __importDefault(require("path"));
 const mime_types_1 = __importDefault(require("mime-types"));
-const readline_1 = __importDefault(require("readline"));
+const inquirer_1 = __importDefault(require("inquirer"));
+// import readline from 'readline'
 const core_1 = require("@cyklang/core");
 const form_data_1 = __importDefault(require("form-data"));
 const logger = (0, loglevel_1.getLogger)('AssetCommand.ts');
@@ -59,7 +60,7 @@ class AssetList extends Cmd_1.Cmd {
             if (this.dbManager === undefined)
                 throw 'dbManager undefined';
             const dbClient = new DBClient_1.DBClient(this.dbManager);
-            dbClient.selectFromTable('List of Assets', 'cyk_asset', { fields: 'asset_id,asset_route,asset_last_update,asset_mimetype', sort: options.sort || '1' });
+            dbClient.selectFromTable('List of Assets', 'cyk_asset', { fields: 'asset_id,asset_route,asset_auth,asset_access,asset_mimetype,asset_last_update', sort: options.sort || '1' });
         }
         catch (err) {
             logger.error(err);
@@ -74,12 +75,24 @@ class AssetUpload extends Cmd_1.Cmd {
         //----------------------------------------------------------------------------------------------
         this.ignorePatterns = ['.git', 'node_modules'];
         this.description(description)
-            .option('-d --dest <destination>', 'route of destination')
+            .option('-d --dest <destination>', 'destination path, directory name')
+            .option('-c --clean', 'clean destination path before uploading')
+            .option('-y --yes', 'upload list is automatically confirmed')
             .argument('[sources...]', 'local files or directories to upload as assets to the server')
             .action(async (sources, options) => {
             await this.commandUpload(sources, options);
         });
     }
+    mimetypeLookup(filename) {
+        let result;
+        if (path_1.default.extname(filename) === '.cyk') {
+            result = 'application/xml';
+        }
+        else {
+            result = mime_types_1.default.lookup(filename);
+        }
+        return result;
+    }
     async commandUpload(sources, options) {
         try {
             await this.prologue(options);
@@ -94,13 +107,16 @@ class AssetUpload extends Cmd_1.Cmd {
                 dest = '/' + dest;
             if (dest.substring(dest.length - 1) !== '/')
                 dest = dest + '/';
+            if (options.clean) {
+                await this.cleanDestination(dest);
+            }
             for (let ind = 0; ind < sources.length; ind++) {
                 const source = sources[ind];
                 if (fs.existsSync(source) === false)
                     throw 'source ' + source + ' does not exist';
                 const filestat = fs.lstatSync(source);
                 if (filestat.isDirectory() === true) {
-                    await this.uploadDirectory(source, dest);
+                    await this.uploadDirectory(source, dest, options);
                 }
                 else if (filestat.isFile() === true) {
                     const base = path_1.default.parse(source).base;
@@ -114,9 +130,22 @@ class AssetUpload extends Cmd_1.Cmd {
         }
     }
     //----------------------------------------------------------------------------------------------
+    // cleanDestination
+    //----------------------------------------------------------------------------------------------
+    async cleanDestination(dest) {
+        const remoteList = await this.scanAssets();
+        for (let ind = 0; ind < remoteList.length; ind++) {
+            const fd = remoteList[ind];
+            if (fd.path.startsWith(dest)) {
+                const url = '/api/admin/assets/' + fd.id;
+                await this.dbRemote?.apiServer.delete(url);
+            }
+        }
+    }
+    //----------------------------------------------------------------------------------------------
     // uploadDirectory
     //----------------------------------------------------------------------------------------------
-    async uploadDirectory(source, dest) {
+    async uploadDirectory(source, dest, options) {
         const localList = [];
         let dirName;
         if (source.substring(source.length - 1) === '/') {
@@ -126,23 +155,31 @@ class AssetUpload extends Cmd_1.Cmd {
         else {
             dirName = source + '/';
         }
-        logger.debug('dirName', dirName);
+        logger.debug('options', options);
         this.scanDir(dirName, localList);
-        const remoteList = [];
-        await this.scanAssets(remoteList);
+        const remoteList = await this.scanAssets();
         const uploadList = this.buildUploadList(dirName, dest, localList, remoteList);
         // logger.info(fileNames.join('\n'))
         if (uploadList.length === 0)
             throw 'None file to upload';
-        const rl = readline_1.default.createInterface(process.stdin, process.stdout);
-        rl.question('Do you want to upload this(these) ' + uploadList.length + ' file(s) (Y/N/y/n) ?', async (reply) => {
-            rl.close();
-            if (reply !== 'Y' && reply !== 'y') {
-                logger.info('upload cancelled');
-                return;
-            }
+        let uploadConfirmed = (options.yes !== undefined);
+        if (uploadConfirmed === false) {
+            const reply = await inquirer_1.default.prompt({ type: 'confirm', name: 'confirm', message: 'Do you want to upload this(these) ' + uploadList.length + ' file(s) ?' });
+            if (reply.confirm === true)
+                uploadConfirmed = true;
+        }
+        if (uploadConfirmed === true) {
             await this.uploadFiles(dirName, uploadList, dest);
-        });
+        }
+        // const rl = readline.createInterface(process.stdin, process.stdout)
+        // rl.question('Do you want to upload this(these) ' + uploadList.length + ' file(s) (Y/N/y/n) ?', async (reply) => {
+        //     rl.close()
+        //     if (reply !== 'Y' && reply !== 'y') {
+        //         logger.info('upload cancelled')
+        //         return
+        //     }
+        //     await this.uploadFiles(dirName, uploadList, dest)
+        // })
     }
     //----------------------------------------------------------------------------------------------
     // buildUploadList
@@ -172,7 +209,8 @@ class AssetUpload extends Cmd_1.Cmd {
     //----------------------------------------------------------------------------------------------
     // scanAssets
     //----------------------------------------------------------------------------------------------
-    async scanAssets(result) {
+    async scanAssets() {
+        const result = [];
         if (this.dbManager === undefined)
             throw 'dbManager undefined';
         const dbReq = new core_1.DBExecuteRequest();
@@ -188,11 +226,13 @@ class AssetUpload extends Cmd_1.Cmd {
         for (let ind = 0; ind < rows.list.length; ind++) {
             const { variable: row } = rows.list[ind];
             const record = row.data;
+            const asset_id = record.variables.getData('asset_id').value;
             const asset_route = record.variables.getData('asset_route').value;
-            const asset_last_update = record.variables.getData('asset_last_update').value;
+            const asset_last_update = record.variables.getData('asset_last_update')?.value;
             // logger.debug('asset_route ' + asset_route,'asset_last_update ' + asset_last_update)
-            result.push({ path: asset_route, mtime: asset_last_update });
+            result.push({ path: asset_route, mtime: asset_last_update, id: asset_id });
         }
+        return result;
     }
     //----------------------------------------------------------------------------------------------
     // scanDir
@@ -208,7 +248,7 @@ class AssetUpload extends Cmd_1.Cmd {
                 this.scanDir(dirName + fileName + '/', result);
             }
             else {
-                if (mime_types_1.default.lookup(fileName) === false) {
+                if (this.mimetypeLookup(fileName) === false) {
                     logger.info(fileName + ' file extension is unknown and will not be uploaded');
                     continue;
                 }
@@ -241,13 +281,13 @@ class AssetUpload extends Cmd_1.Cmd {
     // uploadAsset
     //----------------------------------------------------------------------------------------------
     async uploadAsset(upload, route) {
-        logger.debug('uploadAsset ' + upload.path + ' to route ' + route + ' with mimetype ' + mime_types_1.default.lookup(upload.path));
+        logger.debug('uploadAsset ' + upload.path + ' to route ' + route + ' with mimetype ' + this.mimetypeLookup(upload.path));
         try {
             let dbAsset = await this.dbManager?.dbAssetExist(route);
             if (dbAsset === undefined) {
                 dbAsset = new core_1.DBAsset();
             }
-            const mimetype = mime_types_1.default.lookup(upload.path);
+            const mimetype = this.mimetypeLookup(upload.path);
             if (mimetype === false)
                 throw 'mimetype false for ' + upload;
             dbAsset.mimetype = mimetype;
@@ -280,7 +320,7 @@ class AssetUpload extends Cmd_1.Cmd {
             const file = fs.createReadStream(fileName);
             const form = new form_data_1.default();
             form.append('uploadFile', file);
-            const route = '/upload/cyk_asset/asset_content?asset_id=' + dbAsset.id;
+            const route = '/api/upload/cyk_asset/asset_content?asset_id=' + dbAsset.id;
             const resp = await this.dbRemote?.apiServer.post(route, form);
             if (resp.status === 200) {
                 logger.info(fileName + ' uploaded');

package/build/Cmd.d.ts

@@ -1,8 +1,8 @@
-import { DBManager, DBRemote } from "@cyklang/core";
+import { DBManager, DBRemote, SigninResponse } from "@cyklang/core";
 import { Command } from "commander";
 export declare class Cmd extends Command {
     dbManager: DBManager | undefined;
     dbRemote: DBRemote | undefined;
     constructor(name: string);
-    prologue(options: any): Promise<void>;
+    prologue(options: any): Promise<SigninResponse>;
 }

package/build/Cmd.js

@@ -23,13 +23,14 @@ class Cmd extends commander_1.Command {
         const structure = new core_1.Structure();
         if (process.env.DBREMOTE_URL === undefined)
             throw 'DBREMOTE_URL undefined';
-        logger.debug('DBREMOTE_URL ' + process.env.DBREMOTE_URL);
+        logger.debug('Cmd.DBREMOTE_URL ' + process.env.DBREMOTE_URL);
         const nodeCrypto = new NodeCrypto_1.NodeCrypto();
         this.dbRemote = new core_1.DBRemote(structure.scope, process.env.DBREMOTE_URL, nodeCrypto);
         const login = await this.dbRemote.signin(process.env.USER_NAME, undefined, process.env.USER_PASSWORD);
         // logger.debug(login)
         this.dbManager = new core_1.DBManager(structure.scope, this.dbRemote);
         await this.dbManager.initialize();
+        return login;
     }
 }
 exports.Cmd = Cmd;

package/build/DBClient.d.ts

@@ -2,10 +2,12 @@ import { DBManager } from "@cyklang/core";
 export declare class DBClient {
     dbManager: DBManager;
     constructor(dbManager: DBManager);
+    runQuery(): Promise<void>;
     selectFromTable(title: string, tableName: string, options: {
         fields: string;
         sort?: string | undefined;
         where?: string | undefined;
         width?: string | undefined;
     }): Promise<void>;
+    deleteModule(dbname: string): Promise<void>;
 }

package/build/DBClient.js

@@ -13,6 +13,8 @@ class DBClient {
     constructor(dbManager) {
         this.dbManager = dbManager;
     }
+    async runQuery() {
+    }
     async selectFromTable(title, tableName, options) {
         try {
             const objectDataType = this.dbManager.scope.structure.objectDataType;
@@ -76,6 +78,18 @@ class DBClient {
             logger.error(err);
         }
     }
+    async deleteModule(dbname) {
+        try {
+            const dbModule = await this.dbManager.dbModuleExist(dbname);
+            if (dbModule === undefined) {
+                throw ('Module ' + dbname + ' not found');
+            }
+            await this.dbManager.dbModuleDelete(dbModule);
+        }
+        catch (err) {
+            logger.error(err);
+        }
+    }
 }
 exports.DBClient = DBClient;
 class List {
@@ -203,6 +217,8 @@ class List {
         else {
             result = value.toString();
         }
+        // replace \n with a space
+        result = result.replace(/\n/, ' ');
         if (width !== undefined && width !== 0) {
             if (result.length >= width) {
                 result = result.substring(0, width);

package/build/ModuleCommand.js

@@ -48,7 +48,9 @@ Otherwise, a new module is inserted in the database. To rename a module, use opt
         // list
         this.addCommand(new ModuleList('list', 'List modules'));
         this.addCommand(new ModuleList('l', 'shortcut for (l)ist'));
-        // rename
+        // rename **TODO**
+        // delete
+        this.addCommand(new ModuleDelete('delete', 'delete module from database'));
     }
 }
 exports.ModuleCommand = ModuleCommand;
@@ -57,7 +59,7 @@ function getModuleDBName(filePath) {
     // if (filePath.endsWith('.xml') === false) throw filePath + ' does not have .xml extension'
     // result = path.basename(filePath, '.xml')
     const result = path_1.default.parse(filePath).name;
-    const identifierRegex = /^[_a-zA-Z][_a-zA-Z0-9]*$/;
+    const identifierRegex = /^[_a-zA-Z][-_a-zA-Z0-9]*$/;
     if (result.match(identifierRegex) === null)
         throw 'filename ' + result + ' does not match identifier syntax';
     return result;
@@ -194,7 +196,7 @@ class ModuleList extends Cmd_1.Cmd {
             if (this.dbManager === undefined)
                 throw 'dbManager undefined';
             const dbClient = new DBClient_1.DBClient(this.dbManager);
-            dbClient.selectFromTable('List of Modules', 'cyk_module', { fields: 'module_id,module_dbname,module_access,module_description', sort: options.sort || '1' });
+            dbClient.selectFromTable('List of Modules', 'cyk_module', { fields: 'module_id,module_dbname,module_auth,module_access,module_description', sort: options.sort || '1' });
         }
         catch (err) {
             logger.error(err);
@@ -217,6 +219,12 @@ class ModuleDelete extends Cmd_1.Cmd {
                 throw 'dbManager undefined';
             if (files.length === 0)
                 throw 'no module to delete';
+            const dbClient = new DBClient_1.DBClient(this.dbManager);
+            for (let ind = 0; ind < files.length; ind++) {
+                const dbname = files.at(ind);
+                if (dbname !== undefined)
+                    dbClient.deleteModule(dbname);
+            }
         }
         catch (err) {
             logger.error(err);

package/build/QueryCommand.js

@@ -5,58 +5,68 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueryCommand = void 0;
-const core_1 = require("@cyklang/core");
 const loglevel_1 = __importDefault(require("loglevel"));
+const Cmd_1 = require("./Cmd");
 const commander_1 = require("commander");
+const DBClient_1 = require("./DBClient");
 const logger = loglevel_1.default.getLogger("QueryCommand.ts");
 logger.setLevel("debug");
 class QueryCommand extends commander_1.Command {
     constructor(name) {
         super(name);
+        this.description('query management');
+        this.addCommand(new QueryList('list', 'list queries'));
+        this.addCommand(new QueryList('l', 'list queries'));
     }
 }
 exports.QueryCommand = QueryCommand;
-function parseXmlFile(filepath, basename, xmlSource) {
-    const tag = (0, core_1.parseXML)(filepath, xmlSource);
-    if (tag.name !== 'DB.QUERY') {
-        throw Error('tag ' + tag.name + ', should be <db.query>');
-    }
-    const name = tag.attributes.NAME;
-    if (name === undefined) {
-        throw Error('name attribute is missing');
+//--------------------------------------------------------------------------------------------------------------------
+// class TableList
+//--------------------------------------------------------------------------------------------------------------------
+class QueryList extends Cmd_1.Cmd {
+    constructor(name, description) {
+        super(name);
+        this.description(description)
+            .option('-s --sort <columns>', 'sort list by column numbers (begins with 0) separated by comma')
+            .action(async (options) => {
+            await this.commandList(options);
+        });
     }
-    if (basename !== name + '.xml') {
-        throw Error('filename ' + filepath + ' and name ' + name + ' do not correspond');
+    async commandList(options) {
+        await this.prologue(options);
+        if (this.dbManager === undefined)
+            throw 'dbManager undefined';
+        const dbClient = new DBClient_1.DBClient(this.dbManager);
+        dbClient.selectFromTable('List of Queries', 'cyk_query', { fields: 'query_id,query_name,query_auth,query_access,query_description', sort: options.sort || '1' });
     }
-    return tag;
 }
-async function executeXml(structure, tag, xmlSource) {
-    try {
-        logger.debug('executeXml ' + tag.attributes.NAME);
-        // structure.setInstructionType("print", new PrintInstructionType(logfilename))
-        const dbQueryInstructionType = structure.scope.getInstructionType('db.query');
-        if (dbQueryInstructionType === undefined) {
-            throw Error('dbQueryInstructionType not found');
-        }
-        const scopeParse = new core_1.Scope(structure, structure.scope, undefined);
-        const dbQueryInst = await dbQueryInstructionType.parseInstruction(tag, scopeParse);
-        dbQueryInst.source = xmlSource;
-        const scopeExecute = new core_1.Scope(structure, structure.scope, undefined);
-        await dbQueryInst.execute(scopeExecute);
+//--------------------------------------------------------------------------------------------------------------------
+// class queryData
+//--------------------------------------------------------------------------------------------------------------------
+class queryData extends Cmd_1.Cmd {
+    constructor(name, description) {
+        super(name);
+        this.description(description)
+            .argument('<query>', 'query name')
+            .option('--where <clause_where_sql>', 'criteria in SQL syntax')
+            .option('-s --sort <columns>', 'sort by columns positions (begins by 0) separated by comma')
+            .option('-w --width <colwidth>', 'columns widths separated by comma')
+            .action(async (query, options) => {
+            this.commandData(query, options);
+        });
     }
-    catch (err) {
-        logger.error(err);
+    async commandData(query, options) {
+        try {
+            await this.prologue(options);
+            if (this.dbManager === undefined)
+                throw 'dbManager undefined';
+            const dbQuery = await this.dbManager.dbQueryExist(query);
+            if (dbQuery === undefined)
+                throw 'query ' + query + ' not found';
+            //DBClient
+        }
+        catch (err) {
+            logger.error(err);
+        }
     }
 }
-async function testQuery(structure, queryName) {
-    const xmlScript = `
-    <block>
-    <object name='result'/>
-    <db.execute query='${queryName}' result='result' />
-    <print>string(result)</print>
-    </block>
-    `;
-    const script = new core_1.Script(structure.scope, 'test', xmlScript);
-    await script.parseInstructions();
-    await script.execute();
-}

package/build/RunCommand.js

@@ -61,11 +61,11 @@ async function runFile(filename) {
     if (filename.indexOf(".") !== -1) {
         filename = filename.substring(0, filename.indexOf("."));
     }
+    // skip filename with double underscore
+    if (filename.indexOf("__") !== -1)
+        return;
     let xmlfilename = filename + ".xml";
-    // let logfilename = filename + ".log"
-    // let outfilename = filename + ".output"
     let xml = fs.readFileSync(xmlfilename);
-    // fs.writeFileSync(logfilename, "")
     try {
         if (process.env.DBREMOTE_URL === undefined)
             throw 'DBREMOTE_URL undefined';
@@ -76,14 +76,24 @@ async function runFile(filename) {
         const login = await dbRemote.signin(process.env.USER_NAME, undefined, process.env.USER_PASSWORD);
         const dbManager = new core_1.DBManager(structure.scope, dbRemote);
         await dbManager.initialize();
-        const tag = (0, core_1.parseXML)(xmlfilename, xml.toString());
-        const moduleInstruction = new core_1.ModuleInstruction(tag, dbManager);
-        await moduleInstruction.parse(structure.scope);
-        await moduleInstruction.execute(structure.scope);
-        // structure.scope.addInstructionType(new PrintInstructionType(logfilename))
-        // let script = new Script(structure.scope, xmlfilename, xml.toString())
-        // await script.parseInstructions()
-        // await script.execute()
+        const user_lang = login.content.user_lang;
+        if (user_lang && user_lang.trim() !== '') {
+            const langfilename = filename + "__" + user_lang + ".xml";
+            if (fs.existsSync(langfilename)) {
+                const langXml = fs.readFileSync(langfilename);
+                const tag = (0, core_1.parseXML)(xmlfilename, langXml.toString());
+                const modLang = new core_1.ModuleInstruction(tag, dbManager);
+                await modLang.parse(structure.scope);
+                await modLang.execute(structure.scope);
+                const langMap = modLang.objectData?.variables.getData(user_lang);
+                if (langMap !== null && langMap !== undefined) {
+                    structure.mapLang = langMap;
+                }
+            }
+        }
+        let script = new core_1.Script(structure.scope, xmlfilename, xml.toString());
+        await script.parseInstructions();
+        await script.execute();
     }
     catch (err) {
         if (err instanceof core_1.XmlError) {
@@ -92,21 +102,4 @@ async function runFile(filename) {
         }
         console.log(err);
     }
-    // let log = fs.readFileSync(logfilename)
-    // if (fs.existsSync(outfilename) === true ) {
-    //     let out = fs.readFileSync(outfilename)
-    //     if (log.toString() === out.toString()) {
-    //         console.log("test " + xmlfilename + " SUCCESS")
-    //         result = true
-    //     }
-    //     else {
-    //         console.log("test " + xmlfilename + " FAILURE")
-    //         result = false
-    //     }
-    // }
-    // else {
-    //     console.log("test " + xmlfilename + " output file not found ")
-    //     result = false
-    // }
-    // return result
 }

package/build/TableCommand.js

@@ -41,8 +41,8 @@ class TableCommand extends commander_1.Command {
         this.addCommand(new TableImportCmd());
         this.addCommand(new TableList('list', 'list database tables'));
         this.addCommand(new TableList('l', '(l)ist database tables'));
-        this.addCommand(new TableQuery('query', 'query select table content'));
-        this.addCommand(new TableQuery('q', 'query select table content'));
+        this.addCommand(new TableData('data', 'table (d)ata'));
+        this.addCommand(new TableData('d', 'table (d)ata'));
     }
 }
 exports.TableCommand = TableCommand;
@@ -271,25 +271,25 @@ class TableList extends Cmd_1.Cmd {
         if (this.dbManager === undefined)
             throw 'dbManager undefined';
         const dbClient = new DBClient_1.DBClient(this.dbManager);
-        dbClient.selectFromTable('List of Tables', 'cyk_table', { fields: 'table_id,table_name,table_description,table_access', sort: options.sort || '1' });
+        dbClient.selectFromTable('List of Tables', 'cyk_table', { fields: 'table_id,table_name,table_auth,table_access,table_description', sort: options.sort || '1' });
     }
 }
 //--------------------------------------------------------------------------------------------------------------------
-// class TableQuery
+// class TableData
 //--------------------------------------------------------------------------------------------------------------------
-class TableQuery extends Cmd_1.Cmd {
+class TableData extends Cmd_1.Cmd {
     constructor(name, description) {
         super(name);
         this.description(description)
-            .argument('<table>', 'table to query')
+            .argument('<table>', 'table name')
             .option('--where <clause_where_sql>', 'criteria in SQL syntax')
             .option('-s --sort <columns>', 'sort by columns positions (begins by 0) separated by comma')
             .option('-w --width <colwidth>', 'columns widths separated by comma')
             .action(async (table, options) => {
-            this.commandQuery(table, options);
+            this.commandData(table, options);
         });
     }
-    async commandQuery(table, options) {
+    async commandData(table, options) {
         try {
             await this.prologue(options);
             if (this.dbManager === undefined)

package/build/TestCommand.js

@@ -42,11 +42,11 @@ class TestCommand extends Cmd_1.Cmd {
     }
     async testRun(files, options) {
         try {
-            await this.prologue(options);
+            const signinResponse = await this.prologue(options);
             for (let ind = 0; ind < files.length; ind++) {
                 const result = await testfile(files[ind]);
                 if (result === false) {
-                    logger.debug('*********** FAILURE ' + process.argv[ind] + ' ***************');
+                    logger.debug('*********** FAILURE ' + files[ind] + ' ***************');
                 }
             }
         }
@@ -61,6 +61,9 @@ async function testfile(filename) {
     if (filename.indexOf(".") !== -1) {
         filename = filename.substring(0, filename.indexOf("."));
     }
+    // skip filename with double underscore
+    if (filename.indexOf("__") !== -1)
+        return true;
     let xmlfilename = filename + ".xml";
     let logfilename = filename + ".log";
     let outfilename = filename + ".output";
@@ -80,6 +83,22 @@ async function testfile(filename) {
         await dbManager.initialize();
         structure.scope.addInstructionType(new console_1.PrintInstructionType(logfilename));
         let script = new core_1.Script(structure.scope, xmlfilename, xml.toString());
+        const user_lang = login.content.user_lang;
+        if (user_lang && user_lang.trim() !== '') {
+            const langfilename = filename + "__" + user_lang + ".xml";
+            if (fs.existsSync(langfilename)) {
+                const langXml = fs.readFileSync(langfilename);
+                const tag = (0, core_1.parseXML)(xmlfilename, langXml.toString());
+                const modLang = new core_1.ModuleInstruction(tag, dbManager);
+                await modLang.parse(structure.scope);
+                await modLang.execute(structure.scope);
+                const langMap = modLang.objectData?.variables.getData(user_lang);
+                if (langMap !== null && langMap !== undefined) {
+                    structure.mapLang = langMap;
+                    outfilename = filename + "__" + user_lang + ".output";
+                }
+            }
+        }
         await script.parseInstructions();
         await script.execute();
         // console.log(JSON.stringify(script.block.toString()))

package/build/UserCommand.js

@@ -36,6 +36,7 @@ class UserAddCmd extends Cmd_1.Cmd {
             .option('-a --access <acl>', 'access control list')
             .option('-m --module <module_name>', 'module to launch by default')
             .option('-d --disable', 'user not abled to connect')
+            .option('-l --lang <language>', 'user language')
             .action(async (options) => {
             const dbUser = new core_1.DBUser();
             dbUser.name = options.name;
@@ -44,6 +45,7 @@ class UserAddCmd extends Cmd_1.Cmd {
             dbUser.access = options.access;
             dbUser.appli = options.module;
             dbUser.disable = options.disable || false;
+            dbUser.lang = options.lang;
             await this.commandAdd(dbUser, options);
         });
     }
@@ -75,7 +77,7 @@ class UserListCmd extends Cmd_1.Cmd {
             if (this.dbManager === undefined)
                 throw 'dbManager undefined';
             const dbClient = new DBClient_1.DBClient(this.dbManager);
-            dbClient.selectFromTable('List of users', 'cyk_user', { fields: 'user_id,user_name,user_email,user_access,user_appli,user_disable', sort: options.sort || '1' });
+            dbClient.selectFromTable('List of users', 'cyk_user', { fields: 'user_id,user_name,user_email,user_access,user_appli,user_lang,user_disable', sort: options.sort || '1' });
         }
         catch (err) {
             logger.error(err);
@@ -91,6 +93,7 @@ class UserUpdateCmd extends Cmd_1.Cmd {
             .option('-e --email <email>', 'user email address')
             .option('-a --access <acl>', 'access control list')
             .option('-m --module <module_name>', 'module to launch by default')
+            .option('-l --lang <language>', 'user language')
             .option('-d --disable', 'user not able to connect')
             .action(async (options) => {
             const dbUser = new core_1.DBUser();
@@ -99,6 +102,7 @@ class UserUpdateCmd extends Cmd_1.Cmd {
             dbUser.email = options.email;
             dbUser.access = options.access;
             dbUser.appli = options.module;
+            dbUser.lang = options.lang;
             dbUser.disable = options.disable;
             await this.commandUpdate(dbUser, options);
         });
@@ -122,6 +126,8 @@ class UserUpdateCmd extends Cmd_1.Cmd {
                 dbUser1.access = dbUser2.access;
             if (dbUser2.appli !== undefined)
                 dbUser1.appli = dbUser2.appli;
+            if (dbUser2.lang !== undefined)
+                dbUser1.lang = dbUser2.lang;
             if (dbUser2.disable !== undefined)
                 dbUser1.disable = dbUser2.disable;
             // logger.debug('dbUser1 before dbUserUpdate : ', dbUser1)

package/docker.env

@@ -33,6 +33,6 @@ LOGIN_APPLI="accounting"
 
 USER_NAME=cyk
 USER_PASSWORD=cyk
-CYK_PORT="3000"
-DBREMOTE_URL="http://localhost:3000"
+CYK_PORT="3100"
+DBREMOTE_URL="http://localhost:3100"