WIP for supporting dataLoader use for a computed #208

Author: chrisala

grails-app/assets/javascripts/forms-knockout-bindings.js

@@ -1160,5 +1160,21 @@
         }
     };
 
+    ko.extenders.dataLoader = function(target, options) {
+
+        var dataLoader = new ecodata.forms.dataLoader(target.context, target.config);
+        var dataLoaderConfig = target.get('computed');
+        if (!dataLoaderConfig) {
+            throw "This extender can only be used with the metadata extender";
+        }
+        var dependencyTracker = ko.computed(function () {
+            return dataLoader.prepop(dataLoaderConfig).done( function(data) {
+                target(data);
+            });
+        });
+        //dependencyTracker.subscribe(function() { console.log("bananas")})
+        return target;
+    }
+
 })();
 

grails-app/assets/javascripts/forms.js

@@ -329,14 +329,14 @@ function orEmptyArray(v) {
         var expressionCache = {};
 
         function evaluateInternal(expression, context) {
-            var parsedExpression = expressionCache[expression];
-            if (!parsedExpression) {
-                parsedExpression = parser.parse(expression);
-                expressionCache[expression] = parsedExpression;
-            }
+                var parsedExpression = expressionCache[expression];
+                if (!parsedExpression) {
+                    parsedExpression = parser.parse(expression);
+                    expressionCache[expression] = parsedExpression;
+                }
 
-            var variables = parsedExpression.variables();
-            var boundVariables = bindVariables(variables, context);
+                var variables = parsedExpression.variables();
+                var boundVariables = bindVariables(variables, context);
 
             var result;
             try {
@@ -655,18 +655,23 @@ function orEmptyArray(v) {
         self.getPrepopData = function (conf) {
             var source = conf.source;
             if (source.url) {
+                var failedValidation = false;
                 var url = (config.prepopUrlPrefix || window.location.href) + source.url;
                 var params = [];
                 _.each(source.params || [], function(param) {
                     var value;
                     if (param.type && param.type == 'computed') {
                         // evaluate the expression against the context.
                         value = ecodata.forms.expressionEvaluator.evaluateUntyped(param.expression, context);
+                        if (param.required && !value) {
+                            failedValidation = true;
+                        }
                     }
                     else {
                         // Treat it as a literal
                         value = param.value;
                     }
+
                     // Unroll the array to prevent jQuery appending [] to the array typed parameter name.
                     if (_.isArray(value)) {
                         for (var i=0; i<value.length; i++) {
@@ -677,6 +682,9 @@ function orEmptyArray(v) {
                         params.push({name:param.name, value: value});
                     }
                 });
+                if (failedValidation) {
+                    return $.Deferred().resolve(source.defaultValue || null);
+                }
                 return $.ajax(url, {data:params, dataType:source.dataType || 'json'});
             }
             var deferred = $.Deferred();
@@ -690,6 +698,14 @@ function orEmptyArray(v) {
             else if (source && source.hasOwnProperty('literal')) {
                 data = source['literal'];
             }
+
+            // Support for converting array typed values to lookup tables.
+            // e.g. MERIT has a list of data sets that we want to be selectable from a list then
+            // the full data set to be available for lookup by id (using the lookupTable data type)
+            if (source['index-by']) {
+                data = _.indexBy(data, source['index-by'])
+            }
+
             deferred.resolve(data);
             return deferred;
         };
@@ -844,6 +860,7 @@ function orEmptyArray(v) {
                     }
                 }
                 else if (metadata.constraints.type == 'pre-populated') {
+                    console.log("******************** Encountered pre-pop constraints for "+self.getName()+"***************************************")
                     var defaultConstraints = metadata.constraints.defaults || [];
                     var constraintsObservable = ko.observableArray(defaultConstraints);
                     if (!includeExcludeDefined) {
@@ -898,14 +915,15 @@ function orEmptyArray(v) {
             self.displayOptions = metadata.displayOptions;
         }
         self.load = function(data) {
+            console.log("Loading data for "+self.getName()+" : "+data)
+            self(data);
             if (constraintsInititaliser) {
                 constraintsInititaliser.always(function() {
+                    console.log("Re-Loading data for "+self.getName()+" : "+data)
                     self(data);
                 })
             }
-            else {
-                self(data);
-            }
+
         }
     };
 

grails-app/assets/javascripts/knockout-utils.js

@@ -91,9 +91,16 @@
             return (typeof root.modelAsJSON === 'function') ? root.modelAsJSON() : ko.toJSON(root);
         };
         var _initialState = ko.observable(getRepresentation());
+        console.log("****************** Initial state ******************")
+        console.log( _initialState())
 
         result.isDirty = ko.pureComputed(function () {
+
             var dirty = _isInitiallyDirty() || _initialState() !== getRepresentation();
+            if (dirty) {
+                console.log("******************* new state *******************")
+                console.log(getRepresentation())
+            }
             return dirty;
         });
         if (rateLimit) {
@@ -102,6 +109,8 @@
 
         result.reset = function () {
             _initialState(getRepresentation());
+            console.log("****************** Reset initial state ******************")
+            console.log( _initialState())
             _isInitiallyDirty(false);
         };
 
@@ -137,14 +146,16 @@
 
                 //just for subscriptions
                 getRepresentation();
-
+                console.log("****************** Initial state ******************")
+                console.log(getRepresentation())
                 //next time return true and avoid ko.toJS
                 _initialized(true);
 
                 //on initialization this flag is not dirty
                 return false;
             }
-
+            console.log("****************** New state ******************")
+            console.log(getRepresentation())
             //on subsequent changes, flag is now dirty
             return true;
         });

grails-app/taglib/au/org/ala/ecodata/forms/ModelJSTagLib.groovy

@@ -136,7 +136,7 @@ class ModelJSTagLib {
         else if (mod.dataType == 'time') {
             timeViewModel(ctx)
         }
-        else if (mod.computed) {
+        else if (mod.computed && !mod.computed.source) {
             computedModel(ctx)
         }
         else if (mod.dataType == 'text') {
@@ -572,6 +572,9 @@ class ModelJSTagLib {
         if (requiresMetadataExtender(ctx.dataModel)) {
             extenders.add("{metadata:{metadata:self.dataModel['${ctx.fieldName()}'], context:self.\$context, config:config}}")
         }
+        if (ctx.dataModel.computed?.source) {
+            extenders.add("{dataLoader:true}")
+        }
 
         extenders.each {
             extenderJS += ".extend(${it})"
@@ -581,7 +584,7 @@ class ModelJSTagLib {
     }
 
     private boolean requiresMetadataExtender(Map dataModel) {
-        dataModel.dataType == 'feature' || dataModel.behaviour || dataModel.warning || dataModel.constraints || dataModel.displayOptions || (dataModel.validate instanceof List) || dataModel.scores
+        dataModel.dataType == 'feature' || dataModel.behaviour || dataModel.warning || dataModel.constraints || dataModel.displayOptions || (dataModel.validate instanceof List) || dataModel.scores || dataModel.computed?.source
 
     }
 

src/main/groovy/au/org/ala/ecodata/forms/ComputedValueRenderer.groovy

@@ -47,40 +47,54 @@ class ComputedValueRenderer {
     }
 
     def computedObservable(model, propertyContext, dependantContext, out) {
-        out << INDENT*5 << "${propertyContext}.${model.name} = ko.computed(function () {\n"
+
+        boolean needsDefer = model.computed.defer
+        String endFunction = "});\n"
+        String computedParams = "function ()"
+        if (needsDefer) {
+            computedParams = "{deferEvaluation:true, read:function ()"
+            endFunction = "}});\n"
+        }
+
+        out << INDENT*5 << "${propertyContext}.${model.name} = ko.computed($computedParams {\n"
 
         if (model.computed.expression) {
             renderJSExpression(model, "self", out)
         }
         else {
-            // must be at least one dependant
-            def numbers = []
-            def checkNumberness = []
-            model.computed.dependents.each {
-                def ref = it
-                def path = dependantContext
-                if (ref.startsWith('$')) {
-                    ref = ref[1..-1]
-                    path = "self.data"
-                }
-                numbers << "Number(${path}.${ref}())"
-                checkNumberness << "isNaN(Number(${path}.${ref}()))"
-            }
-            out << INDENT * 6 << "if (" + checkNumberness.join(' || ') + ") { return 0; }\n"
-            if (model.computed.operation == 'divide') {
-                // can't divide by zero
-                out << INDENT * 6 << "if (${numbers[-1]} === 0) { return 0; }\n"
-            }
-            def expression = numbers.join(" ${operators[model.computed.operation]} ")
-            if (model.computed.rounding) {
-                expression = "neat_number(${expression},${model.computed.rounding})"
-            }
-            out << INDENT * 6 << "return " + expression + ";\n"
+            renderLegacyComputed(model, dependantContext, out)
         }
-        out << INDENT * 5 << "});\n"
 
+        out << INDENT*5 << endFunction
     }
 
+    private void renderLegacyComputed(model, dependantContext, out) {
+        // must be at least one dependant
+        def numbers = []
+        def checkNumberness = []
+        model.computed.dependents.each {
+            def ref = it
+            def path = dependantContext
+            if (ref.startsWith('$')) {
+                ref = ref[1..-1]
+                path = "self.data"
+            }
+            numbers << "Number(${path}.${ref}())"
+            checkNumberness << "isNaN(Number(${path}.${ref}()))"
+        }
+        out << INDENT * 6 << "if (" + checkNumberness.join(' || ') + ") { return 0; }\n"
+        if (model.computed.operation == 'divide') {
+            // can't divide by zero
+            out << INDENT * 6 << "if (${numbers[-1]} === 0) { return 0; }\n"
+        }
+        def expression = numbers.join(" ${operators[model.computed.operation]} ")
+        if (model.computed.rounding) {
+            expression = "neat_number(${expression},${model.computed.rounding})"
+        }
+        out << INDENT * 6 << "return " + expression + ";\n"
+    }
+
+
     def computedViewModel(out, attrs, model, propertyContext, dependantContext) {
         computedViewModel(out, attrs, model, propertyContext, dependantContext, null)
     }