@cyklang/cli 0.2.2 → 0.3.0

package/src/RunCommand.ts

@@ -1,4 +1,4 @@
-import { Structure, Script, XmlError, DBRemote, DBManager, ModuleInstruction, parseXML } from "@cyklang/core"
+import { Structure, Script, XmlError, DBRemote, DBManager, ModuleInstruction, parseXML, MapData } from "@cyklang/core"
 import * as fs from "fs"
 import { errorconsole, PrintInstructionType } from "./console"
 import loglevel from 'loglevel'
@@ -11,15 +11,15 @@ export class RunCommand extends Cmd {
     constructor() {
         super('run')
         this.description('run module').version('0.2')
-        .argument('<files...>', 'local module file(s) to run')
-        .action(async(files: any, options: any) => {
-            await this.runFiles(files, options)
-        })
+            .argument('<files...>', 'local module file(s) to run')
+            .action(async (files: any, options: any) => {
+                await this.runFiles(files, options)
+            })
     }
     async runFiles(files: string[], options: any) {
         try {
             await this.prologue(options)
-            for (let ind=0; ind < files.length; ind++) {
+            for (let ind = 0; ind < files.length; ind++) {
                 const result = await runFile(files[ind])
                 // if (result === false) {
                 //     logger.debug('*********** FAILURE ' + process.argv[ind] + ' ***************')
@@ -40,32 +40,46 @@ async function runFile(filename: string): Promise<void> {
         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'
-        logger.trace('DBREMOTE_URL '+process.env.DBREMOTE_URL)
+        logger.trace('DBREMOTE_URL ' + process.env.DBREMOTE_URL)
         const structure = new Structure()
         const nodeCrypto = new NodeCrypto()
         const dbRemote = new DBRemote(structure.scope, process.env.DBREMOTE_URL, nodeCrypto)
         const login = await dbRemote.signin(process.env.USER_NAME, undefined, process.env.USER_PASSWORD)
         const dbManager = new DBManager(structure.scope, dbRemote)
         await dbManager.initialize()
-        const tag = parseXML(xmlfilename, xml.toString())
-        const moduleInstruction = new 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 = parseXML(xmlfilename, langXml.toString())
+                const modLang = new 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 as MapData
+                }
+            }
+        }
+
+        let script = new Script(structure.scope, xmlfilename, xml.toString())
+        await script.parseInstructions()
+        await script.execute()
     }
     catch (err) {
 
@@ -75,24 +89,4 @@ async function runFile(filename: string): Promise<void> {
         }
         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/src/TableCommand.ts

@@ -20,8 +20,8 @@ export class TableCommand extends 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'))
     }
 }
 
@@ -273,30 +273,30 @@ class TableList extends Cmd {
 
         const dbClient = new DBClient(this.dbManager)
         dbClient.selectFromTable('List of Tables', 'cyk_table',
-            { fields: 'table_id,table_name,table_description,table_access', sort: options.sort || '1' }
+            { fields: 'table_id,table_name,table_auth,table_access,table_description', sort: options.sort || '1' }
         )
     }
 }
 
 //--------------------------------------------------------------------------------------------------------------------
-// class TableQuery
+// class TableData
 //--------------------------------------------------------------------------------------------------------------------
 
-class TableQuery extends Cmd {
+class TableData extends Cmd {
 
     constructor(name: string, description: string) {
         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: string, options: any) {
+    async commandData(table: string, options: any) {
         try {
             await this.prologue(options)
             if (this.dbManager === undefined) throw 'dbManager undefined'

package/src/TestCommand.ts

@@ -1,4 +1,4 @@
-import { Structure, Script, XmlError, DBRemote, DBManager } from "@cyklang/core"
+import { Structure, Script, XmlError, DBRemote, DBManager, MapData, ModuleInstruction, parseXML } from "@cyklang/core"
 import * as fs from "fs"
 import { errorconsole, PrintInstructionType } from "./console"
 import loglevel from 'loglevel'
@@ -18,11 +18,11 @@ export class TestCommand extends Cmd {
     }
     async testRun(files: string[], options: any) {
         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] + ' ***************')
                 }
             }
         }
@@ -41,6 +41,9 @@ async function testfile(filename: string): Promise<boolean> {
         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"
@@ -62,6 +65,28 @@ async function testfile(filename: string): Promise<boolean> {
         await dbManager.initialize()
         structure.scope.addInstructionType(new PrintInstructionType(logfilename))
         let script = new 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 = parseXML(xmlfilename, langXml.toString())
+                const modLang = new 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 as MapData
+
+                    outfilename = filename + "__" + user_lang + ".output"
+                }
+            }
+        }
+
         await script.parseInstructions()
         await script.execute()
         // console.log(JSON.stringify(script.block.toString()))

package/src/UserCommand.ts

@@ -31,6 +31,7 @@ interface Options {
     disable: boolean | undefined
     env: string | undefined
     sort: string | undefined
+    lang: string | undefined
 }
 
 class UserAddCmd extends Cmd {
@@ -43,6 +44,7 @@ class UserAddCmd extends 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: Options) => {
                 const dbUser = new DBUser()
                 dbUser.name = options.name
@@ -51,6 +53,7 @@ class UserAddCmd extends Cmd {
                 dbUser.access = options.access
                 dbUser.appli = options.module
                 dbUser.disable = options.disable || false
+                dbUser.lang = options.lang
                 await this.commandAdd(dbUser, options)
             })
     }
@@ -83,7 +86,7 @@ class UserListCmd extends Cmd {
 
             const dbClient = new 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' })
+                { fields: 'user_id,user_name,user_email,user_access,user_appli,user_lang,user_disable', sort: options.sort || '1' })
 
         }
         catch (err) {
@@ -102,6 +105,7 @@ class UserUpdateCmd extends 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: Options) => {
                 const dbUser = new DBUser()
@@ -110,6 +114,7 @@ class UserUpdateCmd extends 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)
             })
@@ -126,6 +131,7 @@ class UserUpdateCmd extends Cmd {
             if (dbUser2.email !== undefined) dbUser1.email = dbUser2.email
             if (dbUser2.access !== undefined) 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)
             await this.dbManager.dbUserUpdate(dbUser1)