cob-cli 2.23.0 → 2.25.0

package/.gitmodules

@@ -0,0 +1,27 @@
+[submodule "templates/keywords/image"]
+	path = templates/keywords/image
+	url = https://github.com/cob/customize.keywords.image.git
+[submodule "templates/keywords/styleResults"]
+	path = templates/keywords/styleResults
+	url = git@github.com:cob/customize.keywords.styleResults.git
+[submodule "templates/keywords/log"]
+	path = templates/keywords/log
+	url = git@github.com:cob/customize.keywords.log.git
+[submodule "templates/keywords/calc"]
+	path = templates/keywords/calc
+	url = git@github.com:cob/customize.keywords.calc.git
+[submodule "templates/keywords/audit"]
+	path = templates/keywords/audit
+	url = git@github.com:cob/customize.keywords.audit.git
+[submodule "templates/frontend/common"]
+	path = templates/frontend/common
+	url = git@github.com:cob/customize.frontend.common.git
+[submodule "templates/frontend/formatList/currency"]
+	path = templates/frontend/formatList/currency
+	url = git@github.com:cob/customize.frontend.formatList.currency.git
+[submodule "templates/dashboards/dash"]
+	path = templates/dashboards/dash
+	url = git@github.com:cob/customize.dashboard.dash.git
+[submodule "templates/keywords/kibana"]
+	path = templates/keywords/kibana
+	url = git@github.com:cob/customize.keywords.kibana.git

package/customizations/dashboard.dash.js

@@ -3,9 +3,12 @@ exports.option = {
     short: "Dash",
     questions: [
     ],
-    customization: function (answers) {
+    customization: async function (answers) {
+        console.log("\nApplying Dash keyword customizations ...")
+
         const { copy } = require("../lib/task_lists/customize_copy");
         const  target = "./recordm/customUI/dash/"
-        return copy("../../templates/dashboards/dash/",target)
+        await copy("../../templates/dashboards/dash/",target)
+        return require("../templates/dashboards/dash/package.json").version
     }
 }

package/customizations/frontend.common.js

@@ -11,5 +11,6 @@ exports.option = {
       const target = "./recordm/customUI/"
       await copy("../../templates/frontend/common/",target)
       await mergeFiles("Frontend.Common")
+      return require("../templates/frontend/common/package.json").version
   }
 }

package/customizations/frontend.formatList.currency.js

@@ -5,11 +5,13 @@ exports.option = {
   ],
   customization: async function (answers) {
       console.log("\nApplying FormatCurrency frontend customizations ...")
+      
       const { copy } = require("../lib/task_lists/customize_copy");
       const { mergeFiles } = require("../lib/task_lists/customize_mergeFiles");
       
       const target = "./recordm/customUI/"
       await copy("../../templates/frontend/formatList/currency/",target)
       await mergeFiles("frontend.formatList.currency.js")
+      return require("../templates/frontend/formatList/currency/package.json").version
   }
 }

package/customizations/keywords.audit.js

@@ -13,5 +13,6 @@ exports.option = {
       const be_target = "./integrationm/"
       await copy("../../templates/keywords/audit/backend",be_target)
       await mergeFiles("Keyword.Audit")
+      return require("../templates/keywords/audit/package.json").version
   }
 }

package/customizations/keywords.calc.js

@@ -13,5 +13,6 @@ exports.option = {
       const be_target = "./integrationm/"
       await copy("../../templates/keywords/calc/backend/",be_target)
       await mergeFiles("Keyword.Calc")
+      return require("../templates/keywords/calc/package.json").version
   }
 }

package/customizations/keywords.image.js

@@ -0,0 +1,16 @@
+exports.option = {
+  name: 'Image - Allows for $image[.replace|.add][(width)]', 
+  short: "Image",
+  questions: [
+  ],
+  customization: async function (answers) {
+      console.log("\nApplying Image keyword customizations ...")
+
+      const { copy } = require("../lib/task_lists/customize_copy");
+      const { mergeFiles } = require("../lib/task_lists/customize_mergeFiles");
+      const fe_target = "./recordm/customUI/"
+      await copy("../../templates/keywords/image/frontend",fe_target)
+      await mergeFiles("Keyword.Image")
+      return require("../templates/keywords/image/package.json").version
+  }
+}

package/customizations/keywords.js

@@ -9,6 +9,8 @@ exports.option = {
         require("./keywords.calc").option,
         require("./keywords.audit").option,
         require("./keywords.styleResults").option,
+        require("./keywords.image").option,
+        require("./keywords.kibana").option,
         require("./keywords.log").option
     ]}
   ]

package/customizations/keywords.kibana.js

@@ -0,0 +1,16 @@
+exports.option = {
+  name: 'Kibana - Allows for $kibana[dashboardId [,heigth])', 
+  short: "Kibana",
+  questions: [
+  ],
+  customization: async function (answers) {
+      console.log("\nApplying Kibana keyword customizations ...")
+
+      const { copy } = require("../lib/task_lists/customize_copy");
+      const { mergeFiles } = require("../lib/task_lists/customize_mergeFiles");
+      const fe_target = "./recordm/customUI/"
+      await copy("../../templates/keywords/kibana/frontend",fe_target)
+      await mergeFiles("Keyword.Kibana")
+      return require("../templates/keywords/kibana/package.json").version
+  }
+}

package/customizations/keywords.log.js

@@ -13,5 +13,6 @@ exports.option = {
       const be_target = "./integrationm/"
       await copy("../../templates/keywords/log/backend",be_target)
       await mergeFiles("Keyword.Log")
+      return require("../templates/keywords/log/package.json").version
   }
 }

package/customizations/keywords.styleResults.js

@@ -13,5 +13,6 @@ exports.option = {
       const be_target = "./integrationm/"
       await copy("../../templates/keywords/styleResults/backend",be_target)
       await mergeFiles("Keyword.StyleResults")
+      return require("../templates/keywords/styleResults/package.json").version
   }
 }

package/lib/commands/customize.js

@@ -62,9 +62,9 @@ function processOption(option) {
     })
   } else if(option.customization) {
     // Final customization options HAVE a 'customization' function, that process the answers, and HAVE one or more questions
-    return inquirer.prompt(option.questions).then( answers => {
-      option.customization(answers) 
-      updateCustomizationsVersions(option.short, require('../../package.json').version) 
+    return inquirer.prompt(option.questions).then( async (answers) => {
+      let version = await option.customization(answers) || require('../../package.json').version
+      updateCustomizationsVersions(option.short, version) 
     })
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cob-cli",
-  "version": "2.23.0",
+  "version": "2.25.0",
   "description": "A command line utility to help Cult of Bits partners develop with higher speed and reusing common code and best practices.",
   "preferGlobal": true,
   "repository": {

package/templates/dashboards/dash/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cob-dashboard-vue",
-  "version": "0.1.0",
+  "version": "2.3.1",
   "private": true,
   "scripts": {
     "serve": "vue-cli-service serve",

package/templates/frontend/common/templates/frontend/common/package.json

@@ -0,0 +1,3 @@
+{
+  "version": "1.0.0"
+}

package/templates/frontend/formatList/currency/package.json

@@ -0,0 +1,3 @@
+{
+  "version": "1.0.0"
+}

package/templates/keywords/audit/backend/scripts/_audit.groovy

@@ -4,7 +4,6 @@ import org.codehaus.jettison.json.JSONObject
 import com.google.common.cache.*
 import java.util.concurrent.TimeUnit
 
-// ========================================================================================================
 if (msg.product != "recordm-definition" && msg.product != "recordm" ) return
 
 @Field static cacheOfAuditFieldsForDefinition = CacheBuilder.newBuilder()
@@ -16,68 +15,64 @@ if (msg.product == "recordm-definition") cacheOfAuditFieldsForDefinition.invalid
 // ========================================================================================================
 def auditFields = cacheOfAuditFieldsForDefinition.get(msg.type, { getAuditFields(msg.type) })
 if (auditFields.size() > 0
-	&& msg.product == "recordm"
-	&& msg.user != "integrationm"
-	&& msg.action =~ "add|update" ) {
+    && msg.product == "recordm"
+    && msg.user != "integrationm"
+    && msg.action =~ "add|update" ) {
 
-	def updates = getAuditFieldsUpdates(auditFields,msg.instance.fields)
-	def result = actionPacks.recordm.update(msg.type, "recordmInstanceId:" + msg.instance.id, updates);
-	if(updates) log.info("[\$audit] UPDATE '${msg.type}' id:${msg.instance.id}, updates: ${updates}, result:${result.getStatus()} | ${result.getStatusInfo()} ");
+    def updates = getAuditFieldsUpdates(auditFields,msg.instance.fields)
+    def result = actionPacks.recordm.update(msg.type, "recordmInstanceId:" + msg.instance.id, updates);
+    if(updates) log.info("[\$audit] UPDATE '${msg.type}' id:${msg.instance.id}, updates: ${updates}, result:${result.getStatus()} | ${result.getStatusInfo()} ");
 }
 
 // ========================================================================================================
 def getAuditFieldsUpdates(auditFields,instanceFields) {
-	def updates = [:]
-	auditFields.each { auditField ->
-		if( auditField.op == "creator" && msg.action == "update" && msg.value(auditField.name) != null) return // 'creator' fields are only changed in 'update' if the previous value was empty (meaning it was a field that was not visible)
-		if( msg.action == 'update' && !msg.diff) return // Only continues if there is at least one change
-		if( auditField.args == "uri") {
-			updates << [(auditField.name) : actionPacks.get("userm").getUser(msg.user).data._links.self]
+    def updates = [:]
+    auditFields.each { auditField ->
+        if( auditField.op == "creator" && msg.action == "update" && msg.value(auditField.name) != null) return // 'creator' fields are only changed in 'update' if the previous value was empty (meaning it was a field that was not visible)
+        if( msg.action == 'update' && !msg.diff) return // Only continues if there is at least one change
+        if( auditField.args == "uri") {
+            updates << [(auditField.name) : actionPacks.get("userm").getUser(msg.user).data._links.self]
 
-		} else if( auditField.args == "username") {
-			updates << [(auditField.name) : msg.user]
-			
-		} else if( auditField.args == "time") {
-			if(msg.action == 'add' && Math.abs(msg.value(auditField.name, Long.class)?:0 - msg._timestamp_) < 30000) return // Ignore changes less then 30s
-			updates << [(auditField.name) : "" + msg._timestamp_]
-		}
-	}
-	return updates
+        } else if( auditField.args == "username") {
+            updates << [(auditField.name) : msg.user]
+            
+        } else if( auditField.args == "time") {
+            if(msg.action == 'add' && Math.abs(msg.value(auditField.name, Long.class)?:0 - msg._timestamp_) < 30000) return // Ignore changes less then 30s
+            updates << [(auditField.name) : "" + msg._timestamp_]
+        }
+    }
+    return updates
 }
 
-// ========================================================================================================
 def getAuditFields(definitionName) {
-	log.info("[\$audit] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
-
-	// Obtém detalhes da definição
-	def definitionEncoded = URLEncoder.encode(definitionName, "utf-8").replace("+", "%20")
-	def resp = actionPacks.rmRest.get( "recordm/definitions/name/${definitionEncoded}".toString(), [:], "integrationm");
-	JSONObject definition = new JSONObject(resp);
+    // Obtém detalhes da definição
+    def definitionEncoded = URLEncoder.encode(definitionName, "utf-8").replace("+", "%20")
+    def resp = actionPacks.rmRest.get( "recordm/definitions/name/${definitionEncoded}".toString(), [:], "integrationm");
+    JSONObject definition = new JSONObject(resp);
 
-	def fieldsSize = definition.fieldDefinitions.length();
+    def fieldsSize = definition.fieldDefinitions.length();
 
-	def fields = [:]
-	(0..fieldsSize-1).each { index ->
-		def fieldDefinition  = definition.fieldDefinitions.getJSONObject(index)
-		def fieldDescription = fieldDefinition.getString("description")
-		if(fieldDescription){
-			def fieldDefId       = fieldDefinition.get("id");
-			def fieldName        = fieldDefinition.get("name");
-			fields[fieldDefId]   = [name:fieldName, description: fieldDescription]
-		}
-	}
+    def fields = [:]
+    (0..fieldsSize-1).each { index ->
+        def fieldDefinition  = definition.fieldDefinitions.getJSONObject(index)
+        def fieldDescription = fieldDefinition.getString("description")
+        if(fieldDescription){
+            def fieldDefId       = fieldDefinition.get("id");
+            def fieldName        = fieldDefinition.get("name");
+            fields[fieldDefId]   = [name:fieldName, description: fieldDescription]
+        }
+    }
 
-	// Finalmente obtém a lista de campos que é necessário calcular
-	def auditFields = [];
-	fields.each { fieldId,field -> 
-		def matcher = field.description =~ /[$]audit\.(creator|updater)\.(username|uri|time)/
-		if(matcher) {
-			def op = matcher[0][1]
-			def arg = matcher[0][2]
-			auditFields << [fieldId: fieldId, name:field.name, op : op, args: arg]
-		}
-	}
-	log.info("[\$audit] Update 'auditFields' for '$definitionName': $auditFields");
-	log.info("[\$audit] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
-	return auditFields
+    // Finalmente obtém a lista de campos que é necessário calcular
+    def auditFields = [];
+    fields.each { fieldId,field -> 
+        def matcher = field.description =~ /[$]audit\.(creator|updater)\.(username|uri|time)/
+        if(matcher) {
+            def op = matcher[0][1]
+            def arg = matcher[0][2]
+            auditFields << [fieldId: fieldId, name:field.name, op : op, args: arg]
+        }
+    }
+    log.info("[\$audit] Update 'auditFields' for '$definitionName': $auditFields");
+    return auditFields
 }

package/templates/keywords/audit/package.json

@@ -0,0 +1,3 @@
+{
+  "version": "1.1.12"
+}

package/templates/keywords/calc/backend/scripts/_calc.groovy

@@ -6,7 +6,6 @@ import java.math.RoundingMode;
 import com.google.common.cache.*
 import java.util.concurrent.TimeUnit
 
-// ========================================================================================================
 if (msg.product != "recordm-definition" && msg.product != "recordm" ) return
 
 @Field static cacheOfCalcFieldsForDefinition = CacheBuilder.newBuilder()
@@ -18,144 +17,135 @@ if (msg.product == "recordm-definition") cacheOfCalcFieldsForDefinition.invalida
 // ========================================================================================================
 def calculationFields = cacheOfCalcFieldsForDefinition.get(msg.type, { getAllCalculationFields(msg.type) })
 if (calculationFields.size() > 0
-	&& msg.product == "recordm"
-	&& msg.user != "integrationm"
-	&& msg.action =~ "add|update" ){
+    && msg.product == "recordm"
+    && msg.user != "integrationm"
+    && msg.action =~ "add|update" ){
 
-	def updates = executeCalculations(calculationFields, msg.instance.fields)
+    def updates = executeCalculations(calculationFields, msg.instance.fields)
     def result = actionPacks.recordm.update(messageMap.type, "recordmInstanceId:" + messageMap.instance.id, updates);
-	if(updates) log.info("[\$calc] UPDATE '${msg.type}' id:${msg.instance.id}, updates: ${updates}, result:${result.getStatus()} | ${result.getStatusInfo()} ");
+    if(updates) log.info("[\$calc] UPDATE '${msg.type}' id:${msg.instance.id}, updates: ${updates}, result:${result.getStatus()} | ${result.getStatusInfo()} ");
 }
+// ========================================================================================================
 
-// ==================================================
 def getCalculationOperation(fieldDescription) {
-	def matcher = fieldDescription =~/.*[$]calc.([^(]+)/
-	def op = matcher[0][1]
-	return op
+    def matcher = fieldDescription =~/.*[$]calc.([^(]+)/
+    def op = matcher[0][1]
+    return op
 }
 
-// ==================================================
 def getCalculationArgNames(fieldDescription) {
-	def matcher = fieldDescription =~/.*[$]calc.[^(]+\(([^(]+)\)/
-	def argNamesArray = matcher[0][1].tokenize(",")
-	return argNamesArray;
+    def matcher = fieldDescription =~/.*[$]calc.[^(]+\(([^(]+)\)/
+    def argNamesArray = matcher[0][1].tokenize(",")
+    return argNamesArray;
 }
 
-// ========================================================================================================
 def executeCalculations(calculationFields,instanceFields) {
-	def updates = [:]
-	def atLeastOneChangeFlag = false;
-	def passCount = 0;
-	def temporaryResults = [:]
-	while(passCount++ == 0 || atLeastOneChangeFlag && passCount < 10) { //10 is just for security against loops
-		atLeastOneChangeFlag = false
-		calculationFields.each { calculation ->
-			def novoResultado = evaluateExpression(calculation,instanceFields,temporaryResults)
-			if(temporaryResults[calculation.fieldId] != novoResultado ) {
-				// log.info("[\$calc] {{passCount:${passCount}, field:${calculation.name} (${calculation.fieldId})" + 
-				// 		", calcType:${calculation.op}(${calculation.args})" +
-				// 		", previousResult:${temporaryResults[calculation.fieldId]}" +
-				// 		", calcValue:$novoResultado}}");
-
-				temporaryResults[calculation.fieldId] = novoResultado;
-				updates << [(calculation.name) : novoResultado]
-				atLeastOneChangeFlag = true
-			}
-		}
-	}
-	return updates
+    def updates = [:]
+    def atLeastOneChangeFlag = false;
+    def passCount = 0;
+    def temporaryResults = [:]
+    while(passCount++ == 0 || atLeastOneChangeFlag && passCount < 10) { //10 is just for security against loops
+        atLeastOneChangeFlag = false
+        calculationFields.each { calculation ->
+            def novoResultado = evaluateExpression(calculation,instanceFields,temporaryResults)
+            if(temporaryResults[calculation.fieldId] != novoResultado ) {
+                // log.info("[\$calc] {{passCount:${passCount}, field:${calculation.name} (${calculation.fieldId})" + 
+                // 		", calcType:${calculation.op}(${calculation.args})" +
+                // 		", previousResult:${temporaryResults[calculation.fieldId]}" +
+                // 		", calcValue:$novoResultado}}");
+
+                temporaryResults[calculation.fieldId] = novoResultado;
+                updates << [(calculation.name) : novoResultado]
+                atLeastOneChangeFlag = true
+            }
+        }
+    }
+    return updates
 }
 
-// ==================================================
 def evaluateExpression(calculation,instanceFields,temporaryResults) {
-	// Realizar operação
-	def resultado = new BigDecimal(0)
-	def args = getCalculationArguments(calculation,instanceFields,temporaryResults)
-
-	if(calculation.op == "multiply" && args.size() > 0) {
-		resultado = 1
-		args.each { arg -> resultado = resultado.multiply(new BigDecimal(arg?.trim() ?: 0)) }
-
-	} else if (calculation.op == "divide" && args.size() == 2 && (args[1]?:0 != 0)) {
-		resultado = new BigDecimal(args[0]?.trim() ?:0);
-		resultado = resultado.divide(new BigDecimal(args[1]?.trim()), 8, RoundingMode.HALF_UP)
-
-	} else if(calculation.op == "sum") {
-		args.each { arg -> resultado = resultado + new BigDecimal(arg?.trim() ?: 0)}
-
-	} else if (calculation.op == "subtract" && args.size() == 2) {
-		resultado = new BigDecimal(args[0]?.trim() ?: 0);
-		resultado = resultado.subtract(new BigDecimal(args[1]?.trim() ?: 0))
-	}
-	return resultado.stripTrailingZeros().toPlainString()
+    // Realizar operação
+    def resultado = new BigDecimal(0)
+    def args = getCalculationArguments(calculation,instanceFields,temporaryResults)
+
+    if(calculation.op == "multiply" && args.size() > 0) {
+        resultado = 1
+        args.each { arg -> resultado = resultado.multiply(new BigDecimal(arg?.trim() ?: 0)) }
+
+    } else if (calculation.op == "divide" && args.size() == 2 && (args[1]?:0 != 0)) {
+        resultado = new BigDecimal(args[0]?.trim() ?:0);
+        resultado = resultado.divide(new BigDecimal(args[1]?.trim()), 8, RoundingMode.HALF_UP)
+
+    } else if(calculation.op == "sum") {
+        args.each { arg -> resultado = resultado + new BigDecimal(arg?.trim() ?: 0)}
+
+    } else if (calculation.op == "subtract" && args.size() == 2) {
+        resultado = new BigDecimal(args[0]?.trim() ?: 0);
+        resultado = resultado.subtract(new BigDecimal(args[1]?.trim() ?: 0))
+    }
+    return resultado.stripTrailingZeros().toPlainString()
 }
 
-// ==================================================
 def getCalculationArguments(calculation,instanceFields,temporaryResults) {
-	def values = calculation.args.collect { argName,argFieldIds ->
-		(""+argName).isNumber()
-			? argName * 1
-			: getAllAplicableValuesForVarName(calculation.fieldId,argName,argFieldIds,instanceFields,temporaryResults)
-	}
-	return values.flatten()
+    def values = calculation.args.collect { argName,argFieldIds ->
+        (""+argName).isNumber()
+            ? argName * 1
+            : getAllAplicableValuesForVarName(calculation.fieldId,argName,argFieldIds,instanceFields,temporaryResults)
+    }
+    return values.flatten()
 }
 
-// ==================================================
 def getAllAplicableValuesForVarName(fieldId,varName,varFieldIds,instanceFields,temporaryResults) {
-	// log.info("[\$calc] find '$varName'($varFieldIds) in $instanceFields (temporaryResults=$temporaryResults) ");
-	def relevantFields = instanceFields.findAll{ instField -> varFieldIds.indexOf(instField.fieldDefinition.id) >= 0 }
-	
-	def result = varFieldIds.collect { varFieldId ->
-		if(temporaryResults[varFieldId] != null) { 
-			return temporaryResults[varFieldId]
-		} else {
-			return  temporaryResults[varFieldId] = instanceFields.findAll{ instField -> varFieldId == instField.fieldDefinition.id }?.collect { it.value }
-		}
-	}
-	// log.info("[\$calc] values for '$varName'($varFieldIds) = $result (temporaryResults=$temporaryResults) " );
-	return result.flatten()
+    // log.info("[\$calc] find '$varName'($varFieldIds) in $instanceFields (temporaryResults=$temporaryResults) ");
+    def relevantFields = instanceFields.findAll{ instField -> varFieldIds.indexOf(instField.fieldDefinition.id) >= 0 }
+    
+    def result = varFieldIds.collect { varFieldId ->
+        if(temporaryResults[varFieldId] != null) { 
+            return temporaryResults[varFieldId]
+        } else {
+            return  temporaryResults[varFieldId] = instanceFields.findAll{ instField -> varFieldId == instField.fieldDefinition.id }?.collect { it.value }
+        }
+    }
+    // log.info("[\$calc] values for '$varName'($varFieldIds) = $result (temporaryResults=$temporaryResults) " );
+    return result.flatten()
 }
 
-// ========================================================================================================
 def getAllCalculationFields(definitionName) {
-	log.info("[\$calc] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
-
-	// Obtém detalhes da definição
-	def definitionEncoded = URLEncoder.encode(definitionName, "utf-8").replace("+", "%20")
-	def resp = actionPacks.rmRest.get( "recordm/definitions/name/${definitionEncoded}".toString(), [:], "integrationm");
-	JSONObject definition = new JSONObject(resp);
-
-	def fieldsSize = definition.fieldDefinitions.length();
-
-	def fields = [:]
-	(0..fieldsSize-1).each { index ->
-		def fieldDefinition  = definition.fieldDefinitions.getJSONObject(index)
-		def fieldDescription = fieldDefinition.get("description")
-		def fieldDefId       = fieldDefinition.get("id")
-		def fieldName        = fieldDefinition.get("name");
-		fields[fieldDefId]   = [name:fieldName, description: fieldDescription]
-	}
-
-	// Finalmente obtém a lista de campos que é necessário calcular
-	def calculationFields = [];
-	def previousId
-	fields.each { fieldId,field ->
-		if(field.description.toString() =~ /[$]calc\./) {
-			def op = getCalculationOperation(field.description)
-			def args = getCalculationArgNames(field.description)
-			argsFields = [:]
-			args.each { arg ->
-				if(arg == "previous") {
-					argsFields[arg] = [previousId]
-				} else {
-					argsFields[arg] = fields.findAll{fId,f -> f.description?.toString() =~ /.*[$]$arg.*/ }.collect { fId,f -> fId}
-				}
-			}
-			calculationFields << [fieldId: fieldId, name:field.name, op : op, args : argsFields]
-		}
-		previousId = fieldId
-	}
-	log.info("[\$calc] Update 'calculationFields' for '$definitionName': $calculationFields");	
-	log.info("[\$calc] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
-	return calculationFields
+    // Obtém detalhes da definição
+    def definitionEncoded = URLEncoder.encode(definitionName, "utf-8").replace("+", "%20")
+    def resp = actionPacks.rmRest.get( "recordm/definitions/name/${definitionEncoded}".toString(), [:], "integrationm");
+    JSONObject definition = new JSONObject(resp);
+
+    def fieldsSize = definition.fieldDefinitions.length();
+
+    def fields = [:]
+    (0..fieldsSize-1).each { index ->
+        def fieldDefinition  = definition.fieldDefinitions.getJSONObject(index)
+        def fieldDescription = fieldDefinition.get("description")
+        def fieldDefId       = fieldDefinition.get("id")
+        def fieldName        = fieldDefinition.get("name");
+        fields[fieldDefId]   = [name:fieldName, description: fieldDescription]
+    }
+
+    // Finalmente obtém a lista de campos que é necessário calcular
+    def calculationFields = [];
+    def previousId
+    fields.each { fieldId,field ->
+        if(field.description.toString() =~ /[$]calc\./) {
+            def op = getCalculationOperation(field.description)
+            def args = getCalculationArgNames(field.description)
+            argsFields = [:]
+            args.each { arg ->
+                if(arg == "previous") {
+                    argsFields[arg] = [previousId]
+                } else {
+                    argsFields[arg] = fields.findAll{fId,f -> f.description?.toString() =~ /.*[$]$arg.*/ }.collect { fId,f -> fId}
+                }
+            }
+            calculationFields << [fieldId: fieldId, name:field.name, op : op, args : argsFields]
+        }
+        previousId = fieldId
+    }
+    log.info("[\$calc] Update 'calculationFields' for '$definitionName': $calculationFields");	
+    return calculationFields
 }

package/templates/keywords/calc/package.json

@@ -0,0 +1,3 @@
+{
+  "version": "1.0.11"
+}

package/templates/keywords/image/frontend/js/cob/_image.js

@@ -0,0 +1,30 @@
+//----------------- $image  ------------------------
+cob.custom.customize.push(function (core, utils, ui) {
+  const matcher = /[$]image(.add|.replace)?(\(.+\))?/;
+
+  core.customizeAllInstances((instance, presenter) => {
+    if (instance.isNew() || presenter.isGroupEdit()) return;
+
+    let imagesFPs = presenter.findFieldPs((fp) => matcher.exec( fp.field.fieldDefinition.description ) );
+    imagesFPs.forEach((fp) => {
+      let args = fp.field.fieldDefinition.description.match(matcher);
+      let replaceFlag = (args && args[1] && args[1] == ".replace") || false;
+      let width = (args && args[2]) || "";
+      debugger;
+      let $image = $(
+        '<div style="width:100%;text-align:center">' +
+          "<img " +
+          (width ? 'style="width:' + width + 'px" ' : "") +
+          'src="' +
+          (fp.field.fieldDefinition.description.match(/[$]file/)
+            ? $(fp.content()[0]).find(".link-container a")[0].href
+            : fp.field.htmlEncodedValue) +
+          '">' +
+          "</img>" +
+          "</div>"
+      );
+      fp.content()[0].append($image[0]);
+      fp.content()[0].children[0].style.display = replaceFlag ? "none" : "";
+    });
+  });
+});

package/templates/keywords/image/frontend/js/customizations2.__MERGE__.js

@@ -0,0 +1 @@
+import("./cob/_image.js");

package/templates/keywords/image/package.json

@@ -0,0 +1,3 @@
+{
+  "version": "1.0.0"
+}

package/templates/keywords/kibana/frontend/js/cob/_kibana.js

@@ -0,0 +1,58 @@
+//----------------- $kibana  ------------------------
+cob.custom.customize.push(function (core, utils, ui) {
+    core.customizeAllInstances((instance, presenter) => 
+    {
+        if (instance.isNew() || presenter.isGroupEdit()) return;
+
+        let iFramesFPs = presenter.findFieldPs((fp) =>
+          /[$]kibana\(.+\)/.exec(fp.field.fieldDefinition.description)
+        );
+        iFramesFPs.forEach((fp) => {
+          let matcher = /[$]kibana\(([^,]+),([^,]+)(,([^,]+))??\)/;
+          let args = fp.field.fieldDefinition.description.match(matcher);
+          let dashboardKibana = args[1];
+          let query = args[2];
+          let height = args[4] || "300";
+
+          let varsMatcher = /{{(.+)}}/;
+          let vars = query.match(varsMatcher);
+
+          for (let i = 1; i < vars.length; i++) {
+            let varValue =
+              instance.findFields(vars[i]) &&
+              instance.findFields(vars[i])[0].value;
+            query = query.replaceAll(
+              "{{" + vars[i] + "}}",
+              '"' + varValue + '"'
+            );
+          }
+
+          if (
+            !$("#" + dashboardKibana).length &&
+            !instance.isNew() &&
+            !presenter.isGroupEdit()
+          ) {
+            let $kibana = $(
+              '<li id="' +
+                dashboardKibana +
+                '" style="margin:0;">' +
+                "<iframe " +
+                'src="/kibana/app/dashboards#/view/' +
+                dashboardKibana +
+                "?embed=true" +
+                "&hide-filter-bar=true" +
+                "&_a=(query:(language:lucene,query:'" +
+                encodeURI(query) +
+                "'))\" " +
+                'height="' +
+                height +
+                '" ' +
+                'width="99.6%" style="border: 1px solid lightgray;">' +
+                "</iframe>" +
+                "</li>"
+            );
+            fp.content()[0].append($kibana[0]);
+          }
+        });
+    })
+});

package/templates/keywords/kibana/frontend/js/customizations2.__MERGE__.js

@@ -0,0 +1 @@
+import("./cob/_kibana.js");

package/templates/keywords/kibana/package.json

@@ -0,0 +1,3 @@
+{
+  "version": "1.0.0"
+}

package/templates/keywords/log/backend/scripts/_log.groovy

@@ -16,12 +16,12 @@ if (msg.product == "recordm-definition") cacheOfLogFieldsForDefinition.invalidat
 // ========================================================================================================
 def logFields = cacheOfLogFieldsForDefinition.get(msg.type, { getLogFields(msg.type) })
 if( logFields.size() > 0
-	&& msg.product == "recordm"
-	&& msg.user != "integrationm"
-	&& msg.action =~ "add|update" 
+    && msg.product == "recordm"
+    && msg.user != "integrationm"
+    && msg.action =~ "add|update" 
 ) {
-	def updates = getLogUpdates(logFields)
-	def result = recordm.update(messageMap.type, "recordmInstanceId:" + messageMap.instance.id, updates);
+    def updates = getLogUpdates(logFields)
+    def result = recordm.update(messageMap.type, "recordmInstanceId:" + messageMap.instance.id, updates);
     if (updates) log.info("[\$log] UPDATE '${msg.type}' id:${msg.instance.id}, updates: ${updates}, result:${result} ");
 }
 
@@ -31,30 +31,30 @@ def getLogUpdates(logFields){
     def updates = [:]
     def currentUser = actionPacks.get("userm").getUser(msg.user).data.name;
 
-	logFields.each { logField ->
-		def commentLogs = msg.value(logField.name);
-		def newComment = msg.value(logField.sourceField);
-		def fieldMsg = getFieldMessage(logField.stateField);
-
-		if( newComment != null || msg.field(logField.stateField).changed() ){
-			def newLogEntry = "#### " + (new Date()).format('yyyy-MM-dd HH:mm:ss').toString() + " - " + currentUser;
-			newLogEntry += " [$fieldMsg] "
-			newLogEntry +="\n\n";
-			newLogEntry += newComment != null ? newComment : "";
-			newLogEntry +="\n\n";
-
-			if(commentLogs!=null) {
-				newLogEntry +=  "======================================================================\n";
-			}
-			updates << [(logField.name) : "" + newLogEntry + (commentLogs ?: "")];
-			updates << [(logField.sourceField) :  ""];		
-		}
-	}
+    logFields.each { logField ->
+        def commentLogs = msg.value(logField.name);
+        def newComment = msg.value(logField.sourceField);
+        def fieldMsg = getFieldMessage(logField.stateField);
+
+        if( newComment != null || msg.field(logField.stateField).changed() ){
+            def newLogEntry = "#### " + (new Date()).format('yyyy-MM-dd HH:mm:ss').toString() + " - " + currentUser;
+            newLogEntry += " [$fieldMsg] "
+            newLogEntry +="\n\n";
+            newLogEntry += newComment != null ? newComment : "";
+            newLogEntry +="\n\n";
+
+            if(commentLogs!=null) {
+                newLogEntry +=  "======================================================================\n";
+            }
+            updates << [(logField.name) : "" + newLogEntry + (commentLogs ?: "")];
+            updates << [(logField.sourceField) :  ""];		
+        }
+    }
     return updates
 }
 
 def getFieldMessage(field){
-	String newValue = msg.value(field) ?: "";
+    String newValue = msg.value(field) ?: "";
     if( msg.field(field).changed() ){
         String oldValue = msg.oldInstance.value(field) ?: "";
         return "$field: $oldValue -> $newValue";
@@ -63,37 +63,33 @@ def getFieldMessage(field){
     }
 }
 
-// ========================================================================================================
 def getLogFields(definitionName) {
-	log.info("[\$log] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
-
-	// Obtém detalhes da definição
-	def definitionEncoded = URLEncoder.encode(definitionName, "utf-8").replace("+", "%20")
-	def resp = actionPacks.rmRest.get( "recordm/definitions/name/${definitionEncoded}".toString(), [:], "");
-	JSONObject definition = new JSONObject(resp);
-
-	def fieldsSize = definition.fieldDefinitions.length();
-
-	def fields = [:]
-	(0..fieldsSize-1).each { index ->
-		def fieldDefinition  = definition.fieldDefinitions.getJSONObject(index)
-		def fieldDescription = fieldDefinition.get("description")
-		def fieldDefId       = fieldDefinition.get("id")
-		def fieldName        = fieldDefinition.get("name");
-		fields[fieldDefId]   = [name:fieldName, description: fieldDescription]
-	}
+    // Obtém detalhes da definição
+    def definitionEncoded = URLEncoder.encode(definitionName, "utf-8").replace("+", "%20")
+    def resp = actionPacks.rmRest.get( "recordm/definitions/name/${definitionEncoded}".toString(), [:], "");
+    JSONObject definition = new JSONObject(resp);
+
+    def fieldsSize = definition.fieldDefinitions.length();
+
+    def fields = [:]
+    (0..fieldsSize-1).each { index ->
+        def fieldDefinition  = definition.fieldDefinitions.getJSONObject(index)
+        def fieldDescription = fieldDefinition.get("description")
+        def fieldDefId       = fieldDefinition.get("id")
+        def fieldName        = fieldDefinition.get("name");
+        fields[fieldDefId]   = [name:fieldName, description: fieldDescription]
+    }
 
-	// Finalmente obtém a lista de campos que é necessário calcular
-	def auditFields = [];
-	fields.each { fieldId,field -> 
-		def matcher = field.description.toString() =~ /[$]log\(([^(]+),\s*([^(]+)\)/
-		if(matcher) {
-			def sourceField = matcher[0][1]
-			def stateField = matcher[0][2]
-			auditFields << [name: field.name, sourceField : sourceField, stateField : stateField]
-		}
-	}
-	log.info("[\$log] Update 'logFields' for '$definitionName': $auditFields");
-	log.info("[\$log] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
-	return auditFields
+    // Finalmente obtém a lista de campos que é necessário calcular
+    def auditFields = [];
+    fields.each { fieldId,field -> 
+        def matcher = field.description.toString() =~ /[$]log\(([^(]+),\s*([^(]+)\)/
+        if(matcher) {
+            def sourceField = matcher[0][1]
+            def stateField = matcher[0][2]
+            auditFields << [name: field.name, sourceField : sourceField, stateField : stateField]
+        }
+    }
+    log.info("[\$log] Update 'logFields' for '$definitionName': $auditFields");
+    return auditFields
 }

package/templates/keywords/log/package.json

@@ -0,0 +1,3 @@
+{
+  "version": "1.0.0"
+}

package/templates/keywords/styleResults/package.json

@@ -0,0 +1,3 @@
+{
+  "version": "1.0.0"
+}