cob-cli 2.5.0 → 2.6.1

package/customizations/frontend.common.js

@@ -10,6 +10,6 @@ exports.option = {
       const { mergeFiles } = require("../lib/task_lists/customize_mergeFiles");
       const target = "./recordm/customUI/"
       await copy("../../templates/frontend/common/",target)
-      await mergeFiles()
+      await mergeFiles("Frontend.Common")
   }
-}
+}

package/customizations/frontend.formatList.currency.js

@@ -0,0 +1,17 @@
+exports.option = { 
+  name: 'FormatCurrency - Make $style[currency] available on definitions', 
+  short: "Simple",
+  questions: [
+      require("../lib/task_lists/customize_questions").definitionNameQuestion
+  ],
+  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/"
+      let substitutions = {"__DEFINITION__": answers.name}
+      await copy("../../templates/frontend/formatList/currency/",target, substitutions)
+      await mergeFiles("frontend.formatList.currency.js: " + answers.name )
+  }
+}

package/customizations/frontend.formatList.js

@@ -0,0 +1,13 @@
+exports.option = {
+  name: 'FormatList - Add classes to change the style of specified columns in search results', 
+  short: "FormatList",
+  followUp: [ {
+    type: 'list',
+    name: 'choosenFollowUp',
+    message: 'Select one?',
+    choices: [
+        require("./frontend.formatList.currency").option//,
+        // require("./frontend.formatList.percentage").option
+    ]}
+  ]
+}

package/customizations/frontend.js

@@ -6,7 +6,8 @@ exports.option = {
     name: 'choosenFollowUp',
     message: 'Select one?',
     choices: [
-        require("./frontend.common").option
+        require("./frontend.common").option,
+        require("./frontend.formatList").option
     ]}
   ]
 }

package/customizations/keywords.audit.js

@@ -0,0 +1,17 @@
+exports.option = {
+  name: 'Audit - Allows for $user in definitions (https://learning.cultofbits.com/docs/cob-platform/admins/managing-information/available-customizations/audit/)', 
+  short: "Audit",
+  questions: [
+  ],
+  customization: async function (answers) {
+      console.log("\nApplying Audit 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/audit/frontend",fe_target)
+      const be_target = "./integrationm/"
+      await copy("../../templates/keywords/audit/backend",be_target)
+      await mergeFiles("Keyword.Audit")
+  }
+}

package/customizations/keywords.calc.js

@@ -0,0 +1,17 @@
+exports.option = {
+  name: 'Calc - Allows for $calc in definitions (https://learning.cultofbits.com)', 
+  short: "Calc",
+  questions: [
+  ],
+  customization: async function (answers) {
+      console.log("\nApplying Calc 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/calc/frontend",fe_target)
+      const be_target = "./integrationm/"
+      await copy("../../templates/keywords/calc/backend/",be_target)
+      await mergeFiles("Keyword.Calc")
+  }
+}

package/customizations/keywords.js

@@ -0,0 +1,13 @@
+exports.option = {
+  name: 'Keywords - Add a keyword for use in definitions (https://learning.cultofbits.com)', 
+  short: "Keywords",
+  followUp: [ {
+    type: 'list',
+    name: 'choosenFollowUp',
+    message: 'Select one?',
+    choices: [
+        require("./keywords.calc").option,
+        require("./keywords.audit").option
+    ]}
+  ]
+}

package/lib/commands/customize.js

@@ -19,6 +19,7 @@ async function customize(args) {
           require("../../customizations/dashboard").option,
           require("../../customizations/frontend").option,
           require("../../customizations/backend").option,
+          require("../../customizations/keywords").option,
           require("../../customizations/importer").option,
         ]  
       }]  

package/lib/task_lists/customize_copy.js

@@ -1,23 +1,46 @@
 const ncp = require('ncp');
 const path = require('path');
-var fs = require('fs');
+const {Transform} = require('stream')
 
 // https://www.npmtrends.com/copyfiles-vs-cpx-vs-ncp-vs-npm-build-tools
 // https://www.npmjs.com/package/ncp
 // https://www.npmjs.com/package/copyfiles
 
-function copy(source, target) {
-    console.log("  Copying template files...")
-    return new Promise(resolve => {
+function copy(source, target, substitutions = {}) {
+    console.log("  Copying template files to '" + target + "'...")
+    return new Promise(async (resolve) => {
         // Source is on cob-cli repo and Destination on the server repo
-        ncp(path.resolve(__dirname,source) , target, { clobber: true, filter: (src) => src.match(/node_modules/) == null }, (error) => {
-            if (error) {
-                // Error is an array of problems
-                resolve(error.map(e => e.message).join("\n"));
-            } else {
-                resolve();
+        await ncp(path.resolve(__dirname,source),
+            target, 
+            { 
+                clobber: true,
+                filter: (src) => src.match(/node_modules/) == null,
+                transform(read, write) {
+                    const replaceVars = new Transform({
+                        transform: (chunk, encoding, done) => done(null,chunk.toString().replace(/__.+__/g, m => substitutions[m]))
+                    }) 
+                    read.pipe(replaceVars).pipe(write)
+                }
+            },
+            (error,x) => {
+                if (error) {
+                    // Error is an array of problems
+                    resolve(error.map(e => e.message).join("\n"));
+                } else {
+                    resolve();
+                }
             }
-        });
+        );
+        
+        const { renameSync } = require('fs');
+        const fg = require('fast-glob');
+
+        const files = await fg(['**/*.__*__.*'], { onlyFiles: true, dot: true });        
+        files
+          .forEach(file => {
+            if(file.match(/__MERGE__/)) return
+            renameSync(file, file.replace(/__.+__/g, m => substitutions[m]));
+          });        
     });
 }
 exports.copy = copy;

package/lib/task_lists/customize_mergeFiles.js

@@ -1,21 +1,22 @@
 
-async function mergeFiles() {
+async function mergeFiles(block) {
   const fg = require('fast-glob');
   const fs = require('fs-extra');
   const mergeFiles = await fg(['**/*.__MERGE__.*'], { onlyFiles: false, dot: true });
   for (let mergeFile of mergeFiles) {
     let prodFile = mergeFile.replace(/\.__MERGE__/, "");
+    let blockMark = (block == undefined ? "" : block)
     if (!fs.existsSync(prodFile)) {
       // If prod file does not exist creates it
       console.log("  Creating " + prodFile)
       fs.closeSync(fs.openSync(prodFile, 'w'));
     } else {
-      console.log("  Merging " + prodFile)
+      console.log("  Merging " + prodFile + " " + block)
     }
     let prodFileContent = fs.readFileSync(prodFile).toString();
     let mergeFileContent = fs.readFileSync(mergeFile).toString();
-    let startStr = '\n/* COB-CLI START ' + mergeFile + ' */ \n';
-    let endStr = '\n/* COB-CLI END ' + mergeFile + ' */ \n';
+    let startStr = '/* COB-CLI START Customization ' + blockMark + ' */\n';
+    let endStr = '\n/* COB-CLI END Customization ' + blockMark + ' */\n';
 
     if (prodFileContent.indexOf(startStr) < 0) {
       // If previous customization does not exist

package/lib/task_lists/customize_questions.js

@@ -1,3 +1,10 @@
+exports.definitionNameQuestion = {
+  type: 'input',
+  name: 'name',
+  message: 'What\'s the name of the definition?',
+  description: 'the name of the definition listing to customize'
+};
+
 exports.dashboardNameQuestion = {
   type: 'input',
   name: 'name',
@@ -30,4 +37,4 @@ exports.dashboardNameQuestion2  = {
 
     return 'Only letters and numbers name, at least one';
   }
-};
+};

package/lib/task_lists/test_otherFilesContiousReload.js

@@ -64,7 +64,7 @@ async function otherFilesContiousReload(cmdEnv) {
         let productDir = resolveCobPath(cmdEnv.server, "serverLive", product).split(":")[1];
         let productScopeFilePath = changedFile.substring(changedFile.indexOf("/") + 1); // remove o directorio inicial do producto
 
-        let isRemoteFile = await execa('ssh', [cmdEnv.server, "[[ -f " + productDir + productScopeFilePath + " ]] && echo 'file' || echo '' " ])
+        let isRemoteFile = () => execa('ssh', [cmdEnv.server, "[[ -f " + productDir + productScopeFilePath + " ]] && echo 'file' || echo '' " ])
             .then( r => {
                 return r.stdout == "file"
             }).catch( () => {
@@ -77,8 +77,7 @@ async function otherFilesContiousReload(cmdEnv) {
         } catch {}    
 
         if (
-            (isLocalFile || isRemoteFile)
-            && changedFile.indexOf("/customUI/") < 0
+            changedFile.indexOf("/customUI/") < 0
             && changedFile.indexOf("/node_modules/") < 0
             && !changedFile.startsWith(".git")
             && !changedFile.startsWith(".idea")
@@ -86,6 +85,7 @@ async function otherFilesContiousReload(cmdEnv) {
             && !changedFile.endsWith(".swp")
             && !changedFile.endsWith(".swap")
             && changedFile.indexOf(IN_PROGRESS_TEST_FILE) < 0
+            && (isLocalFile || await isRemoteFile())
         ) {
             try {
                 await addFileToCurrentTest(cmdEnv.server, changedFile, changedFiles, " Syncing ".bgRed.bold + " ", restoreChanges );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cob-cli",
-  "version": "2.5.0",
+  "version": "2.6.1",
   "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/frontend/formatList/currency/css/_format_currency.css

@@ -0,0 +1,11 @@
+.currency_negative {
+	color:red;
+}
+.currency_positive {
+	color:green;
+}
+
+.currency_negative::after,
+.currency_positive::after {
+	content: ' €';
+}

package/templates/frontend/formatList/currency/css/customizations.__MERGE__.css

@@ -0,0 +1 @@
+@import "_format_currency.css";

package/templates/frontend/formatList/currency/js/cob/_format_currency.__DEFINITION__.js

@@ -0,0 +1,13 @@
+const DEFINITION = "__DEFINITION__";
+
+cob.custom.customize.push(function (core, utils, ui) {
+    core.customizeAllColumns(DEFINITION, (node, esDoc, colDef) => {
+        // Test $style[currency], by it self or with other styles 
+        if(/\$style\[([^,]+,)*currency(,[^,]+)*\]/.exec(colDef.fieldDefDescription) != null) {
+            let value = esDoc[colDef.field] ? esDoc[colDef.field][0] : null
+            if(value) {
+                node.classList.add((value[0] === "-") ? "currency_negative" : "currency_positive")
+            }
+        }
+    })
+})

package/templates/frontend/formatList/currency/js/customizations2.__MERGE__.js

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

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

@@ -0,0 +1,82 @@
+import groovy.transform.Field
+import org.codehaus.jettison.json.JSONObject
+
+import com.google.common.cache.*
+import java.util.concurrent.TimeUnit
+
+// ========================================================================================================
+@Field static cacheOfAuditFieldsForDefinition = CacheBuilder.newBuilder()
+        .expireAfterWrite(5, TimeUnit.MINUTES)
+        .build();
+
+if (msg.product == "recordm-definition") cacheOfAuditFieldsForDefinition.invalidate(msg.type)
+def auditFields = cacheOfAuditFieldsForDefinition.get(msg.type, { getAuditFields(msg.type) })
+
+// ========================================================================================================
+
+if (auditFields.size() > 0
+	&& msg.product == "recordm"
+	&& msg.user != "integrationm"
+	&& msg.action =~ "add|update" ) {
+
+	def updates = updateUser(auditFields,msg.instance.fields)
+    def result = actionPacks.recordm.update(msg.type, "recordmInstanceId:" + msg.instance.id, updates);
+	/**/log.info("[\$audit] ACTUALIZADA '${msg.type}' {{id:${msg.instance.id}, result:${result}, updates: ${updates}}}");
+}
+
+// ========================================================================================================
+def updateUser(auditFields,instanceFields) {
+	def userm = actionPacks.get("userm");
+	def updates = [:]
+	auditFields.each { auditField ->
+		if( auditField.op == "creator" && msg.action == "update" && msg.value(auditField.name) != null) return
+		if( auditField.args == "usermRef") {
+			updates << [(auditField.name) : 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
+			if(msg.action == 'update' && !msg.diff) return // Only continues if there is at least one change
+			updates << [(auditField.name) : "" + msg._timestamp_]
+		}
+	}
+	return updates
+}
+
+// ========================================================================================================
+def getAuditFields(definitionName) {
+	/**/log.info("[\$audit] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
+	/**/log.info("[\$audit] Update auditFields for $definitionName ... ");
+
+	// 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 =~ /[$]audit\.(creator|updater)\.(username|usermRef|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] fields for '$definitionName': $auditFields");
+	/**/log.info("[\$audit] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
+	return auditFields
+}

package/templates/keywords/audit/frontend/js/cob/_audit.js

@@ -0,0 +1,20 @@
+//----------------- $audit  ------------------------
+cob.custom.customize.push(function (core, utils, ui) {
+    core.customizeAllInstances((instance, presenter) => 
+    {
+        let userFPs = presenter.findFieldPs( fp => /[$]audit\.(creator|updater)\.(username|usermRef|time)/.exec(fp.field.fieldDefinition.description) )
+        userFPs.forEach( fp => {
+            fp.disable()
+            if(!instance.isNew() || presenter.isGroupEdit()) return //Only update if it's on create interface (updates will only be changed by the backend)
+            if(/[$]audit\.(creator|updater)\.username/.exec(fp.field.fieldDefinition.description)) {
+                fp.setValue(core.getCurrentLoggedInUser())
+            }
+            if(/[$]audit\.(creator|updater)\.usermRef/.exec(fp.field.fieldDefinition.description)) {
+                fp.setValue(core.getCurrentLoggedInUserUri())
+            }
+            if(/[$]audit\.(creator|updater)\.time/.exec(fp.field.fieldDefinition.description)) {               
+                fp.setValue(Date.now())
+            }
+        })
+    })
+});

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

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

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

@@ -0,0 +1,160 @@
+import groovy.transform.Field
+import org.codehaus.jettison.json.JSONObject
+
+import java.math.RoundingMode;
+
+import com.google.common.cache.*
+import java.util.concurrent.TimeUnit
+
+// ========================================================================================================
+@Field static cacheOfCalcFieldsForDefinition = CacheBuilder.newBuilder()
+        .expireAfterWrite(5, TimeUnit.MINUTES)
+        .build();
+
+if (msg.product == "recordm-definition") cacheOfCalcFieldsForDefinition.invalidate(msg.type)
+def calculationFields = cacheOfCalcFieldsForDefinition.get(msg.type, { getAllCalculationFields(msg.type) })
+
+// ========================================================================================================
+if (calculationFields.size() > 0
+	&& msg.product == "recordm"
+	&& msg.user != "integrationm"
+	&& msg.action =~ "add|update" ){
+
+	def updates = executeCalculations(calculationFields, msg.instance.fields)
+    def result = actionPacks.recordm.update(messageMap.type, "recordmInstanceId:" + messageMap.instance.id, updates);
+	log.info("[\$calc] ACTUALIZADA '${messageMap.type}' {{id:${messageMap.instance.id}, result:${result}, updates: ${updates}}}");
+}
+
+// ==================================================
+def getCalculationOperation(fieldDescription) {
+	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 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 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()
+}
+
+// ==================================================
+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 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()
+}
+
+// ========================================================================================================
+def getAllCalculationFields(definitionName) {
+	log.info("[\$calc] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
+	log.info("[\$calc] update calculationFields for $definitionName... ");
+
+	// 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 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] fields for '$definitionName': $calculationFields");	
+	log.info("[\$calc] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
+	return calculationFields
+}

package/templates/keywords/calc/frontend/js/cob/_calc.js

@@ -0,0 +1,183 @@
+//----------------- Enable do $calc  ------------------------
+cob.custom.customize.push(function (core, utils, ui) {
+    core.customizeAllInstances((instance, presenter) => calc_automation(instance, presenter))
+});
+
+function calc_automation(instance, presenter) {
+    registerAndExecuteCalculation()
+
+    //=========================================================
+    // Support functions
+    //=========================================================
+    function registerAndExecuteCalculation() {
+        registerExecuteCalculationsOnChanges()
+        executeCalculations()
+    }
+
+    //=========================================================
+    function getAllCalculationsFields() {
+        return presenter
+            .findFieldPs( fp => /[$]calc\.(.*)/.exec(fp.field.fieldDefinition.description) )
+            .map( calculationFp => {
+                calculationFp.disable()
+                return {
+                    fp: calculationFp,
+                    op: getCalculationOperation(calculationFp),
+                    args: getCalculationArguments(calculationFp)
+                }
+            })
+
+        //=========================================================
+        function getCalculationOperation(calculationFp) {
+            let fieldDescription = calculationFp.field.fieldDefinition.description
+            let expr = fieldDescription.substr(fieldDescription.indexOf("$calc.")+6)
+            let matcher = /([^(]+)/
+            let op = expr.match(matcher)[1]
+            return op
+        }
+
+        //=========================================================
+        function getCalculationArguments(calculationFp) {
+            let argNames = getCalculationArgNames(calculationFp)
+            return argNames
+                .map( argName => isNaN(argName)
+                    ? getAllAplicableFpsForVarName(calculationFp, argName) // É uma variável, retorna todos os fp associados
+                    : argName * 1 // é uma constante numérica
+                )
+                .flat()
+
+            //=========================================================
+            function getCalculationArgNames(calculationFp) {
+                let fieldDescription = calculationFp.field.fieldDefinition.description;
+                let expr = fieldDescription.substr( fieldDescription.indexOf("$calc.") + 6 );
+                let matcher = /[^(]+\(([^(]+)\)/;
+                let argNamesArray = expr.match(matcher)[1].split(",");
+                return argNamesArray;
+            }
+
+            //=========================================================
+            function getAllAplicableFpsForVarName(calculationFp, varName) {
+                let result
+                 if(varName === "previous") {
+                    let todosCampos = presenter.findFieldPs(() => true).map(fp => fp.field.id )
+                    result = presenter.findFieldPs(fp => fp.field.id === todosCampos[todosCampos.indexOf(calculationFp.field.id)-1])
+                } else {
+                    result = presenter.findFieldPs( fp => fp.field.fieldDefinition.description && fp.field.fieldDefinition.description.includes("$"+varName))
+                }
+                return result
+            }
+        }
+    }
+
+    //=========================================================
+    function registerExecuteCalculationsOnChanges() {
+        let calculations = getAllCalculationsFields()
+        // eventos de field changes de qualquer das variáveis (ou seja, sempre que o argumento não for um número)
+        calculations.forEach(
+            calculation => calculation.args.forEach( arg => {
+                if(isNaN(arg)) {
+                    if(arg.field.fieldDefinition.duplicable) {
+                        //O caso de campos duplicáveis é diferente porque é necessário voltar a registar tudo e só depois calcular
+                        presenter.onFieldChange(arg.field.fieldDefinition.name, () => registerAndExecuteCalculation() )
+                    } else {
+                        //No caso de campos normais só é necessário calcular tudo quando uma dependência muda
+                        presenter.onFieldChange(arg, () => executeCalculations() )
+                    }
+                }
+            })
+        )
+    }
+
+    //=========================================================
+    function executeCalculations() {
+        console.group("[Calculations] eval all $calc");
+        let calculations = getAllCalculationsFields() // Get fresh values
+        let t0 = performance.now();
+        calculations.forEach( calculation => {
+            let t0parcial = performance.now();
+            let novoResultado = "" + evaluateExpression(calculation)
+            if(calculation.fp.getValue() != novoResultado ) {
+                calculation.fp.setValue(novoResultado)
+                console.groupCollapsed("[Calculations] updated field ", calculation.fp.field.fieldDefinition.id, " '", calculation.fp.field.fieldDefinition.name, "' with ",novoResultado)
+                console.debug("[Calculations]", calculation.op)
+                console.debug("[Calculations]", calculation.args.map(arg => isNaN(arg) ? arg.field.fieldDefinition : arg))
+                console.debug("[Calculations] subcalc took " + (performance.now() - t0parcial) + " milliseconds.");
+                console.groupEnd()
+
+            }
+        })
+        console.debug("[Calculations] total calc took " + (performance.now() - t0) + " milliseconds.");
+        console.groupEnd();
+        return ;
+
+        //=========================================================
+        function evaluateExpression(calculation) {
+            // Obter valores para variaveis
+            let values = calculation.args.map(arg =>
+                arg.getValue
+                ? isNaN(arg.getValue() * 1)
+                    ? 0
+                    : parseFloat(arg.getValue())
+                : arg
+            );
+
+            // Realizar operação
+            let resultado = new BigDecimal(0)
+            if (calculation.op === "multiply" && values.length > 0) {
+                resultado = new BigDecimal(1);
+                values.forEach(value => resultado = resultado.multiply(new BigDecimal(value)))
+
+            } else if (calculation.op === "divide" && values.length === 2 && values[1] !== 0 ) {
+                resultado = new BigDecimal(values[0]);
+                resultado = resultado.divide(new BigDecimal(values[1]))
+
+            } else if (calculation.op === "sum") {
+                values.forEach(value => resultado = resultado.add(new BigDecimal(value)))
+
+            } else if (calculation.op === "subtract" && values.length === 2) {
+                resultado = new BigDecimal(values[0]);
+                resultado = resultado.subtract(new BigDecimal(values[1]))
+            }
+            return resultado
+        }
+    }
+}
+
+// From https://stackoverflow.com/questions/16742578/bigdecimal-in-javascript
+class BigDecimal {
+    // Configuration: constants
+    static DECIMALS = 8; // number of decimals on all instances
+    static ROUNDED = true; // numbers are truncated (false) or rounded (true)
+    static SHIFT = BigInt("1" + "0".repeat(BigDecimal.DECIMALS)); // derived constant
+    constructor(value) {
+        if (value instanceof BigDecimal) return value;
+        let [ints, decis] = String(value).split(".").concat("");
+        this._n = BigInt(ints + decis.padEnd(BigDecimal.DECIMALS, "0")
+                                     .slice(0, BigDecimal.DECIMALS)) 
+                  + BigInt(BigDecimal.ROUNDED && decis[BigDecimal.DECIMALS] >= "5");
+    }
+    static fromBigInt(bigint) {
+        return Object.assign(Object.create(BigDecimal.prototype), { _n: bigint });
+    }
+    add(num) {
+        return BigDecimal.fromBigInt(this._n + new BigDecimal(num)._n);
+    }
+    subtract(num) {
+        return BigDecimal.fromBigInt(this._n - new BigDecimal(num)._n);
+    }
+    static _divRound(dividend, divisor) {
+        return BigDecimal.fromBigInt(dividend / divisor 
+            + (BigDecimal.ROUNDED ? dividend  * 2n / divisor % 2n : 0n));
+    }
+    multiply(num) {
+        return BigDecimal._divRound(this._n * new BigDecimal(num)._n, BigDecimal.SHIFT);
+    }
+    divide(num) {
+        return BigDecimal._divRound(this._n * BigDecimal.SHIFT, new BigDecimal(num)._n);
+    }
+    toString() {
+        const s = this._n.toString().padStart(BigDecimal.DECIMALS+1, "0");
+        const decimals = s.slice(-BigDecimal.DECIMALS).replace(/\.?0+$/, "")
+        return s.slice(0, -BigDecimal.DECIMALS) + (decimals ? ".":"") + decimals;
+    }
+}

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

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