diff --git a/grails-app/assets/javascripts/forms-knockout-bindings.js b/grails-app/assets/javascripts/forms-knockout-bindings.js
index 951b11b6..5707d602 100644
--- a/grails-app/assets/javascripts/forms-knockout-bindings.js
+++ b/grails-app/assets/javascripts/forms-knockout-bindings.js
@@ -679,7 +679,10 @@
var options = _.defaults(valueAccessor() || {}, defaults);
$(element).select2(options).change(function(e) {
- model($(element).val());
+ if (ko.isWritableObservable(model)) { // Don't try and write the value to a computed.
+ model($(element).val());
+ }
+
});
if (options.preserveColumnWidth) {
@@ -1173,7 +1176,54 @@
});
}); // This is a computed rather than a pureComputed as it has a side effect.
return target;
- }
+ };
+
+ ko.bindingHandlers['triggerPrePopulate'] = {
+ 'update': function (element, valueAccessor, allBindings, viewModel, bindingContext) {
+
+
+ var dataModelItem = valueAccessor();
+ var behaviours = dataModelItem.get('behaviour');
+ for (var i = 0; i < behaviours.length; i++) {
+ var behaviour = behaviours[i];
+
+ if (behaviour.type == 'pre_populate') {
+ var config = behaviour.config;
+ var dataLoaderContext = dataModelItem.context;
+
+ var dataLoader = new ecodata.forms.dataLoader(dataLoaderContext, dataModelItem.config);
+
+ var dependencyTracker = ko.computed(function () {
+ dataModelItem(); // register dependency on the observable.
+ dataLoader.prepop(config).done(function (data) {
+ data = data || {};
+ var target = config.target;
+ if (!target) {
+ target = viewModel;
+ }
+ else {
+ target = dataModelItem.findNearestByName(target, bindingContext);
+ }
+ if (!target) {
+ throw "Unable to locate target for pre-population: "+target;
+ }
+ if (_.isFunction(target.loadData)) {
+ target.loadData(data);
+ } else if (_.isFunction(target.load)) {
+ target.load(data);
+ } else if (ko.isObservable(target)) {
+ target(data);
+ } else {
+ console.log("Warning: target for pre-populate is invalid");
+ }
+
+ }); // This is a computed rather than a pureComputed as it has a side effect.
+ });
+ }
+ }
+
+ }
+ };
})();
diff --git a/grails-app/assets/javascripts/forms.js b/grails-app/assets/javascripts/forms.js
index 6621d316..2c395a3a 100644
--- a/grails-app/assets/javascripts/forms.js
+++ b/grails-app/assets/javascripts/forms.js
@@ -179,6 +179,49 @@ function orEmptyArray(v) {
}
};
+ /**
+ * Traverses the model or binding context starting from a nested context and
+ * working backwards towards the root until a property with the supplied name
+ * is matched. That property is then passed to the supplied callback.
+ * Traversing backwards is simpler than forwards as we don't need to take into
+ * account repeating model values (e.g. for repeating sections and table rows)
+ * @param targetName the name of the model variable / property to find.
+ * @param context the starting context
+ * @param callback a function to invoke when the target variable is found.
+ */
+ ecodata.forms.navigateModel = function(targetName, context, callback) {
+ if (!context) {
+ return;
+ }
+ if (!_.isUndefined(context[targetName])) {
+ callback(context[targetName]);
+ }
+ // If the context is a knockout binding context, $data will be the current object
+ // being bound to the view.
+ else if (context['$data']) {
+ ecodata.forms.navigateModel(targetName, context['$data'], callback);
+ }
+ // The root data model is constructed with fields inside a nested "data" object.
+ else if (_.isObject(context['data'])) {
+ ecodata.forms.navigateModel(targetName, context['data'], callback);
+ }
+ // Try to evaluate against the parent - the bindingContext uses $parent and the
+ // ecodata.forms.DataModelItem uses parent
+ else if (context['$parent']) {
+ ecodata.forms.navigateModel(targetName, context['$parent'], callback);
+ }
+ else if (context['parent']) {
+ ecodata.forms.navigateModel(targetName, context['parent'], callback);
+ }
+ // Try to evaluate against the context - this is setup as a model / binding context
+ // variable and refers to data external to the form - e.g. the project or activity the
+ // form is related to.
+ else if (context['$context']) {
+ ecodata.forms.navigateModel(targetName, context['$context'], callback);
+ }
+
+ }
+
/**
* Helper function for evaluating expressions defined in the metadata. These may be used to compute values
* or make decisions on which constraints to apply to individual data model items.
@@ -253,6 +296,10 @@ function orEmptyArray(v) {
return _.findWhere(list, obj);
};
+ parser.functions.deepEquals = function(value1, value2) {
+ return _.isEqual(value1, value2);
+ };
+
var specialBindings = function() {
return {
@@ -296,27 +343,9 @@ function orEmptyArray(v) {
result = specialBindings[contextVariable];
}
else {
- if (!_.isUndefined(context[contextVariable])) {
- result = ko.utils.unwrapObservable(context[contextVariable]);
- }
- else {
- // The root view model is constructed with fields inside a nested "data" object.
- if (_.isObject(context['data'])) {
- result = bindVariable(variable, context['data']);
- }
- // Try to evaluate against the parent
- else if (context['$parent']) {
- // If the parent is the output model, we want to evaluate against the "data" property
- var parentContext = _.isObject(context['$parent'].data) ? context['$parent'].data : context['$parent'];
- result = bindVariable(variable, parentContext);
- }
- // Try to evaluate against the context - used when we are evaluating pre-pop data with a filter
- // expression that references a variable in the form context
- else if (context['$context']) {
- result = bindVariable(variable, context['$context']);
- }
- }
-
+ ecodata.forms.navigateModel(contextVariable, context, function(target) {
+ result = ko.utils.unwrapObservable(target);
+ });
}
return _.isUndefined(result) ? null : result;
}
@@ -334,14 +363,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 {
@@ -619,16 +648,32 @@ function orEmptyArray(v) {
if (prepopData) {
var result = prepopData;
var mapping = conf.mapping;
- if (conf.filter && conf.filter.expression) {
- if (!_.isArray(prepopData)) {
- throw "Filtering is only supported for array typed prepop data."
+
+ function postProcessPrepopData(processingFunction, processingConfig, data) {
+ if (!_.isArray(data)) {
+ throw "Filter/find is only supported for array typed prepop data."
}
- result = _.filter(result, function(item) {
- var expression = conf.filter.expression;
- var itemContext = _.extend({}, item, {$context:context, $config:config});
- return ecodata.forms.expressionEvaluator.evaluateBoolean(expression, itemContext);
+ if (!processingConfig.expression) {
+ throw "Missing expression attribute in configuration"
+ }
+ return processingFunction(data, function(item) {
+ var expression = processingConfig.expression;
+ var namespace = processingConfig['namespace'] || 'item';
+ var evalContext = {};
+ evalContext[namespace] = item;
+
+ var evalContext = _.extend(evalContext, {$context:context, $config:config});
+ return ecodata.forms.expressionEvaluator.evaluateBoolean(expression, evalContext);
});
}
+
+ if (conf.filter) {
+ result = postProcessPrepopData(_.filter, conf.filter, result);
+ }
+ else if (conf.find) {
+ result = postProcessPrepopData(_.find, conf.find, result);
+ }
+
if (mapping) {
result = self.map(mapping, result);
}
@@ -796,16 +841,46 @@ function orEmptyArray(v) {
function buildPrepopConstraints(constraintsConfig, constraintsDeferred) {
var defaultConstraints = constraintsConfig.defaults || [];
var constraintsObservable = ko.observableArray(defaultConstraints);
-
- return ko.computed(function() {
- var dataLoaderContext = _.extend({}, context, {$parent:context.parent});
- var dataLoader = ecodata.forms.dataLoader(dataLoaderContext, config);
- dataLoader.prepop(constraintsConfig.config).done(function (data) {
+ var dataLoaderContext = _.extend({}, context, {$parent:context.parent});
+ var dataLoader = ecodata.forms.dataLoader(dataLoaderContext, config);
+
+ ko.computed(function() {
+ var prepopConf = constraintsConfig.config;
+ // If the prepop needs to post process the data, we need to execute the post processing
+ // in the context of the computed so as to register any dependencies on values used in
+ // the post-processing expressions.
+ // The dataloader won't execute post processing synchronously as retrieving the data can be done
+ // via a remote call.
+ if (prepopConf.filter) {
+ ecodata.forms.expressionEvaluator.evaluate(prepopConf.filter.expression, dataLoaderContext);
+ }
+ if (prepopConf.find) {
+ ecodata.forms.expressionEvaluator.evaluate(prepopConf.filter.expression, dataLoaderContext);
+ }
+ dataLoader.prepop(prepopConf).done(function (data) {
constraintsObservable(data);
constraintsDeferred.resolve();
});
- return constraintsObservable();
});
+
+ return constraintsObservable;
+ }
+
+ /**
+ * Finds the model attribute with the specified name searching from the context of this
+ * DataModelItem if no context is supplied.
+ * This is so that for nested items we can find the nearest neighbour with the specified name. (e.g.
+ * when the model represents a repeating section or table row)
+ */
+ self.findNearestByName = function(targetName, context) {
+ if (!context) {
+ context = self.context;
+ }
+ var result = null;
+ ecodata.forms.navigateModel(targetName, context, function(target) {
+ result = target;
+ })
+ return result;
}
function attachIncludeExclude(constraints) {
diff --git a/grails-app/conf/example_models/behavioursExample.json b/grails-app/conf/example_models/behavioursExample.json
index 6d697c36..d588fa52 100644
--- a/grails-app/conf/example_models/behavioursExample.json
+++ b/grails-app/conf/example_models/behavioursExample.json
@@ -31,6 +31,47 @@
}
}
]
+ },
+ {
+ "dataType": "text",
+ "name": "item5",
+ "behaviour": [
+ {
+ "config": {
+ "source": {
+ "url": "/preview/prepopulate",
+ "params": [
+ {
+ "name": "param",
+ "type": "computed",
+ "expression": "item5"
+ },
+ {
+ "name": "item5",
+ "type": "computed",
+ "expression": "item5"
+ }
+ ]
+ },
+ "mapping": [
+ {
+ "source-path": "param",
+ "target": "item6"
+ },
+ {
+ "source-path": "item5",
+ "target": "item5"
+ }
+ ],
+ "target": "$data"
+ },
+ "type": "pre_populate"
+ }
+ ]
+ },
+ {
+ "dataType": "text",
+ "name": "item6"
}
],
"viewModel": [
@@ -69,7 +110,40 @@
"title": "Item 4"
}
]
-
+ },
+ {
+ "type": "row",
+ "items": [
+ {
+ "type": "col",
+ "items": [
+ {
+ "type": "literal",
+ "source": "Note for this example, data entered into item5 will trigger a pre-pop call and be mapped back to item5 and item6. Note that the target of the pre-pop is $data which is the current binding context (or the root object in this case). A current limitation is the load method is used, which means if the pre-pop result does not contain keys for all data in the target object, the data for missing fields will be set to undefined. A planned enhancement is to only replace data where keys in the pre-pop data exist."
+ }
+ ]
+ }
+ ]
+ },
+ {
+ "type": "row",
+ "items": [
+ {
+ "type": "col",
+ "items": [
+ {
+ "preLabel": "Item 5",
+ "source": "item5",
+ "type": "text"
+ },
+ {
+ "preLabel": "Item 6",
+ "source": "item6",
+ "type": "text"
+ }
+ ]
+ }
+ ]
}
],
"title": "Behaviours example"
diff --git a/grails-app/conf/example_models/constraintsExample.json b/grails-app/conf/example_models/constraintsExample.json
index 299837e9..8832be70 100644
--- a/grails-app/conf/example_models/constraintsExample.json
+++ b/grails-app/conf/example_models/constraintsExample.json
@@ -20,7 +20,19 @@
"type": "pre-populated",
"config": {
"source": {
- "url": "/preview/prepopulateConstraints"
+ "url": "/preview/prepopulateConstraints",
+ "params" : [
+ {
+ "name":"p1",
+ "value":"1"
+ },
+ {
+ "name": "p2",
+ "type": "computed",
+ "expression": "number1"
+ }
+
+ ]
}
},
"excludePath": "list.value1"
@@ -65,7 +77,7 @@
"items": [
{
"type": "literal",
- "source": "
This example illustrates the use of computed constraints
The 'Value 2' field will only allow each item in the dropdown to be selected once, no matter how many times 'Value 2' appears on the page.
For each selection made in a 'Value 2' field, that value will be added as a selectable option in the 'Value 3' field.
"
+ "source": "
This example illustrates the use of computed constraints
The 'Value 2' field will only allow each item in the dropdown to be selected once, no matter how many times 'Value 2' appears on the page.
For each selection made in a 'Value 2' field, that value will be added as a selectable option in the 'Value 3' field.
Note also that the constraints for 'value1' include a parameter that references a form variable. When that variable changes, the constraint pre-population is re-executed