From 8e14de2d17f1f3e76a6fbbd8d0bfdc783d24e06e Mon Sep 17 00:00:00 2001 From: Awen Saunders Date: Thu, 30 May 2024 17:04:10 +0100 Subject: [PATCH 1/3] Add initial round operator This relates to calculating an average FSS on gbv with decimal places. Right now we emit a string, but ideally this would be able to emit a float. --- app/javascript/libs/expressions/constants.js | 2 +- .../libs/expressions/operators/avg.js | 2 +- .../libs/expressions/operators/index.js | 1 + .../libs/expressions/operators/round.js | 21 +++++++++++++++++++ .../libs/expressions/utils/build-operator.js | 5 ++++- 5 files changed, 28 insertions(+), 3 deletions(-) create mode 100644 app/javascript/libs/expressions/operators/round.js diff --git a/app/javascript/libs/expressions/constants.js b/app/javascript/libs/expressions/constants.js index 4ab98b3499..cb16730110 100644 --- a/app/javascript/libs/expressions/constants.js +++ b/app/javascript/libs/expressions/constants.js @@ -2,4 +2,4 @@ export const LOGICAL_OPERATORS = Object.freeze({ NOT: "not", AND: "and", OR: "or" }); export const COMPARISON_OPERATORS = Object.freeze({ GE: "ge", GT: "gt", LE: "le", LT: "lt", EQ: "eq", IN: "in" }); -export const MATHEMATICAL_OPERATORS = Object.freeze({ SUM: "sum", AVG: "avg" }); +export const MATHEMATICAL_OPERATORS = Object.freeze({ SUM: "sum", AVG: "avg", ROUND: "round" }); diff --git a/app/javascript/libs/expressions/operators/avg.js b/app/javascript/libs/expressions/operators/avg.js index 6cd34d6b52..a13e504d71 100644 --- a/app/javascript/libs/expressions/operators/avg.js +++ b/app/javascript/libs/expressions/operators/avg.js @@ -21,6 +21,6 @@ export default expressions => ({ return prev; }, 0); - return Math.floor(sum / (count === 0 ? 1 : count)); + return sum / (count === 0 ? 1 : count); } }); diff --git a/app/javascript/libs/expressions/operators/index.js b/app/javascript/libs/expressions/operators/index.js index 03bcfe0635..8afeba8b75 100644 --- a/app/javascript/libs/expressions/operators/index.js +++ b/app/javascript/libs/expressions/operators/index.js @@ -11,3 +11,4 @@ export { default as orOperator } from "./or"; export { default as notOperator } from "./not"; export { default as sumOperator } from "./sum"; export { default as avgOperator } from "./avg"; +export { default as roundOperator } from "./round"; diff --git a/app/javascript/libs/expressions/operators/round.js b/app/javascript/libs/expressions/operators/round.js new file mode 100644 index 0000000000..8a55a33a43 --- /dev/null +++ b/app/javascript/libs/expressions/operators/round.js @@ -0,0 +1,21 @@ +// Copyright (c) 2014 - 2023 UNICEF. All rights reserved. + +import { MATHEMATICAL_OPERATORS } from "../constants"; + +export default expressions => ({ + expressions, + operator: MATHEMATICAL_OPERATORS.ROUND, + evaluate: data => { + const results = expressions.map(current => (current.evaluate ? current.evaluate(data) : current)); + + if (results.length !== 2) { + return 0; + } + try { + const rounded = results[0].toFixed(results[1]); + return rounded; + } catch (error) { + return 0; + } + } +}); diff --git a/app/javascript/libs/expressions/utils/build-operator.js b/app/javascript/libs/expressions/utils/build-operator.js index 83b10d37f6..45e2a44d14 100644 --- a/app/javascript/libs/expressions/utils/build-operator.js +++ b/app/javascript/libs/expressions/utils/build-operator.js @@ -12,7 +12,8 @@ import { orOperator, notOperator, sumOperator, - avgOperator + avgOperator, + roundOperator } from "../operators"; export default (operator, value) => { @@ -39,6 +40,8 @@ export default (operator, value) => { return sumOperator(value); case MATHEMATICAL_OPERATORS.AVG: return avgOperator(value); + case MATHEMATICAL_OPERATORS.ROUND: + return roundOperator(value); default: throw Error(`Operator ${operator} is not valid.`); } From 73f0b5d1417b0c9529b9b85f2d2bfa457a792c59 Mon Sep 17 00:00:00 2001 From: Awen Saunders Date: Fri, 7 Jun 2024 19:35:50 +0100 Subject: [PATCH 2/3] Allow floats in computed fields --- app/services/record_json_validator_service.rb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/app/services/record_json_validator_service.rb b/app/services/record_json_validator_service.rb index 98df46b7cb..30b138eff6 100644 --- a/app/services/record_json_validator_service.rb +++ b/app/services/record_json_validator_service.rb @@ -54,7 +54,7 @@ def build_schema(fields) when Field::TALLY_FIELD properties[field.name] = { 'type' => %w[object null], 'properties' => tally_properties(field.tally_i18n) } when Field::CALCULATED - properties[field.name] = { 'type' => %w[integer string boolean array null], + properties[field.name] = { 'type' => %w[integer number string boolean array null], 'minimum' => -2_147_483_648, 'maximum' => 2_147_483_647 } end From 4034b9ad4ab9ffde68bc427e5d10f81991179daf Mon Sep 17 00:00:00 2001 From: Awen Saunders Date: Fri, 7 Jun 2024 19:39:58 +0100 Subject: [PATCH 3/3] Remove round, move functionality into avg This introduces a new syntax for avg (and other mathematical operators, but they have essentially no use with them). You can now specify the number of decimal places when computing the average. For example, you can do {"avg": {"data": ["a", "b", "c"] "extra":{"decimalPlaces": 2}}}, rather than the old format of {"avg": ["a", "b", "c"]}. --- app/javascript/libs/expressions/constants.js | 2 +- .../libs/expressions/operators/avg.js | 13 +++++++++--- .../expressions/operators/avg.unit.test.js | 4 ++++ .../libs/expressions/operators/index.js | 1 - .../libs/expressions/operators/round.js | 21 ------------------- .../libs/expressions/parse-expression.js | 10 +++++---- .../expressions/parse-expression.unit.test.js | 10 +++++++++ .../libs/expressions/utils/build-operator.js | 9 +++----- 8 files changed, 34 insertions(+), 36 deletions(-) delete mode 100644 app/javascript/libs/expressions/operators/round.js diff --git a/app/javascript/libs/expressions/constants.js b/app/javascript/libs/expressions/constants.js index cb16730110..4ab98b3499 100644 --- a/app/javascript/libs/expressions/constants.js +++ b/app/javascript/libs/expressions/constants.js @@ -2,4 +2,4 @@ export const LOGICAL_OPERATORS = Object.freeze({ NOT: "not", AND: "and", OR: "or" }); export const COMPARISON_OPERATORS = Object.freeze({ GE: "ge", GT: "gt", LE: "le", LT: "lt", EQ: "eq", IN: "in" }); -export const MATHEMATICAL_OPERATORS = Object.freeze({ SUM: "sum", AVG: "avg", ROUND: "round" }); +export const MATHEMATICAL_OPERATORS = Object.freeze({ SUM: "sum", AVG: "avg" }); diff --git a/app/javascript/libs/expressions/operators/avg.js b/app/javascript/libs/expressions/operators/avg.js index a13e504d71..5074756691 100644 --- a/app/javascript/libs/expressions/operators/avg.js +++ b/app/javascript/libs/expressions/operators/avg.js @@ -7,12 +7,12 @@ import { MATHEMATICAL_OPERATORS } from "../constants"; import sumOperator from "./sum"; -export default expressions => ({ +export default (expressions, extra) => ({ expressions, operator: MATHEMATICAL_OPERATORS.AVG, evaluate: data => { + const decimalPlaces = extra?.decimalPlaces; const sum = sumOperator(expressions).evaluate(data); - const count = Object.values(expressions).reduce((prev, current) => { if (has(data, current) && !isNil(data[current]) && data[current] !== "") { return prev + 1; @@ -21,6 +21,13 @@ export default expressions => ({ return prev; }, 0); - return sum / (count === 0 ? 1 : count); + const res = sum / (count === 0 ? 1 : count); + + if (decimalPlaces) { + return parseFloat(res.toFixed(decimalPlaces)); + } + + // Backwards compatible version rounds down + return Math.floor(res); } }); diff --git a/app/javascript/libs/expressions/operators/avg.unit.test.js b/app/javascript/libs/expressions/operators/avg.unit.test.js index ada9f4b2da..6417fbf439 100644 --- a/app/javascript/libs/expressions/operators/avg.unit.test.js +++ b/app/javascript/libs/expressions/operators/avg.unit.test.js @@ -6,6 +6,7 @@ import avgOperator from "./avg"; describe("avgOperator", () => { const operator = avgOperator(["a", "b", "c"]); + const decimalPlaceOperator = avgOperator(["a", "b", "c"], { decimalPlaces: 3 }); it("should return avg", () => { expect(operator.evaluate({ a: 3, b: 4, c: 2 })).to.deep.equals(3); @@ -22,4 +23,7 @@ describe("avgOperator", () => { it("returns 0 when no argument passed", () => { expect(operator.evaluate({})).to.deep.equals(0); }); + it("returns a float when decimal places are specified", () => { + expect(decimalPlaceOperator.evaluate({ a: 1, b: 4 })).to.deep.equals(2.5); + }); }); diff --git a/app/javascript/libs/expressions/operators/index.js b/app/javascript/libs/expressions/operators/index.js index 8afeba8b75..03bcfe0635 100644 --- a/app/javascript/libs/expressions/operators/index.js +++ b/app/javascript/libs/expressions/operators/index.js @@ -11,4 +11,3 @@ export { default as orOperator } from "./or"; export { default as notOperator } from "./not"; export { default as sumOperator } from "./sum"; export { default as avgOperator } from "./avg"; -export { default as roundOperator } from "./round"; diff --git a/app/javascript/libs/expressions/operators/round.js b/app/javascript/libs/expressions/operators/round.js deleted file mode 100644 index 8a55a33a43..0000000000 --- a/app/javascript/libs/expressions/operators/round.js +++ /dev/null @@ -1,21 +0,0 @@ -// Copyright (c) 2014 - 2023 UNICEF. All rights reserved. - -import { MATHEMATICAL_OPERATORS } from "../constants"; - -export default expressions => ({ - expressions, - operator: MATHEMATICAL_OPERATORS.ROUND, - evaluate: data => { - const results = expressions.map(current => (current.evaluate ? current.evaluate(data) : current)); - - if (results.length !== 2) { - return 0; - } - try { - const rounded = results[0].toFixed(results[1]); - return rounded; - } catch (error) { - return 0; - } - } -}); diff --git a/app/javascript/libs/expressions/parse-expression.js b/app/javascript/libs/expressions/parse-expression.js index dbb56252ed..267cb4c767 100644 --- a/app/javascript/libs/expressions/parse-expression.js +++ b/app/javascript/libs/expressions/parse-expression.js @@ -17,11 +17,13 @@ const parseExpression = expression => { } if (isMathematicalOperator(operator)) { - const mathExp = Array.isArray(value) - ? value.map(nested => (isObject(nested) ? parseExpression(nested) : nested)) - : parseExpression(value); + const data = value?.data ?? value; + const extra = value?.extra; + const mathExp = Array.isArray(data) + ? data.map(nested => (isObject(nested) ? parseExpression(nested) : nested)) + : parseExpression(data); - return buildOperator(operator, mathExp); + return buildOperator(operator, mathExp, extra); } return buildOperator(operator, value); diff --git a/app/javascript/libs/expressions/parse-expression.unit.test.js b/app/javascript/libs/expressions/parse-expression.unit.test.js index 0ea1c727f6..03f7a0086e 100644 --- a/app/javascript/libs/expressions/parse-expression.unit.test.js +++ b/app/javascript/libs/expressions/parse-expression.unit.test.js @@ -199,6 +199,7 @@ describe("parseExpression", () => { context("avgOperator", () => { const operator = parseExpression({ avg: ["a", "b", "c"] }); + const decimalOperator = parseExpression({ avg: { data: ["a", "b", "c"], extra: { decimalPlaces: 3 } } }); it("should return avg", () => { expect(operator.evaluate({ a: 3, b: 4, c: 2 })).to.deep.equals(3); @@ -215,5 +216,14 @@ describe("parseExpression", () => { it("returns 0 when no argument passed", () => { expect(operator.evaluate({})).to.deep.equals(0); }); + it("works with decimalPlaces specified", () => { + expect(decimalOperator.evaluate({ a: 3, b: 2 })).to.deep.equals(2.5); + }); + it("Correctly rounds to the right number of decimal places", () => { + expect(decimalOperator.evaluate({ a: 2, b: 2, c: 1 })).to.deep.equals(1.667); + }); + it("works with strings", () => { + expect(decimalOperator.evaluate({ a: "2", b: "3" })).to.deep.equals(2.5); + }); }); }); diff --git a/app/javascript/libs/expressions/utils/build-operator.js b/app/javascript/libs/expressions/utils/build-operator.js index 45e2a44d14..00a95a83c2 100644 --- a/app/javascript/libs/expressions/utils/build-operator.js +++ b/app/javascript/libs/expressions/utils/build-operator.js @@ -12,11 +12,10 @@ import { orOperator, notOperator, sumOperator, - avgOperator, - roundOperator + avgOperator } from "../operators"; -export default (operator, value) => { +export default (operator, value, extra) => { switch (operator) { case COMPARISON_OPERATORS.EQ: return eqOperator(value); @@ -39,9 +38,7 @@ export default (operator, value) => { case MATHEMATICAL_OPERATORS.SUM: return sumOperator(value); case MATHEMATICAL_OPERATORS.AVG: - return avgOperator(value); - case MATHEMATICAL_OPERATORS.ROUND: - return roundOperator(value); + return avgOperator(value, extra); default: throw Error(`Operator ${operator} is not valid.`); }