From 6bb67a08ca847faebf4accc52cde77b30f2a5961 Mon Sep 17 00:00:00 2001 From: Tomohisa Igarashi Date: Tue, 21 Mar 2023 14:16:06 -0400 Subject: [PATCH] fix: `expression` object support Fixes: #547 Fixes: #548 Fixes: #554 --- .../resource/v1/IntegrationsResourceTest.java | 76 ++++++ .../api/resource/expression-object.yaml | 82 ++++++ .../java/io/kaoto/backend/KamelPopulator.java | 8 +- .../generator/kamelet/KameletRepresenter.java | 12 + .../kamelet/KameletStepParserService.java | 1 + .../kamelet/expression/Expression.java | 42 +++- .../deployment/kamelet/expression/Groovy.java | 95 +++++++ .../kamelet/expression/Javascript.java | 99 ++++++++ .../deployment/kamelet/expression/Jq.java | 127 ++++++++++ .../deployment/kamelet/expression/Script.java | 20 +- .../kamelet/expression/ScriptExpression.java | 237 ++++++++++++++++++ .../kamelet/step/ChoiceFlowStep.java | 5 + .../kamelet/step/ConditionBlock.java | 3 + .../model/deployment/kamelet/step/Filter.java | 18 ++ .../kamelet/step/ScriptFlowStep.java | 3 + .../deployment/kamelet/step/Throttle.java | 6 +- .../kamelet/step/TransformFlowStep.java | 3 + .../kamelet/step/choice/Choice.java | 9 +- .../kamelet/step/choice/SuperChoice.java | 11 +- .../io/kaoto/backend/model/step/Branch.java | 6 + 20 files changed, 842 insertions(+), 21 deletions(-) create mode 100644 api/src/test/resources/io/kaoto/backend/api/resource/expression-object.yaml create mode 100644 kamelet-support/src/main/java/io/kaoto/backend/model/deployment/kamelet/expression/Groovy.java create mode 100644 kamelet-support/src/main/java/io/kaoto/backend/model/deployment/kamelet/expression/Javascript.java create mode 100644 kamelet-support/src/main/java/io/kaoto/backend/model/deployment/kamelet/expression/Jq.java create mode 100644 kamelet-support/src/main/java/io/kaoto/backend/model/deployment/kamelet/expression/ScriptExpression.java diff --git a/api/src/test/java/io/kaoto/backend/api/resource/v1/IntegrationsResourceTest.java b/api/src/test/java/io/kaoto/backend/api/resource/v1/IntegrationsResourceTest.java index cb40316e9..00160d6c8 100644 --- a/api/src/test/java/io/kaoto/backend/api/resource/v1/IntegrationsResourceTest.java +++ b/api/src/test/java/io/kaoto/backend/api/resource/v1/IntegrationsResourceTest.java @@ -14,7 +14,9 @@ import java.nio.file.Path; import java.util.Collections; import java.util.List; +import java.util.Map; +import io.kaoto.backend.model.deployment.kamelet.expression.Expression; import io.kaoto.backend.model.step.Step; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -306,4 +308,78 @@ void scriptStep() throws Exception { assertTrue(groovy.isPresent()); assertEquals("some groovy script", groovy.get().getValue()); } + + @Test + void expressionObject() throws Exception { + String yaml = Files.readString(Path.of( + IntegrationsResourceTest.class.getResource( + "../expression-object.yaml") + .toURI())); + var res = given() + .when() + .contentType("text/yaml") + .body(yaml) + .post("?dsl=Camel Route") + .then() + .statusCode(Response.Status.OK.getStatusCode()); + String json = res.extract().body().asString(); + + res = given() + .when() + .contentType("application/json") + .body(json) + .post("?dsl=Camel Route") + .then() + .statusCode(Response.Status.OK.getStatusCode()); + + var yaml2 = res.extract().body().asString(); + System.out.println(yaml2); + List parsed = new Yaml().load(yaml2); + List steps = (List) ((Map)((Map)parsed.get(0)).get("from")).get("steps"); + assertEquals(19, steps.size()); + var choice = (Map) ((Map) steps.get(0)).get("choice"); + var when0 = (Map) ((List)choice.get("when")).get(0); + assertExpression("choice", "simple", when0); + var delay = (Map) ((Map) steps.get(1)).get("delay"); + assertExpression("delay", "simple", delay); + var drouter = (Map) ((Map) steps.get(2)).get("dynamic-router"); + assertExpression("dynamic-router", "simple", drouter); + var enrich = (Map) ((Map) steps.get(3)).get("enrich"); + assertExpression("enrich", "simple", enrich); + var filter = (Map) ((Map) steps.get(4)).get("filter"); + assertExpression("filter", "simple", filter); + var penrich = (Map) ((Map) steps.get(5)).get("poll-enrich"); + assertExpression("poll-enrich", "simple", penrich); + var rlist = (Map) ((Map) steps.get(6)).get("recipient-list"); + assertExpression("recipient-list", "simple", rlist); + var resequence = (Map) ((Map) steps.get(7)).get("resequence"); + assertExpression("resequence", "simple", resequence); + var rslip = (Map) ((Map) steps.get(8)).get("routing-slip"); + assertExpression("routing-slip", "simple", rslip); + var script = (Map) ((Map) steps.get(9)).get("script"); + assertExpression("script", "groovy", script); + var scall = (Map) ((Map) steps.get(10)).get("service-call"); + assertExpression("service-call", "jsonpath", scall); + var sbody = (Map) ((Map) steps.get(11)).get("set-body"); + assertExpression("set-body", "constant", sbody); + var sheader = (Map) ((Map) steps.get(12)).get("set-header"); + assertExpression("set-header", "jq", sheader); + var sprop = (Map) ((Map) steps.get(13)).get("set-property"); + assertExpression("set-property", "jq", sprop); + var sort = (Map) ((Map) steps.get(14)).get("sort"); + assertExpression("sort", "simple", sort); + var split = (Map) ((Map) steps.get(15)).get("split"); + assertExpression("split", "simple", split); + var throttle = (Map) ((Map) steps.get(16)).get("throttle"); + assertExpression("throttle", "simple", throttle); + var transform = (Map) ((Map) steps.get(17)).get("transform"); + assertExpression("transform", "jq", transform); + var validate = (Map) ((Map) steps.get(18)).get("validate"); + assertExpression("validate", "simple", validate); + } + + private void assertExpression(String name, String syntax, Map step) { + var nested = (Map) ((Map)step.get("expression")).get(syntax); + assertEquals(name, nested.get("expression")); + } } diff --git a/api/src/test/resources/io/kaoto/backend/api/resource/expression-object.yaml b/api/src/test/resources/io/kaoto/backend/api/resource/expression-object.yaml new file mode 100644 index 000000000..f5621e09d --- /dev/null +++ b/api/src/test/resources/io/kaoto/backend/api/resource/expression-object.yaml @@ -0,0 +1,82 @@ +- from: + uri: timer:null + steps: + - choice: + when: + - expression: + simple: + expression: choice + - delay: + expression: + simple: + expression: delay + - dynamic-router: + expression: + simple: + expression: dynamic-router + - enrich: + expression: + simple: + expression: enrich + - filter: + expression: + simple: + expression: filter + - poll-enrich: + expression: + simple: + expression: poll-enrich + - recipient-list: + expression: + simple: + expression: recipient-list + - resequence: + expression: + simple: + expression: resequence + - routing-slip: + expression: + simple: + expression: routing-slip + - script: + expression: + groovy: + expression: script + - service-call: + expression: + jsonpath: + expression: service-call + - set-body: + expression: + constant: + expression: set-body + - set-header: + name: header1 + expression: + jq: + expression: set-header + - set-property: + name: prop1 + expression: + jq: + expression: set-property + - sort: + expression: + simple: + expression: sort + - split: + expression: + simple: + expression: split + - throttle: + expression: + simple: + expression: throttle + - transform: + expression: + jq: + expression: transform + - validate: + expression: + simple: + expression: validate diff --git a/kamelet-support/src/main/java/io/kaoto/backend/KamelPopulator.java b/kamelet-support/src/main/java/io/kaoto/backend/KamelPopulator.java index 935d0b84a..464057342 100644 --- a/kamelet-support/src/main/java/io/kaoto/backend/KamelPopulator.java +++ b/kamelet-support/src/main/java/io/kaoto/backend/KamelPopulator.java @@ -11,6 +11,7 @@ import io.kaoto.backend.model.deployment.kamelet.Template; import io.kaoto.backend.model.deployment.kamelet.expression.Expression; import io.kaoto.backend.model.deployment.kamelet.expression.Script; +import io.kaoto.backend.model.deployment.kamelet.expression.ScriptExpression; import io.kaoto.backend.model.deployment.kamelet.step.AggregateFlowStep; import io.kaoto.backend.model.deployment.kamelet.step.ChoiceFlowStep; import io.kaoto.backend.model.deployment.kamelet.step.CircuitBreakerFlowStep; @@ -507,7 +508,8 @@ public static Expression getExpression(final Step step) { } else if (CONSTANT.equalsIgnoreCase(p.getId())) { expression.setConstant(String.valueOf(p.getValue())); } else if (EXPRESSION.equalsIgnoreCase(p.getId())) { - expression.setExpression((Expression) p.getValue()); + Expression nestedExpression = new Expression(p.getValue()); + expression.setExpression(nestedExpression); } } expression.setId(step.getStepId()); @@ -526,8 +528,12 @@ public static Script getScript(final Step step) { script.setGroovy(String.valueOf(p.getValue())); } else if (JAVASCRIPT.equalsIgnoreCase(p.getId())) { script.setJavascript(String.valueOf(p.getValue())); + } else if (EXPRESSION.equalsIgnoreCase(p.getId())) { + ScriptExpression nestedExpression = new ScriptExpression(p.getValue()); + script.setExpression(nestedExpression); } } + script.setId(step.getStepId()); return script; } diff --git a/kamelet-support/src/main/java/io/kaoto/backend/api/service/deployment/generator/kamelet/KameletRepresenter.java b/kamelet-support/src/main/java/io/kaoto/backend/api/service/deployment/generator/kamelet/KameletRepresenter.java index 45998116e..b79f849f4 100644 --- a/kamelet-support/src/main/java/io/kaoto/backend/api/service/deployment/generator/kamelet/KameletRepresenter.java +++ b/kamelet-support/src/main/java/io/kaoto/backend/api/service/deployment/generator/kamelet/KameletRepresenter.java @@ -11,6 +11,7 @@ import io.kaoto.backend.model.deployment.kamelet.KameletSpec; import io.kaoto.backend.model.deployment.kamelet.Template; import io.kaoto.backend.model.deployment.kamelet.expression.Script; +import io.kaoto.backend.model.deployment.kamelet.expression.ScriptExpression; import io.kaoto.backend.model.deployment.kamelet.step.AggregateFlowStep; import io.kaoto.backend.model.deployment.kamelet.step.ChoiceFlowStep; import io.kaoto.backend.model.deployment.kamelet.step.CircuitBreakerFlowStep; @@ -86,6 +87,7 @@ public class KameletRepresenter extends Representer { public static final String CONSTANT = "constant"; public static final String GROOVY = "groovy"; public static final String JAVASCRIPT = "javascript"; + public static final String EXPRESSION = "expression"; public static final String STEPS = "steps"; public static final String PARAMETERS = "parameters"; public static final String URI = "uri"; @@ -350,6 +352,14 @@ public Node representData(final Object data) { } }); + this.multiRepresenters.put(ScriptExpression.class, new RepresentMap() { + @Override + public Node representData(final Object data) { + return representMapping(getTag(data.getClass(), Tag.MAP), + ((ScriptExpression) data).getRepresenterProperties(), DumperOptions.FlowStyle.AUTO); + } + }); + choice(); filter(); } @@ -398,6 +408,8 @@ private Node representConditionBlock(final Object data) { properties.put(JQ, step.getJq()); } else if (step.getJsonpath() != null && !step.getJsonpath().isEmpty()) { properties.put(JSONPATH, step.getJsonpath()); + } else if (step.getExpression() != null) { + properties.put(EXPRESSION, step.getExpression()); } return representMapping(getTag(data.getClass(), Tag.MAP), properties, DumperOptions.FlowStyle.AUTO); diff --git a/kamelet-support/src/main/java/io/kaoto/backend/api/service/step/parser/kamelet/KameletStepParserService.java b/kamelet-support/src/main/java/io/kaoto/backend/api/service/step/parser/kamelet/KameletStepParserService.java index 5e56741a6..effc19c7f 100644 --- a/kamelet-support/src/main/java/io/kaoto/backend/api/service/step/parser/kamelet/KameletStepParserService.java +++ b/kamelet-support/src/main/java/io/kaoto/backend/api/service/step/parser/kamelet/KameletStepParserService.java @@ -51,6 +51,7 @@ public class KameletStepParserService public static final Pattern PATTERN = Pattern.compile("[\n|\r]kind:(.+)[\n|\r]", Pattern.CASE_INSENSITIVE); public static final String GROOVY = "groovy"; public static final String JAVASCRIPT = "javascript"; + public static final String EXPRESSION = "expression"; private final Logger log = Logger.getLogger(KameletStepParserService.class); diff --git a/kamelet-support/src/main/java/io/kaoto/backend/model/deployment/kamelet/expression/Expression.java b/kamelet-support/src/main/java/io/kaoto/backend/model/deployment/kamelet/expression/Expression.java index 25c7b9cca..b5dc65995 100644 --- a/kamelet-support/src/main/java/io/kaoto/backend/model/deployment/kamelet/expression/Expression.java +++ b/kamelet-support/src/main/java/io/kaoto/backend/model/deployment/kamelet/expression/Expression.java @@ -10,7 +10,7 @@ import java.util.Map; -@JsonPropertyOrder({"name", "constant", "simple", "jq", "jsonpath"}) +@JsonPropertyOrder({"name", "constant", "simple", "jq", "jsonpath", "expression"}) public class Expression extends EIPStep { public static final String CONSTANT_LABEL = KameletRepresenter.CONSTANT; public static final String SIMPLE_LABEL = KameletRepresenter.SIMPLE; @@ -30,7 +30,7 @@ public class Expression extends EIPStep { private Object simple; private Object jsonpath; - private String jq; + private Object jq; private String name; @@ -45,7 +45,7 @@ public Expression( final @JsonProperty(EXPRESSION_LABEL) Expression expression, final @JsonProperty(CONSTANT_LABEL) Object constant, final @JsonProperty(SIMPLE_LABEL) Object simple, - final @JsonProperty(JQ_LABEL) String jq, + final @JsonProperty(JQ_LABEL) Object jq, final @JsonProperty(NAME_LABEL) String name, final @JsonProperty(RESULT_TYPE) String resultType, final @JsonProperty(RESULT_TYPE2) String resultType2, @@ -85,16 +85,16 @@ protected void setProperties(final Object obj) { protected void setPropertiesFromMap(final Map map, final Expression expression) { if (map.containsKey(CONSTANT_LABEL) && map.get(CONSTANT_LABEL) != null) { - expression.setConstant(String.valueOf(map.get(CONSTANT_LABEL))); + expression.setConstant(parseLang(map.get(CONSTANT_LABEL))); } if (map.containsKey(SIMPLE_LABEL) && map.get(SIMPLE_LABEL) != null) { - expression.setSimple(String.valueOf(map.get(SIMPLE_LABEL))); + expression.setSimple(parseLang(map.get(SIMPLE_LABEL))); } if (map.containsKey(JQ_LABEL) && map.get(JQ_LABEL) != null) { - expression.setJq(String.valueOf(map.get(JQ_LABEL))); + expression.setJq(parseLang(map.get(JQ_LABEL))); } if (map.containsKey(JSON_PATH_LABEL) && map.get(JSON_PATH_LABEL) != null) { - expression.setJsonpath(map.get(JSON_PATH_LABEL)); + expression.setJsonpath(parseLang(map.get(JSON_PATH_LABEL))); } if (map.containsKey(NAME_LABEL) && map.get(NAME_LABEL) != null) { expression.setName(String.valueOf(map.get(NAME_LABEL))); @@ -112,6 +112,13 @@ protected void setPropertiesFromMap(final Map map, final Expression expression) } } + private Object parseLang(Object lang) { + if (lang instanceof Map) { + return lang; + } + return String.valueOf(lang); + } + @Override protected void assignAttribute(final Parameter parameter) { switch (parameter.getId()) { @@ -122,7 +129,7 @@ protected void assignAttribute(final Parameter parameter) { this.setSimple(parameter.getValue()); break; case JQ_LABEL: - this.setJq(String.valueOf(parameter.getValue())); + this.setJq(parameter.getValue()); break; case JSON_PATH_LABEL: this.setJsonpath(parameter.getValue()); @@ -131,7 +138,8 @@ protected void assignAttribute(final Parameter parameter) { this.setName(String.valueOf(parameter.getValue())); break; case EXPRESSION_LABEL: - this.setExpression((Expression) parameter.getValue()); + Expression nestedExpression = new Expression(parameter.getValue()); + this.setExpression(nestedExpression); break; case RESULT_TYPE: case RESULT_TYPE2: @@ -193,7 +201,11 @@ public Map getRepresenterProperties() { } if (this.getJq() != null) { - properties.put(JQ_LABEL, this.getJq()); + if (this.getJq() instanceof Jq jq) { + properties.put(JQ_LABEL, jq.getRepresenterProperties()); + } else { + properties.put(JQ_LABEL, this.getJq()); + } } if (this.getJsonpath() != null) { @@ -278,11 +290,15 @@ public void setJsonpath(Object jsonpath) { } } - public String getJq() { + public Object getJq() { return jq; } - public void setJq(final String jq) { - this.jq = jq; + public void setJq(final Object jq) { + if (jq instanceof Map map) { + this.jq = new Jq(map); + } else { + this.jq = jq; + } } } diff --git a/kamelet-support/src/main/java/io/kaoto/backend/model/deployment/kamelet/expression/Groovy.java b/kamelet-support/src/main/java/io/kaoto/backend/model/deployment/kamelet/expression/Groovy.java new file mode 100644 index 000000000..f9ff40b81 --- /dev/null +++ b/kamelet-support/src/main/java/io/kaoto/backend/model/deployment/kamelet/expression/Groovy.java @@ -0,0 +1,95 @@ +package io.kaoto.backend.model.deployment.kamelet.expression; + + +import com.fasterxml.jackson.annotation.JsonPropertyOrder; + +import java.util.HashMap; +import java.util.Map; + +@JsonPropertyOrder({Groovy.EXPRESSION_LABEL, Groovy.ID_LABEL, Groovy.RESULT_TYPE_LABEL, Groovy.TRIM_LABEL}) +public class Groovy { + public static final String EXPRESSION_LABEL = "expression"; + public static final String ID_LABEL = "id"; + public static final String RESULT_TYPE_LABEL = "result-type"; + public static final String RESULT_TYPE_LABEL2 = "resultType"; + public static final String TRIM_LABEL = "trim"; + private String expression; + private String id; + private String resultType; + private Boolean trim; + + public Groovy() { + + } + + @SuppressWarnings("CPD-START") + public Groovy(Map map) { + if (map.containsKey(EXPRESSION_LABEL)) { + setExpression(String.valueOf(map.get(EXPRESSION_LABEL))); + } + if (map.containsKey(ID_LABEL)) { + setId(String.valueOf(map.get(ID_LABEL))); + } + if (map.containsKey(RESULT_TYPE_LABEL)) { + setResultType(String.valueOf(map.get(RESULT_TYPE_LABEL))); + } else if (map.containsKey(RESULT_TYPE_LABEL2)) { + setResultType(String.valueOf(map.get(RESULT_TYPE_LABEL2))); + } + if (map.containsKey(TRIM_LABEL)) { + setTrim(Boolean.valueOf(String.valueOf(map.get(TRIM_LABEL)))); + } + } + + public Map getRepresenterProperties() { + + Map properties = new HashMap<>(); + if (this.getExpression() != null) { + properties.put(EXPRESSION_LABEL, this.getExpression()); + } + + if (this.getId() != null) { + properties.put(ID_LABEL, this.getId()); + } + + if (this.getTrim() != null) { + properties.put(TRIM_LABEL, this.getTrim()); + } + + if (this.getResultType() != null) { + properties.put(RESULT_TYPE_LABEL, this.getResultType()); + } + + return properties; + } + public String getExpression() { + return expression; + } + + public void setExpression(String expression) { + this.expression = expression; + } + + public String getId() { + return id; + } + + public void setId(String id) { + this.id = id; + } + + public String getResultType() { + return resultType; + } + + public void setResultType(String resultType) { + this.resultType = resultType; + } + + public Boolean getTrim() { + return trim; + } + + public void setTrim(Boolean trim) { + this.trim = trim; + } +} diff --git a/kamelet-support/src/main/java/io/kaoto/backend/model/deployment/kamelet/expression/Javascript.java b/kamelet-support/src/main/java/io/kaoto/backend/model/deployment/kamelet/expression/Javascript.java new file mode 100644 index 000000000..cb0866326 --- /dev/null +++ b/kamelet-support/src/main/java/io/kaoto/backend/model/deployment/kamelet/expression/Javascript.java @@ -0,0 +1,99 @@ +package io.kaoto.backend.model.deployment.kamelet.expression; + + +import com.fasterxml.jackson.annotation.JsonPropertyOrder; + +import java.util.HashMap; +import java.util.Map; + +@JsonPropertyOrder({ + Javascript.EXPRESSION_LABEL, + Javascript.ID_LABEL, + Javascript.RESULT_TYPE_LABEL, + Javascript.TRIM_LABEL}) +public class Javascript { + public static final String EXPRESSION_LABEL = "expression"; + public static final String ID_LABEL = "id"; + public static final String RESULT_TYPE_LABEL = "result-type"; + public static final String RESULT_TYPE_LABEL2 = "resultType"; + public static final String TRIM_LABEL = "trim"; + private String expression; + private String id; + private String resultType; + private Boolean trim; + + public Javascript() { + + } + + @SuppressWarnings("CPD-START") + public Javascript(Map map) { + if (map.containsKey(EXPRESSION_LABEL)) { + setExpression(String.valueOf(map.get(EXPRESSION_LABEL))); + } + if (map.containsKey(ID_LABEL)) { + setId(String.valueOf(map.get(ID_LABEL))); + } + if (map.containsKey(RESULT_TYPE_LABEL)) { + setResultType(String.valueOf(map.get(RESULT_TYPE_LABEL))); + } else if (map.containsKey(RESULT_TYPE_LABEL2)) { + setResultType(String.valueOf(map.get(RESULT_TYPE_LABEL2))); + } + if (map.containsKey(TRIM_LABEL)) { + setTrim(Boolean.valueOf(String.valueOf(map.get(TRIM_LABEL)))); + } + } + + public Map getRepresenterProperties() { + + Map properties = new HashMap<>(); + if (this.getExpression() != null) { + properties.put(EXPRESSION_LABEL, this.getExpression()); + } + + if (this.getId() != null) { + properties.put(ID_LABEL, this.getId()); + } + + if (this.getTrim() != null) { + properties.put(TRIM_LABEL, this.getTrim()); + } + + if (this.getResultType() != null) { + properties.put(RESULT_TYPE_LABEL, this.getResultType()); + } + + return properties; + } + public String getExpression() { + return expression; + } + + public void setExpression(String expression) { + this.expression = expression; + } + + public String getId() { + return id; + } + + public void setId(String id) { + this.id = id; + } + + public String getResultType() { + return resultType; + } + + public void setResultType(String resultType) { + this.resultType = resultType; + } + + public Boolean getTrim() { + return trim; + } + + public void setTrim(Boolean trim) { + this.trim = trim; + } +} diff --git a/kamelet-support/src/main/java/io/kaoto/backend/model/deployment/kamelet/expression/Jq.java b/kamelet-support/src/main/java/io/kaoto/backend/model/deployment/kamelet/expression/Jq.java new file mode 100644 index 000000000..4df7a04b8 --- /dev/null +++ b/kamelet-support/src/main/java/io/kaoto/backend/model/deployment/kamelet/expression/Jq.java @@ -0,0 +1,127 @@ +package io.kaoto.backend.model.deployment.kamelet.expression; + + +import com.fasterxml.jackson.annotation.JsonPropertyOrder; + +import java.util.HashMap; +import java.util.Map; + +@JsonPropertyOrder({Jq.EXPRESSION_LABEL, Jq.ID_LABEL, Jq.RESULT_TYPE_LABEL, Jq.TRIM_LABEL}) +public class Jq { + public static final String EXPRESSION_LABEL = "expression"; + public static final String ID_LABEL = "id"; + public static final String RESULT_TYPE_LABEL = "result-type"; + public static final String RESULT_TYPE_LABEL2 = "resultType"; + public static final String HEADER_NAME_LABEL = "header-name"; + public static final String HEADER_NAME_LABEL2 = "headerName"; + public static final String PROPERTY_NAME_LABEL = "property-name"; + public static final String PROPERTY_NAME_LABEL2 = "propertyName"; + public static final String TRIM_LABEL = "trim"; + private String expression; + private String id; + private String resultType; + private String headerName; + private String propertyName; + private Boolean trim; + + public Jq() { + + } + + @SuppressWarnings("CPD-START") + public Jq(Map map) { + if (map.containsKey(EXPRESSION_LABEL)) { + setExpression(String.valueOf(map.get(EXPRESSION_LABEL))); + } + if (map.containsKey(ID_LABEL)) { + setId(String.valueOf(map.get(ID_LABEL))); + } + if (map.containsKey(RESULT_TYPE_LABEL)) { + setResultType(String.valueOf(map.get(RESULT_TYPE_LABEL))); + } else if (map.containsKey(RESULT_TYPE_LABEL2)) { + setResultType(String.valueOf(map.get(RESULT_TYPE_LABEL2))); + } + if (map.containsKey(HEADER_NAME_LABEL)) { + setHeaderName(String.valueOf(map.get(HEADER_NAME_LABEL))); + } else if (map.containsKey(HEADER_NAME_LABEL2)) { + setHeaderName(String.valueOf(map.get(HEADER_NAME_LABEL2))); + } + if (map.containsKey(PROPERTY_NAME_LABEL)) { + setPropertyName(String.valueOf(map.get(PROPERTY_NAME_LABEL))); + } else if (map.containsKey(PROPERTY_NAME_LABEL2)) { + setPropertyName(String.valueOf(map.get(PROPERTY_NAME_LABEL2))); + } + if (map.containsKey(TRIM_LABEL)) { + setTrim(Boolean.valueOf(String.valueOf(map.get(TRIM_LABEL)))); + } + } + + public Map getRepresenterProperties() { + + Map properties = new HashMap<>(); + if (this.getExpression() != null) { + properties.put(EXPRESSION_LABEL, this.getExpression()); + } + + if (this.getId() != null) { + properties.put(ID_LABEL, this.getId()); + } + + if (this.getTrim() != null) { + properties.put(TRIM_LABEL, this.getTrim()); + } + + if (this.getResultType() != null) { + properties.put(RESULT_TYPE_LABEL, this.getResultType()); + } + + return properties; + } + public String getExpression() { + return expression; + } + + public void setExpression(String expression) { + this.expression = expression; + } + + public String getId() { + return id; + } + + public void setId(String id) { + this.id = id; + } + + public String getResultType() { + return resultType; + } + + public void setResultType(String resultType) { + this.resultType = resultType; + } + + public String getHeaderName() { + return headerName; + } + + public void setHeaderName(String headerName) { + this.headerName = headerName; + } + + public String getPropertyName() { + return propertyName; + } + + public void setPropertyName(String propertyName) { + this.propertyName = propertyName; + } + + public Boolean getTrim() { + return trim; + } + + public void setTrim(Boolean trim) { + this.trim = trim; + } +} diff --git a/kamelet-support/src/main/java/io/kaoto/backend/model/deployment/kamelet/expression/Script.java b/kamelet-support/src/main/java/io/kaoto/backend/model/deployment/kamelet/expression/Script.java index 3a61a3194..cb57d90b7 100644 --- a/kamelet-support/src/main/java/io/kaoto/backend/model/deployment/kamelet/expression/Script.java +++ b/kamelet-support/src/main/java/io/kaoto/backend/model/deployment/kamelet/expression/Script.java @@ -10,13 +10,13 @@ import java.util.LinkedHashMap; import java.util.Map; -@JsonPropertyOrder({"name", "groovy", "javascript"}) +@JsonPropertyOrder({"name", "groovy", "javascript", "expression"}) public class Script extends EIPStep { public static final String GROOVY_LABEL = KameletRepresenter.GROOVY; public static final String JAVASCRIPT_LABEL = KameletRepresenter.JAVASCRIPT; + public static final String EXPRESSION_LABEL = KameletRepresenter.EXPRESSION; public static final String NAME_LABEL = KameletRepresenter.NAME; - public static final String EXPRESSION_LABEL = "script"; private Object groovy; @@ -24,6 +24,8 @@ public class Script extends EIPStep { private String name; + private ScriptExpression expression; + public Script() { //Needed for serialization } @@ -32,9 +34,11 @@ public Script() { public Script( final @JsonProperty(GROOVY_LABEL) Object groovy, final @JsonProperty(JAVASCRIPT_LABEL) Object javascript, + final @JsonProperty(EXPRESSION_LABEL) ScriptExpression expression, final @JsonProperty(NAME_LABEL) String name) { setGroovy(groovy); setJavascript(javascript); + setExpression(expression); setName(name); } @@ -50,6 +54,9 @@ protected void assignAttribute(final Parameter parameter) { case NAME_LABEL: this.setName(String.valueOf(parameter.getValue())); break; + case EXPRESSION_LABEL: + ScriptExpression nested = new ScriptExpression(parameter.getValue()); + this.setExpression(nested); default: break; } @@ -67,6 +74,8 @@ protected void assignProperty(final Parameter parameter) { case NAME_LABEL: parameter.setValue(this.name); break; + case EXPRESSION_LABEL: + parameter.setValue(this.expression); default: break; } @@ -84,6 +93,10 @@ public Map getRepresenterProperties() { properties.put(JAVASCRIPT_LABEL, this.getJavascript()); } + if (this.getExpression() != null) { + properties.put(EXPRESSION_LABEL, this.getExpression()); + } + if (this.getName() != null) { properties.put(NAME_LABEL, this.getName()); } @@ -115,4 +128,7 @@ public void setJavascript(final Object javascript) { this.javascript = javascript; } + public ScriptExpression getExpression() {return this.expression; } + public void setExpression(ScriptExpression expression) { this.expression = expression; } + } diff --git a/kamelet-support/src/main/java/io/kaoto/backend/model/deployment/kamelet/expression/ScriptExpression.java b/kamelet-support/src/main/java/io/kaoto/backend/model/deployment/kamelet/expression/ScriptExpression.java new file mode 100644 index 000000000..a11eeff87 --- /dev/null +++ b/kamelet-support/src/main/java/io/kaoto/backend/model/deployment/kamelet/expression/ScriptExpression.java @@ -0,0 +1,237 @@ +package io.kaoto.backend.model.deployment.kamelet.expression; + +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonPropertyOrder; +import io.kaoto.backend.api.service.deployment.generator.kamelet.KameletRepresenter; +import io.kaoto.backend.model.deployment.kamelet.step.EIPStep; +import io.kaoto.backend.model.parameter.Parameter; +import io.kaoto.backend.model.step.Step; + +import java.util.Map; + +@JsonPropertyOrder({"name", "groovy", "javascript", "expression"}) +public class ScriptExpression extends EIPStep { + public static final String GROOVY_LABEL = KameletRepresenter.GROOVY; + public static final String JAVASCRIPT_LABEL = KameletRepresenter.JAVASCRIPT; + public static final String EXPRESSION_LABEL = KameletRepresenter.EXPRESSION; + public static final String NAME_LABEL = KameletRepresenter.NAME; + + public static final String RESULT_TYPE = "result-type"; + public static final String RESULT_TYPE2 = "resultType"; + + private Object groovy; + + private ScriptExpression expression; + + private Object javascript; + + private String name; + + private String resultType; + + public ScriptExpression() { + //Needed for serialization + } + + @JsonCreator + public ScriptExpression( + final @JsonProperty(EXPRESSION_LABEL) ScriptExpression expression, + final @JsonProperty(GROOVY_LABEL) Object groovy, + final @JsonProperty(JAVASCRIPT_LABEL) Object javascript, + final @JsonProperty(NAME_LABEL) String name, + final @JsonProperty(RESULT_TYPE) String resultType, + final @JsonProperty(RESULT_TYPE2) String resultType2, + final @JsonProperty("id") String id) { + setExpression(expression); + setGroovy(groovy); + setJavascript(javascript); + setName(name); + setResultType(resultType != null ? resultType : resultType2); + setId(id); + } + + public ScriptExpression(Step step) { + super(step); + } + + public ScriptExpression(Object obj) { + setProperties(obj); + } + + protected void setProperties(final Object obj) { + if (obj instanceof ScriptExpression e) { + setGroovy(e.getGroovy()); + setJavascript(e.getJavascript()); + setName(e.getName()); + setExpression(e.getExpression()); + setId(e.getId()); + } else if (obj instanceof Map map) { + setPropertiesFromMap(map, this); + } + } + + @SuppressWarnings("CPD-START") + protected void setPropertiesFromMap(final Map map, final ScriptExpression expression) { + if (map.containsKey(GROOVY_LABEL) && map.get(GROOVY_LABEL) != null) { + expression.setGroovy(parseLang(map.get(GROOVY_LABEL))); + } + if (map.containsKey(JAVASCRIPT_LABEL) && map.get(JAVASCRIPT_LABEL) != null) { + expression.setJavascript(parseLang(map.get(JAVASCRIPT_LABEL))); + } + if (map.containsKey(NAME_LABEL) && map.get(NAME_LABEL) != null) { + expression.setName(String.valueOf(map.get(NAME_LABEL))); + } + if (map.containsKey(RESULT_TYPE) && map.get(RESULT_TYPE) != null) { + expression.setResultType(String.valueOf(map.get(RESULT_TYPE))); + } else if (map.containsKey(RESULT_TYPE2) && map.get(RESULT_TYPE2) != null) { + expression.setResultType(String.valueOf(map.get(RESULT_TYPE2))); + } + if (map.containsKey(EXPRESSION_LABEL) && map.get(EXPRESSION_LABEL) != null) { + expression.setExpression((ScriptExpression) map.get(EXPRESSION_LABEL)); + } + if (map.containsKey("id") && map.get("id") != null) { + expression.setId(String.valueOf(map.get("id"))); + } + } + + private Object parseLang(Object lang) { + if (lang instanceof Map) { + return lang; + } + return String.valueOf(lang); + } + + @Override + protected void assignAttribute(final Parameter parameter) { + switch (parameter.getId()) { + case GROOVY_LABEL: + this.setGroovy(parameter.getValue()); + break; + case JAVASCRIPT_LABEL: + this.setJavascript(parameter.getValue()); + break; + case NAME_LABEL: + this.setName(String.valueOf(parameter.getValue())); + break; + case EXPRESSION_LABEL: + ScriptExpression nestedExpression = new ScriptExpression(parameter.getValue()); + this.setExpression(nestedExpression); + break; + case RESULT_TYPE: + case RESULT_TYPE2: + setResultType(String.valueOf(parameter.getValue())); + break; + default: + break; + } + } + + @Override + protected void assignProperty(final Parameter parameter) { + switch (parameter.getId()) { + case GROOVY_LABEL: + parameter.setValue(this.groovy); + break; + case JAVASCRIPT_LABEL: + parameter.setValue(this.javascript); + break; + case NAME_LABEL: + parameter.setValue(this.name); + break; + case EXPRESSION_LABEL: + parameter.setValue(this.getExpression()); + break; + case RESULT_TYPE: + case RESULT_TYPE2: + parameter.setValue(this.getResultType()); + break; + default: + break; + } + } + + @Override + public Map getRepresenterProperties() { + + Map properties = super.getDefaultRepresenterProperties(); + if (this.getGroovy() != null) { + if (this.getGroovy() instanceof Groovy groovy) { + properties.put(GROOVY_LABEL, groovy.getRepresenterProperties()); + } else { + properties.put(GROOVY_LABEL, this.getGroovy()); + } + } + + if (this.getJavascript() != null) { + if (this.getJavascript() instanceof Javascript javascript) { + properties.put(JAVASCRIPT_LABEL, javascript.getRepresenterProperties()); + } else { + properties.put(JAVASCRIPT_LABEL, this.getJavascript()); + } + } + + if (this.getName() != null) { + properties.put(NAME_LABEL, this.getName()); + } + + if (this.getResultType() != null) { + properties.put(RESULT_TYPE, this.getResultType()); + } + + if (this.getExpression() != null) { + properties.put(EXPRESSION_LABEL, this.getExpression()); + } + return properties; + } + + public String getResultType() { + return resultType; + } + + public void setResultType(String resultType) { + this.resultType = resultType; + } + + public String getName() { + return name; + } + + public void setName(final String name) { + this.name = name; + } + + public Object getGroovy() { + return groovy; + } + + public void setGroovy(final Object groovy) { + if (groovy instanceof Map map) { + this.groovy = new Groovy(map); + } else { + this.groovy = groovy; + } + } + + public Object getJavascript() { + return javascript; + } + + public void setJavascript(final Object javascript) { + if (javascript instanceof Map map) { + this.javascript = new Javascript(map); + } else { + this.javascript = javascript; + } + } + + public ScriptExpression getExpression() { + return expression; + } + + public void setExpression(ScriptExpression expression) { + this.expression = expression; + } + + +} diff --git a/kamelet-support/src/main/java/io/kaoto/backend/model/deployment/kamelet/step/ChoiceFlowStep.java b/kamelet-support/src/main/java/io/kaoto/backend/model/deployment/kamelet/step/ChoiceFlowStep.java index 1a1604229..96c8e7fca 100644 --- a/kamelet-support/src/main/java/io/kaoto/backend/model/deployment/kamelet/step/ChoiceFlowStep.java +++ b/kamelet-support/src/main/java/io/kaoto/backend/model/deployment/kamelet/step/ChoiceFlowStep.java @@ -10,6 +10,7 @@ import io.kaoto.backend.api.metadata.catalog.StepCatalog; import io.kaoto.backend.api.service.step.parser.kamelet.KameletStepParserService; import io.kaoto.backend.model.deployment.kamelet.FlowStep; +import io.kaoto.backend.model.deployment.kamelet.expression.Expression; import io.kaoto.backend.model.deployment.kamelet.step.choice.Choice; import io.kaoto.backend.model.deployment.kamelet.step.choice.Otherwise; import io.kaoto.backend.model.deployment.kamelet.step.choice.SuperChoice; @@ -86,6 +87,10 @@ private Choice processChoice(final Branch b, final KamelPopulator kameletPopulat } else { choice.setJsonpath(b.getCondition()); } + if (b.getExpression() != null) { + Expression nestedExpression = new Expression(b.getExpression()); + choice.setExpression(nestedExpression); + } return choice; } diff --git a/kamelet-support/src/main/java/io/kaoto/backend/model/deployment/kamelet/step/ConditionBlock.java b/kamelet-support/src/main/java/io/kaoto/backend/model/deployment/kamelet/step/ConditionBlock.java index dfb1ec3ac..70e274d5d 100644 --- a/kamelet-support/src/main/java/io/kaoto/backend/model/deployment/kamelet/step/ConditionBlock.java +++ b/kamelet-support/src/main/java/io/kaoto/backend/model/deployment/kamelet/step/ConditionBlock.java @@ -1,6 +1,7 @@ package io.kaoto.backend.model.deployment.kamelet.step; import io.kaoto.backend.model.deployment.kamelet.FlowStep; +import io.kaoto.backend.model.deployment.kamelet.expression.Expression; import java.util.List; @@ -12,4 +13,6 @@ public interface ConditionBlock { String getJq(); String getJsonpath(); + + Expression getExpression(); } diff --git a/kamelet-support/src/main/java/io/kaoto/backend/model/deployment/kamelet/step/Filter.java b/kamelet-support/src/main/java/io/kaoto/backend/model/deployment/kamelet/step/Filter.java index 6ce409757..44ced3bd8 100644 --- a/kamelet-support/src/main/java/io/kaoto/backend/model/deployment/kamelet/step/Filter.java +++ b/kamelet-support/src/main/java/io/kaoto/backend/model/deployment/kamelet/step/Filter.java @@ -5,6 +5,7 @@ import io.kaoto.backend.api.metadata.catalog.StepCatalog; import io.kaoto.backend.api.service.step.parser.kamelet.KameletStepParserService; import io.kaoto.backend.model.deployment.kamelet.FlowStep; +import io.kaoto.backend.model.deployment.kamelet.expression.Expression; import io.kaoto.backend.model.parameter.Parameter; import io.kaoto.backend.model.step.Step; @@ -18,6 +19,8 @@ public class Filter extends EIPStep implements ConditionBlock { public static final String SIMPLE_LABEL = "simple"; public static final String JQ_LABEL = "jq"; public static final String JSONPATH_LABEL = "jsonpath"; + public static final String EXPRESSION_LABEL = "expression"; + @JsonProperty(SIMPLE_LABEL) private String simple; @JsonProperty(JQ_LABEL) @@ -25,6 +28,9 @@ public class Filter extends EIPStep implements ConditionBlock { @JsonProperty(JSONPATH_LABEL) private String jsonpath; + @JsonProperty(EXPRESSION_LABEL) + private Expression expression; + @JsonProperty(STEPS_LABEL) private List steps; @@ -72,6 +78,9 @@ public Map getRepresenterProperties() { if (this.getJsonpath() != null) { properties.put(JSONPATH_LABEL, this.getJsonpath()); } + if (this.getExpression() != null) { + properties.put(EXPRESSION_LABEL, this.getExpression()); + } if (this.getSteps() != null) { properties.put(STEPS_LABEL, this.getSteps()); } @@ -93,6 +102,8 @@ protected void assignProperty(final Parameter parameter) { case JSONPATH_LABEL: parameter.setValue(this.getJsonpath()); break; + case EXPRESSION_LABEL: + parameter.setValue(this.getExpression()); default: break; } @@ -110,6 +121,9 @@ protected void assignAttribute(final Parameter parameter) { case JSONPATH_LABEL: this.setJsonpath(String.valueOf(parameter.getValue())); break; + case EXPRESSION_LABEL: + Expression nested = new Expression(parameter.getValue()); + this.setExpression(nested); default: break; } @@ -138,4 +152,8 @@ public String getJsonpath() { public void setJsonpath(String jsonpath) { this.jsonpath = jsonpath; } + + public Expression getExpression() { return expression; } + + public void setExpression(Expression expression) { this.expression = expression; } } diff --git a/kamelet-support/src/main/java/io/kaoto/backend/model/deployment/kamelet/step/ScriptFlowStep.java b/kamelet-support/src/main/java/io/kaoto/backend/model/deployment/kamelet/step/ScriptFlowStep.java index f96a24008..77f343643 100644 --- a/kamelet-support/src/main/java/io/kaoto/backend/model/deployment/kamelet/step/ScriptFlowStep.java +++ b/kamelet-support/src/main/java/io/kaoto/backend/model/deployment/kamelet/step/ScriptFlowStep.java @@ -66,6 +66,9 @@ public Step getStep(final StepCatalog catalog, final KameletStepParserService ka } else if (p.getId() .equalsIgnoreCase(KameletStepParserService.JAVASCRIPT)) { p.setValue(this.getScript().getJavascript()); + } else if (p.getId() + .equalsIgnoreCase(KameletStepParserService.EXPRESSION)) { + p.setValue(this.getScript().getExpression()); } } return res.get(); diff --git a/kamelet-support/src/main/java/io/kaoto/backend/model/deployment/kamelet/step/Throttle.java b/kamelet-support/src/main/java/io/kaoto/backend/model/deployment/kamelet/step/Throttle.java index a75534db3..52541ac74 100644 --- a/kamelet-support/src/main/java/io/kaoto/backend/model/deployment/kamelet/step/Throttle.java +++ b/kamelet-support/src/main/java/io/kaoto/backend/model/deployment/kamelet/step/Throttle.java @@ -50,9 +50,9 @@ public Throttle() { @JsonCreator public Throttle(final @JsonProperty(EXPRESSION_LABEL) Expression expression, - final @JsonProperty(CONSTANT_LABEL) String constant, - final @JsonProperty(SIMPLE_LABEL) String simple, - final @JsonProperty(JQ_LABEL) String jq, + final @JsonProperty(CONSTANT_LABEL) Object constant, + final @JsonProperty(SIMPLE_LABEL) Object simple, + final @JsonProperty(JQ_LABEL) Object jq, final @JsonProperty(CORRELATION_EXPRESSION_LABEL) Expression correlationExpression, final @JsonProperty(CORRELATION_EXPRESSION_LABEL2) Expression correlationExpression2, final @JsonProperty(EXECUTOR_SERVICE_LABEL) Object executorService, diff --git a/kamelet-support/src/main/java/io/kaoto/backend/model/deployment/kamelet/step/TransformFlowStep.java b/kamelet-support/src/main/java/io/kaoto/backend/model/deployment/kamelet/step/TransformFlowStep.java index 44fffc1cb..349814347 100644 --- a/kamelet-support/src/main/java/io/kaoto/backend/model/deployment/kamelet/step/TransformFlowStep.java +++ b/kamelet-support/src/main/java/io/kaoto/backend/model/deployment/kamelet/step/TransformFlowStep.java @@ -78,6 +78,9 @@ public Step getStep(final StepCatalog catalog, final KameletStepParserService ka } else if (p.getId() .equalsIgnoreCase(KameletStepParserService.JQ)) { p.setValue(this.getTransform().getJq()); + } else if (p.getId() + .equalsIgnoreCase(KameletStepParserService.EXPRESSION)) { + p.setValue(this.getTransform().getExpression()); } } return res.get(); diff --git a/kamelet-support/src/main/java/io/kaoto/backend/model/deployment/kamelet/step/choice/Choice.java b/kamelet-support/src/main/java/io/kaoto/backend/model/deployment/kamelet/step/choice/Choice.java index 57642a746..7a780b12c 100644 --- a/kamelet-support/src/main/java/io/kaoto/backend/model/deployment/kamelet/step/choice/Choice.java +++ b/kamelet-support/src/main/java/io/kaoto/backend/model/deployment/kamelet/step/choice/Choice.java @@ -4,6 +4,7 @@ import com.fasterxml.jackson.annotation.JsonProperty; import com.fasterxml.jackson.annotation.JsonPropertyOrder; import io.kaoto.backend.model.deployment.kamelet.FlowStep; +import io.kaoto.backend.model.deployment.kamelet.expression.Expression; import io.kaoto.backend.model.deployment.kamelet.step.ConditionBlock; import java.io.Serial; @@ -11,7 +12,7 @@ import java.util.List; -@JsonPropertyOrder({"simple", "jq", "jsonpath", "steps"}) +@JsonPropertyOrder({"simple", "jq", "jsonpath", "expression", "steps"}) @JsonIgnoreProperties(ignoreUnknown = true) public class Choice implements Serializable, ConditionBlock { @Serial @@ -24,6 +25,9 @@ public class Choice implements Serializable, ConditionBlock { @JsonProperty("jsonpath") private String jsonpath; + @JsonProperty("expression") + private Expression expression; + @JsonProperty("steps") private List steps; @@ -58,4 +62,7 @@ public String getJsonpath() { public void setJsonpath(String jsonpath) { this.jsonpath = jsonpath; } + public Expression getExpression() { return expression; } + + public void setExpression(final Expression e) { this.expression = e; } } diff --git a/kamelet-support/src/main/java/io/kaoto/backend/model/deployment/kamelet/step/choice/SuperChoice.java b/kamelet-support/src/main/java/io/kaoto/backend/model/deployment/kamelet/step/choice/SuperChoice.java index 0d825cac2..e0b8dbf4c 100644 --- a/kamelet-support/src/main/java/io/kaoto/backend/model/deployment/kamelet/step/choice/SuperChoice.java +++ b/kamelet-support/src/main/java/io/kaoto/backend/model/deployment/kamelet/step/choice/SuperChoice.java @@ -4,6 +4,7 @@ import io.kaoto.backend.KamelPopulator; import io.kaoto.backend.api.metadata.catalog.StepCatalog; import io.kaoto.backend.api.service.step.parser.kamelet.KameletStepParserService; +import io.kaoto.backend.model.deployment.kamelet.expression.Expression; import io.kaoto.backend.model.deployment.kamelet.step.EIPStep; import io.kaoto.backend.model.parameter.Parameter; import io.kaoto.backend.model.step.Branch; @@ -34,6 +35,10 @@ public SuperChoice(Step step, final KamelPopulator kameletPopulator) { if (b.getCondition() != null || String.valueOf(b.getIdentifier()).startsWith("when-")) { Choice choice = new Choice(); choice.setSteps(kameletPopulator.processSteps(b)); + if (b.getExpression() != null) { + Expression nestedExpression = new Expression(b.getExpression()); + choice.setExpression(nestedExpression); + } switch (b.getConditionSyntax()) { case SIMPLE: choice.setSimple(b.getCondition()); @@ -68,9 +73,13 @@ protected void processBranches(final Step step, final StepCatalog catalog, if (getChoice() != null) { int i = 1; for (var flow : getChoice()) { - Branch branch = createBranch(getChoiceIdentifier(flow, i++), flow.getSteps(), kameletStepParserService); + Branch branch = createBranch( + getChoiceIdentifier(flow, i++), + flow.getSteps(), + kameletStepParserService); branch.setConditionSyntax(getChoiceConditionSyntax(flow)); branch.setCondition(getChoiceCondition(flow)); + branch.setExpression(flow.getExpression()); kameletStepParserService.setValueOnStepProperty(step, branch.getConditionSyntax().value(), branch.getCondition()); diff --git a/model/src/main/java/io/kaoto/backend/model/step/Branch.java b/model/src/main/java/io/kaoto/backend/model/step/Branch.java index cdffe7da2..3fce6498a 100644 --- a/model/src/main/java/io/kaoto/backend/model/step/Branch.java +++ b/model/src/main/java/io/kaoto/backend/model/step/Branch.java @@ -13,6 +13,7 @@ */ public class Branch { + public enum ConditionSyntax { SIMPLE ("simple"), JQ ("jq"), @@ -34,6 +35,7 @@ public String value() { private String identifier; private String condition; private ConditionSyntax conditionSyntax = ConditionSyntax.SIMPLE; + private Object expression; public Branch() { super(); @@ -91,4 +93,8 @@ public void setCondition(final String condition) { public ConditionSyntax getConditionSyntax() { return conditionSyntax; } public void setConditionSyntax(final ConditionSyntax syntax) { this.conditionSyntax = syntax; } + + public Object getExpression() { return expression; } + + public void setExpression(Object expression) { this.expression = expression; } }