Skip to content

armgit / core

Public Imported from GitHub
0

100% open-source IoT Platform - Integrate your devices, add intelligence, build custom apps

Merge commit from fork

Eric Bariaux01d9cc2f6b65
diff --git a/gradle.properties b/gradle.properties
index 71ae2887c..b397ee78e 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -56,7 +56,6 @@ swaggerVersion=2.2.47
swaggeruiVersion = 5.18.2
hiveMQClientVersion=1.3.10
bluetoothVersion = 0.64
-nashornVersion=15.7
failsafeVersion=3.3.2
suncalcVersion=3.11
snapshotsRepoUrl=https://central.sonatype.com/repository/maven-snapshots/
diff --git a/manager/build.gradle b/manager/build.gradle
index 6567a59d4..37c6b2e80 100644
--- a/manager/build.gradle
+++ b/manager/build.gradle
@@ -24,7 +24,6 @@ dependencies {
implementation "com.google.firebase:firebase-admin:$firebaseAdminVersion"
implementation "org.eclipse.angus:angus-mail:$jakartaMailVersion"
implementation "io.swagger.core.v3:swagger-jaxrs2-jakarta:$swaggerVersion"
- implementation "org.openjdk.nashorn:nashorn-core:$nashornVersion"
implementation "org.apache.camel:camel-undertow:$camelVersion"
// Indirect dep from org.apache.activemq:artemis-mqtt-protocol
diff --git a/manager/src/main/java/org/openremote/manager/rules/RulesResourceImpl.java b/manager/src/main/java/org/openremote/manager/rules/RulesResourceImpl.java
index b709300cd..d074832e2 100644
--- a/manager/src/main/java/org/openremote/manager/rules/RulesResourceImpl.java
+++ b/manager/src/main/java/org/openremote/manager/rules/RulesResourceImpl.java
@@ -47,6 +47,7 @@ import static jakarta.ws.rs.core.Response.Status.NOT_FOUND;
public class RulesResourceImpl extends ManagerWebResource implements RulesResource {
private static final Logger LOG = Logger.getLogger(RulesResourceImpl.class.getName());
+ private static final String LEGACY_JAVASCRIPT_RULESET_MUTATION_ERROR = "JavaScript rules are legacy and cannot be created or updated";
final protected RulesetStorageService rulesetStorageService;
final protected AssetStorageService assetStorageService;
@@ -118,6 +119,19 @@ public class RulesResourceImpl extends ManagerWebResource implements RulesResour
);
}
+ protected void rejectLegacyJavascriptCreate(Ruleset ruleset) {
+ if (ruleset != null && ruleset.getLang() == Ruleset.Lang.JAVASCRIPT) {
+ throw new WebApplicationException(LEGACY_JAVASCRIPT_RULESET_MUTATION_ERROR, BAD_REQUEST);
+ }
+ }
+
+ protected void rejectLegacyJavascriptUpdate(Ruleset existingRuleset, Ruleset incomingRuleset) {
+ if ((existingRuleset != null && existingRuleset.getLang() == Ruleset.Lang.JAVASCRIPT)
+ || (incomingRuleset != null && incomingRuleset.getLang() == Ruleset.Lang.JAVASCRIPT)) {
+ throw new WebApplicationException(LEGACY_JAVASCRIPT_RULESET_MUTATION_ERROR, BAD_REQUEST);
+ }
+ }
+
@Override
public GlobalRuleset[] getGlobalRulesets(@BeanParam RequestParams requestParams, List<Ruleset.Lang> languages, boolean fullyPopulate) {
if (!isSuperUser()) {
@@ -209,6 +223,7 @@ public class RulesResourceImpl extends ManagerWebResource implements RulesResour
if (!isSuperUser()) {
throw new WebApplicationException(Response.Status.FORBIDDEN);
}
+ rejectLegacyJavascriptCreate(ruleset);
ruleset = rulesetStorageService.merge(ruleset);
return ruleset.getId();
}
@@ -233,6 +248,7 @@ public class RulesResourceImpl extends ManagerWebResource implements RulesResour
GlobalRuleset existingRuleset = rulesetStorageService.find(GlobalRuleset.class, id);
if (existingRuleset == null)
throw new WebApplicationException(NOT_FOUND);
+ rejectLegacyJavascriptUpdate(existingRuleset, ruleset);
rulesetStorageService.merge(ruleset);
}
@@ -256,6 +272,7 @@ public class RulesResourceImpl extends ManagerWebResource implements RulesResour
LOG.fine("Realm '" + realm + "' is nonexistent, inactive or inaccessible: username=" + getUsername());
throw new WebApplicationException(Response.Status.FORBIDDEN);
}
+ rejectLegacyJavascriptCreate(ruleset);
// Only super users can create/modify groovy rules
// TODO: Implement robust groovy sandbox
@@ -303,6 +320,7 @@ public class RulesResourceImpl extends ManagerWebResource implements RulesResour
if (!existingRuleset.getRealm().equals(ruleset.getRealm())) {
throw new WebApplicationException("Requested realm and existing ruleset realm must match", BAD_REQUEST);
}
+ rejectLegacyJavascriptUpdate(existingRuleset, ruleset);
// Only super users can create/modify groovy rules
// TODO: Implement robust groovy sandbox
@@ -353,6 +371,7 @@ public class RulesResourceImpl extends ManagerWebResource implements RulesResour
if (isRestrictedUser() && !assetStorageService.isUserAsset(getUserId(), asset.getId())) {
throw new WebApplicationException(Response.Status.FORBIDDEN);
}
+ rejectLegacyJavascriptCreate(ruleset);
// Only super users can create/modify groovy rules
// TODO: Implement robust groovy sandbox
@@ -406,6 +425,7 @@ public class RulesResourceImpl extends ManagerWebResource implements RulesResour
throw new WebApplicationException("Can't update asset ID, delete and create the ruleset to reassign",
BAD_REQUEST);
}
+ rejectLegacyJavascriptUpdate(existingRuleset, ruleset);
// Only super users can create/modify groovy rules
// TODO: Implement robust groovy sandbox
diff --git a/manager/src/main/java/org/openremote/manager/rules/RulesetDeployment.java b/manager/src/main/java/org/openremote/manager/rules/RulesetDeployment.java
index 100cf4f05..fabd04137 100644
--- a/manager/src/main/java/org/openremote/manager/rules/RulesetDeployment.java
+++ b/manager/src/main/java/org/openremote/manager/rules/RulesetDeployment.java
@@ -23,31 +23,47 @@ import groovy.lang.Binding;
import groovy.lang.GroovyShell;
import groovy.lang.Script;
import org.codehaus.groovy.control.CompilerConfiguration;
-import org.jeasy.rules.api.Action;
-import org.jeasy.rules.api.Condition;
import org.jeasy.rules.api.Rule;
import org.jeasy.rules.api.Rules;
-import org.jeasy.rules.core.RuleBuilder;
import org.kohsuke.groovy.sandbox.GroovyValueFilter;
import org.kohsuke.groovy.sandbox.SandboxTransformer;
-import org.openjdk.nashorn.api.scripting.ScriptObjectMirror;
import org.openremote.container.timer.TimerService;
import org.openremote.manager.asset.AssetStorageService;
import org.openremote.model.calendar.CalendarEvent;
-import org.openremote.model.rules.*;
+import org.openremote.model.rules.Alarms;
+import org.openremote.model.rules.AssetRuleset;
+import org.openremote.model.rules.Assets;
+import org.openremote.model.rules.HistoricDatapoints;
+import org.openremote.model.rules.Notifications;
+import org.openremote.model.rules.PredictedDatapoints;
+import org.openremote.model.rules.RealmRuleset;
+import org.openremote.model.rules.Ruleset;
+import org.openremote.model.rules.RulesetStatus;
+import org.openremote.model.rules.Users;
+import org.openremote.model.rules.Webhooks;
import org.openremote.model.rules.flow.NodeCollection;
import org.openremote.model.syslog.SyslogCategory;
import org.openremote.model.util.Pair;
import org.openremote.model.util.TextUtil;
import org.openremote.model.util.ValueUtil;
-import javax.script.*;
-import java.util.*;
-import java.util.concurrent.*;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Date;
+import java.util.List;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Future;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
import java.util.logging.Level;
import java.util.logging.Logger;
-import static org.openremote.model.rules.RulesetStatus.*;
+import static org.openremote.model.rules.RulesetStatus.COMPILATION_ERROR;
+import static org.openremote.model.rules.RulesetStatus.DEPLOYED;
+import static org.openremote.model.rules.RulesetStatus.DISABLED;
+import static org.openremote.model.rules.RulesetStatus.EMPTY;
+import static org.openremote.model.rules.RulesetStatus.VALIDITY_PERIOD_ERROR;
public class RulesetDeployment {
@@ -60,13 +76,10 @@ public class RulesetDeployment {
}
public static final int DEFAULT_RULE_PRIORITY = 1000;
- // Share one JS script engine manager, it's thread-safe
- static final protected ScriptEngineManager scriptEngineManager;
+
static final protected GroovyShell groovyShell;
static {
- scriptEngineManager = new ScriptEngineManager();
-
/* TODO Sharing a static GroovyShell doesn't work, redeploying a ruleset which defines classes (e.g. Flight) is broken:
java.lang.RuntimeException: Error evaluating condition of rule '-Update flight facts when estimated landing time of flight asset is updated':
No signature of method: org.openremote.manager.setup.database.Script1$_run_closure2$_closure14$_closure17.doCall() is applicable for argument types: (org.openremote.manager.setup.database.Flight) values: [...]
@@ -216,7 +229,8 @@ public class RulesetDeployment {
switch (ruleset.getLang()) {
case JAVASCRIPT:
- return compileRulesJavascript(ruleset, assetsFacade, usersFacade, notificationsFacade, historicDatapointsFacade, predictedDatapointsFacade);
+ LOG.warning("JavaScript not supported for ruleset: " + ruleset.getName());
+ return false;
case GROOVY:
return compileRulesGroovy(ruleset, assetsFacade, usersFacade, notificationsFacade, historicDatapointsFacade, predictedDatapointsFacade);
case JSON:
@@ -303,149 +317,6 @@ public class RulesetDeployment {
}
}
- protected boolean compileRulesJavascript(Ruleset ruleset, Assets assetsFacade, Users usersFacade, Notifications notificationsFacade, HistoricDatapoints historicDatapointsFacade, PredictedDatapoints predictedDatapointsFacade) {
- // TODO https://github.com/pfisterer/scripting-sandbox/blob/master/src/main/java/de/farberg/scripting/sandbox/ScriptingSandbox.java
- ScriptEngine scriptEngine = scriptEngineManager.getEngineByName("nashorn");
- ScriptContext newContext = new SimpleScriptContext();
- newContext.setBindings(scriptEngine.createBindings(), ScriptContext.ENGINE_SCOPE);
- Bindings engineScope = newContext.getBindings(ScriptContext.ENGINE_SCOPE);
- engineScope.put("LOG", LOG);
- engineScope.put("assets", assetsFacade);
- engineScope.put("users", usersFacade);
- engineScope.put("notifications", notificationsFacade);
- engineScope.put("historicDatapoints", historicDatapointsFacade);
- engineScope.put("predictedDatapoints", predictedDatapointsFacade);
-
- String script = ruleset.getRules();
-
- // Default header/imports for all rules scripts
- script = "load(\"nashorn:mozilla_compat.js\");\n" + // This provides importPackage
- "\n" +
- "importPackage(\n" +
- " \"java.util.stream\",\n" +
- " \"org.openremote.model.asset\",\n" +
- " \"org.openremote.model.attribute\",\n" +
- " \"org.openremote.model.value\",\n" +
- " \"org.openremote.model.rules\",\n" +
- " \"org.openremote.model.query\"\n" +
- ");\n" +
- "var Match = Java.type(\"org.openremote.model.query.AssetQuery$Match\");\n" +
- "var Operator = Java.type(\"org.openremote.model.query.AssetQuery$Operator\");\n" +
- "var NumberType = Java.type(\"org.openremote.model.query.AssetQuery$NumberType\");\n" +
- "var StringPredicate = Java.type(\"org.openremote.model.query.filter.StringPredicate\");\n" +
- "var BooleanPredicate = Java.type(\"org.openremote.model.query.filter.BooleanPredicate\");\n" +
- "var StringArrayPredicate = Java.type(\"org.openremote.model.query.filter.StringArrayPredicate\");\n" +
- "var DateTimePredicate = Java.type(\"org.openremote.model.query.filter.DateTimePredicate\");\n" +
- "var NumberPredicate = Java.type(\"org.openremote.model.query.filter.NumberPredicate\");\n" +
- "var ParentPredicate = Java.type(\"org.openremote.model.query.filter.ParentPredicate\");\n" +
- "var PathPredicate = Java.type(\"org.openremote.model.query.filter.PathPredicate\");\n" +
- "var RealmPredicate = Java.type(\"org.openremote.model.query.filter.RealmPredicate\");\n" +
- "var AttributePredicate = Java.type(\"org.openremote.model.query.filter.AttributePredicate\");\n" +
- "var AttributeExecuteStatus = Java.type(\"org.openremote.model.attribute.AttributeExecuteStatus\");\n" +
- "var EXACT = Match.EXACT;\n" +
- "var BEGIN = Match.BEGIN;\n" +
- "var END = Match.END;\n" +
- "var CONTAINS = Match.CONTAINS;\n" +
- "var EQUALS = Operator.EQUALS;\n" +
- "var GREATER_THAN = Operator.GREATER_THAN;\n" +
- "var GREATER_EQUALS = Operator.GREATER_EQUALS;\n" +
- "var LESS_THAN = Operator.LESS_THAN;\n" +
- "var LESS_EQUALS = Operator.LESS_EQUALS;\n" +
- "var BETWEEN = Operator.BETWEEN;\n" +
- "var REQUEST_START = AttributeExecuteStatus.REQUEST_START;\n" +
- "var REQUEST_REPEATING = AttributeExecuteStatus.REQUEST_REPEATING;\n" +
- "var REQUEST_CANCEL = AttributeExecuteStatus.REQUEST_CANCEL;\n" +
- "var READY = AttributeExecuteStatus.READY;\n" +
- "var COMPLETED = AttributeExecuteStatus.COMPLETED;\n" +
- "var RUNNING = AttributeExecuteStatus.RUNNING;\n" +
- "var CANCELLED = AttributeExecuteStatus.CANCELLED;\n" +
- "var ERROR = AttributeExecuteStatus.ERROR;\n" +
- "var DISABLED = AttributeExecuteStatus.DISABLED;\n" +
- "\n"
- + script;
-
- try {
- scriptEngine.eval(script, engineScope);
-
- compileRulesJavascript((ScriptObjectMirror) engineScope.get("rules"));
- return true;
-
- } catch (Exception e) {
- setError(e);
- engineScope.clear();
- return false;
- }
- }
-
- /**
- * Marshal the JavaScript rules array into {@link Rule} instances.
- */
- protected void compileRulesJavascript(ScriptObjectMirror scriptRules) {
- if (scriptRules == null || !scriptRules.isArray()) {
- throw new IllegalArgumentException("No 'rules' array defined in ruleset");
- }
- Collection<Object> rulesObjects = scriptRules.values();
- for (Object rulesObject : rulesObjects) {
- ScriptObjectMirror rule = (ScriptObjectMirror) rulesObject;
-
- String name;
- if (!rule.containsKey("name")) {
- throw new IllegalArgumentException("Missing 'name' in rule definition");
- }
- try {
- name = (String) rule.getMember("name");
- } catch (ClassCastException ex) {
- throw new IllegalArgumentException("Defined 'name' of rule is not a string");
- }
-
- String description;
- try {
- description = rule.containsKey("description") ? (String) rule.getMember("description") : null;
- } catch (ClassCastException ex) {
- throw new IllegalArgumentException("Defined 'description' is not a string in rule: " + name);
- }
-
- int priority;
- try {
- priority = rule.containsKey("priority") ? (int) rule.getMember("priority") : DEFAULT_RULE_PRIORITY;
- } catch (ClassCastException ex) {
- throw new IllegalArgumentException("Defined 'priority' is not a number in rule: " + name);
- }
-
- if (!rule.containsKey("when")) {
- throw new IllegalArgumentException("Missing 'when' function in rule: " + name);
- }
-
- Condition when;
- try {
- ScriptObjectMirror whenMirror = (ScriptObjectMirror) rule.getMember("when");
- if (!whenMirror.isFunction()) {
- throw new IllegalArgumentException("Defined 'when' is not a function in rule: " + name);
- }
- when = whenMirror.to(Condition.class);
- } catch (ClassCastException ex) {
- throw new IllegalArgumentException("Defined 'when' is not a function in rule: " + name);
- }
-
- Action then;
- try {
- ScriptObjectMirror thenMirror = (ScriptObjectMirror) rule.getMember("then");
- if (!thenMirror.isFunction()) {
- throw new IllegalArgumentException("Defined 'then' is not a function in rule: " + name);
- }
- then = thenMirror.to(Action.class);
- } catch (ClassCastException ex) {
- throw new IllegalArgumentException("Defined 'then' is not a function in rule: " + name);
- }
-
- LOG.finest("Registering javascript rule: " + name);
-
- rules.register(
- new RuleBuilder().name(name).description(description).priority(priority).when(when).then(then).build()
- );
- }
- }
-
protected boolean compileRulesGroovy(Ruleset ruleset, Assets assetsFacade, Users usersFacade, Notifications notificationFacade, HistoricDatapoints historicDatapointsFacade, PredictedDatapoints predictedDatapointsFacade) {
try {
// TODO Implement sandbox
diff --git a/test/src/test/groovy/org/openremote/test/rules/BasicRulesetResourceTest.groovy b/test/src/test/groovy/org/openremote/test/rules/BasicRulesetResourceTest.groovy
index 9fb2ce86a..3d3f32b87 100644
--- a/test/src/test/groovy/org/openremote/test/rules/BasicRulesetResourceTest.groovy
+++ b/test/src/test/groovy/org/openremote/test/rules/BasicRulesetResourceTest.groovy
@@ -16,6 +16,7 @@ import static org.openremote.manager.security.ManagerIdentityProvider.OR_ADMIN_P
import static org.openremote.manager.security.ManagerIdentityProvider.OR_ADMIN_PASSWORD_DEFAULT
import static org.openremote.model.Constants.*
import static org.openremote.model.rules.Ruleset.Lang.GROOVY
+import static org.openremote.model.rules.Ruleset.Lang.FLOW
import static org.openremote.model.rules.Ruleset.Lang.JAVASCRIPT
import static org.openremote.model.rules.Ruleset.Lang.JSON
@@ -543,7 +544,7 @@ class BasicRulesetResourceTest extends Specification implements ManagerContainer
ex.response.status == 403
when: "a realm ruleset is created in a non-authenticated realm"
- realmRuleset = new RealmRuleset(keycloakTestSetup.realmBuilding.name, "Test realm definition", JAVASCRIPT, "SomeRulesCode")
+ realmRuleset = new RealmRuleset(keycloakTestSetup.realmBuilding.name, "Test realm definition", FLOW, "SomeRulesCode")
rulesetResource.createRealmRuleset(null, realmRuleset)
then: "access should be forbidden"
@@ -551,7 +552,7 @@ class BasicRulesetResourceTest extends Specification implements ManagerContainer
ex.response.status == 403
when: "an asset ruleset is created in the authenticated realm"
- def assetRuleset = new AssetRuleset(managerTestSetup.smartOfficeId, "Test asset definition", JAVASCRIPT, "SomeRulesCode")
+ def assetRuleset = new AssetRuleset(managerTestSetup.smartOfficeId, "Test asset definition", FLOW, "SomeRulesCode")
rulesetResource.createAssetRuleset(null, assetRuleset)
rulesetId = rulesetResource.getAssetRulesets(null, managerTestSetup.smartOfficeId, null, false)[0].id
assetRuleset = rulesetResource.getAssetRuleset(null, rulesetId)
@@ -899,7 +900,7 @@ class BasicRulesetResourceTest extends Specification implements ManagerContainer
ex.response.status == 404
when: "a realm ruleset is created in a non-authenticated realm"
- realmRuleset = new RealmRuleset(keycloakTestSetup.realmCity.name, "Test realm definition", JAVASCRIPT, "SomeRulesCode")
+ realmRuleset = new RealmRuleset(keycloakTestSetup.realmCity.name, "Test realm definition", FLOW, "SomeRulesCode")
rulesetResource.createRealmRuleset(null, realmRuleset)
then: "access should be forbidden"
@@ -910,7 +911,7 @@ class BasicRulesetResourceTest extends Specification implements ManagerContainer
def assetRuleset = new AssetRuleset(
managerTestSetup.apartment1Id,
"Test asset definition",
- JAVASCRIPT, "SomeRulesCode")
+ FLOW, "SomeRulesCode")
rulesetResource.createAssetRuleset(null, assetRuleset)
def rulesetId = rulesetResource.getAssetRulesets(null, managerTestSetup.apartment1Id, null, false)[1].id
assetRuleset = rulesetResource.getAssetRuleset(null, rulesetId)
@@ -1000,7 +1001,7 @@ class BasicRulesetResourceTest extends Specification implements ManagerContainer
}
when: "an asset ruleset is created in the authenticated realm but on a forbidden asset"
- assetRuleset = new AssetRuleset(managerTestSetup.apartment3Id, "Test asset definition", JAVASCRIPT, "SomeRulesCode")
+ assetRuleset = new AssetRuleset(managerTestSetup.apartment3Id, "Test asset definition", FLOW, "SomeRulesCode")
rulesetResource.createAssetRuleset(null, assetRuleset)
then: "access should be forbidden"
@@ -1008,7 +1009,7 @@ class BasicRulesetResourceTest extends Specification implements ManagerContainer
ex.response.status == 403
when: "an asset ruleset is created in a non-authenticated realm"
- assetRuleset = new AssetRuleset(managerTestSetup.smartOfficeId, "Test asset definition", JAVASCRIPT, "SomeRulesCode")
+ assetRuleset = new AssetRuleset(managerTestSetup.smartOfficeId, "Test asset definition", FLOW, "SomeRulesCode")
rulesetResource.createAssetRuleset(null, assetRuleset)
then: "access should be forbidden"
@@ -1016,4 +1017,191 @@ class BasicRulesetResourceTest extends Specification implements ManagerContainer
ex.response.status == 403
}
+
+ def "JavaScript ruleset create requests are rejected"() {
+
+ given: "the server container is started"
+ def container = startContainer(defaultConfig(), defaultServices())
+ def managerTestSetup = container.getService(SetupService.class).getTaskOfType(ManagerTestSetup.class)
+
+ and: "an authenticated admin user"
+ def accessToken = authenticate(
+ container,
+ MASTER_REALM,
+ KEYCLOAK_CLIENT_ID,
+ MASTER_REALM_ADMIN_USER,
+ getString(container.getConfig(), OR_ADMIN_PASSWORD, OR_ADMIN_PASSWORD_DEFAULT)
+ ).token
+
+ and: "the ruleset resource"
+ def rulesetResource = getClientApiTarget(serverUri(serverPort), MASTER_REALM, accessToken).proxy(RulesResource.class)
+
+ when: "a global JavaScript ruleset is created"
+ rulesetResource.createGlobalRuleset(null, new GlobalRuleset("Test JS global definition", JAVASCRIPT, "SomeRulesCode"))
+
+ then: "the request should be rejected"
+ WebApplicationException ex = thrown()
+ ex.response.status == 400
+
+ when: "a realm JavaScript ruleset is created"
+ rulesetResource.createRealmRuleset(null, new RealmRuleset(MASTER_REALM, "Test JS realm definition", JAVASCRIPT, "SomeRulesCode"))
+
+ then: "the request should be rejected"
+ ex = thrown()
+ ex.response.status == 400
+
+ when: "an asset JavaScript ruleset is created"
+ rulesetResource.createAssetRuleset(null, new AssetRuleset(managerTestSetup.smartOfficeId, "Test JS asset definition", JAVASCRIPT, "SomeRulesCode"))
+
+ then: "the request should be rejected"
+ ex = thrown()
+ ex.response.status == 400
+ }
+
+ def "JavaScript ruleset update requests are rejected"() {
+
+ given: "the server container is started"
+ def container = startContainer(defaultConfig(), defaultServices())
+ def rulesetStorageService = container.getService(RulesetStorageService.class)
+ def managerTestSetup = container.getService(SetupService.class).getTaskOfType(ManagerTestSetup.class)
+
+ and: "an authenticated admin user"
+ def accessToken = authenticate(
+ container,
+ MASTER_REALM,
+ KEYCLOAK_CLIENT_ID,
+ MASTER_REALM_ADMIN_USER,
+ getString(container.getConfig(), OR_ADMIN_PASSWORD, OR_ADMIN_PASSWORD_DEFAULT)
+ ).token
+
+ and: "the ruleset resource"
+ def rulesetResource = getClientApiTarget(serverUri(serverPort), MASTER_REALM, accessToken).proxy(RulesResource.class)
+
+ and: "existing rulesets are stored directly"
+ def globalRuleset = rulesetStorageService.merge(new GlobalRuleset("Test global definition", JSON, "SomeRulesCode"))
+ def realmRuleset = rulesetStorageService.merge(new RealmRuleset(MASTER_REALM, "Test JS realm definition", JAVASCRIPT, "SomeRulesCode"))
+ def assetRuleset = rulesetStorageService.merge(new AssetRuleset(managerTestSetup.smartOfficeId, "Test JS asset definition", JAVASCRIPT, "SomeRulesCode"))
+
+ when: "a stored global ruleset is updated to JavaScript"
+ def updatedGlobalRuleset = rulesetResource.getGlobalRuleset(null, globalRuleset.id)
+ updatedGlobalRuleset.lang = JAVASCRIPT
+ updatedGlobalRuleset.rules = "SomeRulesCodeModified"
+ rulesetResource.updateGlobalRuleset(null, globalRuleset.id, updatedGlobalRuleset)
+
+ then: "the request should be rejected"
+ WebApplicationException ex = thrown()
+ ex.response.status == 400
+
+ when: "a stored JavaScript realm ruleset is updated to a non-JavaScript language"
+ def updatedRealmRuleset = rulesetResource.getRealmRuleset(null, realmRuleset.id)
+ updatedRealmRuleset.lang = JSON
+ updatedRealmRuleset.rules = "SomeRulesCodeModified"
+ rulesetResource.updateRealmRuleset(null, realmRuleset.id, updatedRealmRuleset)
+
+ then: "the request should be rejected"
+ ex = thrown()
+ ex.response.status == 400
+
+ when: "a stored JavaScript asset ruleset is updated to a non-JavaScript language"
+ def updatedAssetRuleset = rulesetResource.getAssetRuleset(null, assetRuleset.id)
+ updatedAssetRuleset.lang = FLOW
+ updatedAssetRuleset.rules = "SomeRulesCodeModified"
+ rulesetResource.updateAssetRuleset(null, assetRuleset.id, updatedAssetRuleset)
+
+ then: "the request should be rejected"
+ ex = thrown()
+ ex.response.status == 400
+ }
+
+ def "Legacy JavaScript rulesets remain readable and deletable"() {
+
+ given: "the server container is started"
+ def container = startContainer(defaultConfig(), defaultServices())
+ def rulesetStorageService = container.getService(RulesetStorageService.class)
+ def managerTestSetup = container.getService(SetupService.class).getTaskOfType(ManagerTestSetup.class)
+
+ and: "an authenticated admin user"
+ def accessToken = authenticate(
+ container,
+ MASTER_REALM,
+ KEYCLOAK_CLIENT_ID,
+ MASTER_REALM_ADMIN_USER,
+ getString(container.getConfig(), OR_ADMIN_PASSWORD, OR_ADMIN_PASSWORD_DEFAULT)
+ ).token
+
+ and: "the ruleset resource"
+ def rulesetResource = getClientApiTarget(serverUri(serverPort), MASTER_REALM, accessToken).proxy(RulesResource.class)
+
+ and: "legacy JavaScript rulesets are stored directly"
+ def globalRuleset = rulesetStorageService.merge(new GlobalRuleset("Legacy JS global definition", JAVASCRIPT, "SomeRulesCode"))
+ def realmRuleset = rulesetStorageService.merge(new RealmRuleset(MASTER_REALM, "Legacy JS realm definition", JAVASCRIPT, "SomeRulesCode"))
+ def assetRuleset = rulesetStorageService.merge(new AssetRuleset(managerTestSetup.smartOfficeId, "Legacy JS asset definition", JAVASCRIPT, "SomeRulesCode"))
+
+ when: "legacy JavaScript rulesets are listed"
+ def globalRulesets = rulesetResource.getGlobalRulesets(null, null, false)
+ def realmRulesets = rulesetResource.getRealmRulesets(null, MASTER_REALM, null, false)
+ def assetRulesets = rulesetResource.getAssetRulesets(null, managerTestSetup.smartOfficeId, null, false)
+
+ then: "they remain visible in list endpoints"
+ def listedGlobalRuleset = globalRulesets.find { it.id == globalRuleset.id }
+ def listedRealmRuleset = realmRulesets.find { it.id == realmRuleset.id }
+ def listedAssetRuleset = assetRulesets.find { it.id == assetRuleset.id }
+
+ listedGlobalRuleset != null
+ listedGlobalRuleset.lang == JAVASCRIPT
+ listedGlobalRuleset.name == "Legacy JS global definition"
+ listedGlobalRuleset.rules == null
+
+ listedRealmRuleset != null
+ listedRealmRuleset.lang == JAVASCRIPT
+ listedRealmRuleset.name == "Legacy JS realm definition"
+ listedRealmRuleset.rules == null
+
+ listedAssetRuleset != null
+ listedAssetRuleset.lang == JAVASCRIPT
+ listedAssetRuleset.name == "Legacy JS asset definition"
+ listedAssetRuleset.rules == null
+
+ when: "legacy JavaScript rulesets are fetched"
+ def fetchedGlobalRuleset = rulesetResource.getGlobalRuleset(null, globalRuleset.id)
+ def fetchedRealmRuleset = rulesetResource.getRealmRuleset(null, realmRuleset.id)
+ def fetchedAssetRuleset = rulesetResource.getAssetRuleset(null, assetRuleset.id)
+
+ then: "they remain readable through detail endpoints"
+ fetchedGlobalRuleset.lang == JAVASCRIPT
+ fetchedGlobalRuleset.rules == "SomeRulesCode"
+ fetchedRealmRuleset.lang == JAVASCRIPT
+ fetchedRealmRuleset.rules == "SomeRulesCode"
+ fetchedAssetRuleset.lang == JAVASCRIPT
+ fetchedAssetRuleset.rules == "SomeRulesCode"
+
+ when: "legacy JavaScript rulesets are deleted"
+ rulesetResource.deleteGlobalRuleset(null, globalRuleset.id)
+ rulesetResource.deleteRealmRuleset(null, realmRuleset.id)
+ rulesetResource.deleteAssetRuleset(null, assetRuleset.id)
+
+ then: "the delete requests succeed"
+ notThrown(WebApplicationException)
+
+ when: "a deleted global ruleset is fetched"
+ rulesetResource.getGlobalRuleset(null, globalRuleset.id)
+
+ then: "it is no longer found"
+ WebApplicationException ex = thrown()
+ ex.response.status == 404
+
+ when: "a deleted realm ruleset is fetched"
+ rulesetResource.getRealmRuleset(null, realmRuleset.id)
+
+ then: "it is no longer found"
+ ex = thrown()
+ ex.response.status == 404
+
+ when: "a deleted asset ruleset is fetched"
+ rulesetResource.getAssetRuleset(null, assetRuleset.id)
+
+ then: "it is no longer found"
+ ex = thrown()
+ ex.response.status == 404
+ }
}
diff --git a/test/src/test/groovy/org/openremote/test/rules/residence/ResidenceAllLightsOffTest.groovy b/test/src/test/groovy/org/openremote/test/rules/residence/ResidenceAllLightsOffTest.groovy
deleted file mode 100644
index d649563a4..000000000
--- a/test/src/test/groovy/org/openremote/test/rules/residence/ResidenceAllLightsOffTest.groovy
+++ /dev/null
@@ -1,97 +0,0 @@
-package org.openremote.test.rules.residence
-
-import org.openremote.manager.asset.AssetProcessingService
-import org.openremote.manager.asset.AssetStorageService
-import org.openremote.manager.rules.RulesEngine
-import org.openremote.manager.rules.RulesService
-import org.openremote.manager.rules.RulesetStorageService
-import org.openremote.manager.setup.SetupService
-import org.openremote.setup.integration.ManagerTestSetup
-import org.openremote.model.attribute.AttributeEvent
-import org.openremote.model.rules.AssetRuleset
-import org.openremote.model.rules.Ruleset
-import org.openremote.test.ManagerContainerTrait
-import spock.lang.Ignore
-import spock.lang.Specification
-import spock.util.concurrent.PollingConditions
-
-import static java.util.concurrent.TimeUnit.SECONDS
-import static org.openremote.setup.integration.ManagerTestSetup.DEMO_RULE_STATES_APARTMENT_2
-
-@Ignore
-class ResidenceAllLightsOffTest extends Specification implements ManagerContainerTrait {
-
- def "Turn all lights off"() {
-
- given: "the container environment is started"
- def conditions = new PollingConditions(timeout: 10, delay: 0.2)
- def container = startContainer(defaultConfig(), defaultServices())
- def managerTestSetup = container.getService(SetupService.class).getTaskOfType(ManagerTestSetup.class)
- def rulesService = container.getService(RulesService.class)
- def rulesetStorageService = container.getService(RulesetStorageService.class)
- def assetProcessingService = container.getService(AssetProcessingService.class)
- def assetStorageService = container.getService(AssetStorageService.class)
- RulesEngine apartment2Engine
-
- and: "some rules"
- Ruleset ruleset = new AssetRuleset(
- managerTestSetup.apartment2Id,
- "Demo Apartment - All Lights Off",
- Ruleset.Lang.JAVASCRIPT,
- getClass().getResource("/org/openremote/test/rules/ResidenceAllLightsOff.js").text)
- rulesetStorageService.merge(ruleset)
-
- expect: "the rule engines to become available and be running"
- conditions.eventually {
- apartment2Engine = rulesService.assetEngines.get(managerTestSetup.apartment2Id)
- assert apartment2Engine != null
- assert apartment2Engine.isRunning()
- }
-
- and: "the demo attributes marked with RULE_STATE = true meta should be inserted into the engines"
- conditions.eventually {
- assert apartment2Engine.facts.assetStates.size() == DEMO_RULE_STATES_APARTMENT_2
- }
-
- and: "the room lights in an apartment to be on"
- conditions.eventually {
- def livingroomAsset = assetStorageService.find(managerTestSetup.apartment2LivingroomId, true)
- assert livingroomAsset.getAttribute("lightSwitch").get().value.get()
- def bathRoomAsset = assetStorageService.find(managerTestSetup.apartment2BathroomId, true)
- assert bathRoomAsset.getAttribute("lightSwitch").get().value.get()
- }
-
- when: "the ALL LIGHTS OFF push-button is pressed for an apartment"
- def lightsOffEvent = new AttributeEvent(
- managerTestSetup.apartment2Id, "allLightsOffSwitch", true
- )
- assetProcessingService.sendAttributeEvent(lightsOffEvent)
-
- then: "the room lights in the apartment should be off"
- conditions.eventually {
- assert apartment2Engine.facts.assetStates.size() == DEMO_RULE_STATES_APARTMENT_2
- assert apartment2Engine.facts.assetEvents.size() == 1
- def livingroomAsset = assetStorageService.find(managerTestSetup.apartment2LivingroomId, true)
- assert !livingroomAsset.getAttribute("lightSwitch").get().value.get()
- def bathRoomAsset = assetStorageService.find(managerTestSetup.apartment2BathroomId, true)
- assert !bathRoomAsset.getAttribute("lightSwitch").get().value.get()
- }
-
- when: "time advanced by 15 seconds"
- advancePseudoClock(15, SECONDS, container)
-
- and: "we turn the light on again in a room"
- assetProcessingService.sendAttributeEvent(
- new AttributeEvent(managerTestSetup.apartment2LivingroomId, "lightSwitch", true)
- )
-
- then: "the light should still be on after a few seconds (the all lights off event expires after 3 seconds)"
- new PollingConditions(timeout: 5, initialDelay: 3).eventually {
- assert apartment2Engine.facts.assetStates.size() == DEMO_RULE_STATES_APARTMENT_2
- assert apartment2Engine.facts.assetEvents.size() == 0
- def livingroomAsset = assetStorageService.find(managerTestSetup.apartment2LivingroomId, true)
- assert livingroomAsset.getAttribute("lightSwitch").get().value.get()
- }
-
- }
-}
diff --git a/test/src/test/resources/org/openremote/test/rules/ResidenceAllLightsOff.js b/test/src/test/resources/org/openremote/test/rules/ResidenceAllLightsOff.js
deleted file mode 100644
index 603086781..000000000
--- a/test/src/test/resources/org/openremote/test/rules/ResidenceAllLightsOff.js
+++ /dev/null
@@ -1,41 +0,0 @@
-rules = [{
- name: "Switch room lights off when residence ALL LIGHTS OFF push-button is pressed",
- when: function (facts) {
-
- var roomWithLightOn = facts.matchFirstAssetState( // Find asset state
- new AssetQuery()
- .types(ROOM) // for a room
- .attributeValue("lightSwitch", true) // where the light switch is on
- );
-
- // If we have a room where the light is on
- if (roomWithLightOn.isPresent()) {
- var room = roomWithLightOn.get();
-
- var residenceWithLightOff = facts.matchFirstAssetEvent( // Find asset event
- new AssetQuery()
- .types(AssetType.RESIDENCE) // for a residence
- .ids(room.parentId) // that is the parent asset of the room
- .attributeValue("allLightsOffSwitch", true) // where the "all lights off" switch has been triggered
- );
-
- // If we have a residence where the light has been switched off
- if (residenceWithLightOff.isPresent()) {
-
- // Store the room for RHS consumption
- facts.bind("roomId", room.id);
-
- // Trigger the action
- return true;
- }
- }
- return false;
-
- },
- then: function (facts) {
- // Turn the light off in the room
- facts.updateAssetState(
- facts.bound("roomId"), "lightSwitch", false
- );
- }
-}];
diff --git a/ui/app/manager/test/rules.test.ts b/ui/app/manager/test/rules.test.ts
index 2794798d8..5f52c1863 100644
--- a/ui/app/manager/test/rules.test.ts
+++ b/ui/app/manager/test/rules.test.ts
@@ -2,10 +2,89 @@ import {expect} from "@openremote/test";
import {test, userStatePath} from "./fixtures/manager.js";
import {preparedAssetsForRules as assets} from "./fixtures/data/assets.js";
import {energyRule} from "./fixtures/data/rules.js";
-import {Asset} from "@openremote/model";
+import {Asset, RealmRuleset, RulesetLang} from "@openremote/model";
test.use({storageState: userStatePath});
+function createRealmRule(rule: Partial<RealmRuleset> & Pick<RealmRuleset, "id" | "name" | "lang">): RealmRuleset {
+ return {
+ type: "realm",
+ id: rule.id,
+ version: rule.version ?? 0,
+ realm: rule.realm ?? "smartcity",
+ enabled: rule.enabled ?? true,
+ name: rule.name,
+ lang: rule.lang,
+ rules: rule.rules ?? "SomeRulesCode",
+ meta: rule.meta,
+ status: rule.status,
+ error: rule.error,
+ accessPublicRead: rule.accessPublicRead,
+ };
+}
+
+async function mockRealmRulesApi(page: any, initialRules: RealmRuleset[]) {
+ let rules = [...initialRules];
+ let deleteRequests = 0;
+ let postRequests = 0;
+ let putRequests = 0;
+
+ await page.route("**/api/**/rules/realm**", async (route: any) => {
+ const request = route.request();
+ const method = request.method();
+ const url = new URL(request.url());
+
+ if (method === "GET") {
+ if (/\/rules\/realm\/\d+$/.test(url.pathname)) {
+ const id = Number(url.pathname.split("/").pop());
+ const rule = rules.find((r) => r.id === id);
+ await route.fulfill(rule ? { status: 200, json: rule } : { status: 404, json: { message: "Not found" } });
+ return;
+ }
+
+ await route.fulfill({ status: 200, json: rules });
+ return;
+ }
+
+ if (method === "DELETE") {
+ deleteRequests += 1;
+ const id = Number(url.pathname.split("/").pop());
+ rules = rules.filter((rule) => rule.id !== id);
+ await route.fulfill({ status: 204, body: "" });
+ return;
+ }
+
+ if (method === "POST") {
+ postRequests += 1;
+ await route.fulfill({ status: 500, json: { message: "Unexpected create request" } });
+ return;
+ }
+
+ if (method === "PUT") {
+ putRequests += 1;
+ await route.fulfill({ status: 500, json: { message: "Unexpected update request" } });
+ return;
+ }
+
+ await route.fallback();
+ });
+
+ return {
+ get deleteRequests() {
+ return deleteRequests;
+ },
+ get postRequests() {
+ return postRequests;
+ },
+ get putRequests() {
+ return putRequests;
+ },
+ get rules() {
+ return rules;
+ }
+ };
+}
+
/**
* Simple function that generates assets based on {@link assets}
* @param multiplier - Amount of assets to generate per asset type
@@ -196,6 +275,115 @@ test("Create a Flow rule for an asset with logic connections", async ({page, sha
await expect(page.locator("or-rule-tree").getByText("Solar panel")).toHaveCount(1);
});
+test("Legacy JavaScript rules are visible but read-only in the rules UI", async ({page, manager}) => {
+ const legacyJavascriptRule = createRealmRule({
+ id: 71001,
+ name: "Legacy JS rule",
+ lang: RulesetLang.JAVASCRIPT,
+ rules: "console.log('legacy');"
+ });
+ const api = await mockRealmRulesApi(page, [legacyJavascriptRule]);
+
+ await manager.setup("smartcity");
+ await manager.goToRealmStartPage("smartcity");
+ await manager.navigateToTab("Rules");
+
+ await expect(page.locator("or-rule-tree").getByText(legacyJavascriptRule.name!)).toHaveCount(1);
+ await page.locator("or-rule-tree").getByText(legacyJavascriptRule.name!).click();
+
+ await expect(page.locator("or-rule-viewer")).toContainText("JavaScript rules are legacy and can only be viewed or deleted.");
+ await expect(page.getByRole("button", {name: "Save"})).toBeDisabled();
+ await expect(page.locator("or-rule-tree").locator("or-mwc-input[icon='content-copy']")).toHaveCount(0);
+
+ await page.click(".mdi-plus >> nth=0");
+ await expect(page.locator("li").filter({hasText: "JavaScript"})).toHaveCount(0);
+
+ expect(api.postRequests).toBe(0);
+ expect(api.putRequests).toBe(0);
+});
+
+test("Legacy JavaScript rules can still be deleted from the rules UI", async ({page, manager}) => {
+ const legacyJavascriptRule = createRealmRule({
+ id: 71002,
+ name: "Legacy JS deletable rule",
+ lang: RulesetLang.JAVASCRIPT,
+ rules: "console.log('delete me');"
+ });
+ const api = await mockRealmRulesApi(page, [legacyJavascriptRule]);
+
+ await manager.setup("smartcity");
+ await manager.goToRealmStartPage("smartcity");
+ await manager.navigateToTab("Rules");
+
+ await page.locator("or-rule-tree").getByText(legacyJavascriptRule.name!).click();
+ await page.locator("or-rule-tree").locator("or-mwc-input[icon='delete']").click();
+ await page.getByRole("button", {name: "Delete"}).click();
+
+ await expect(page.locator("or-rule-tree").getByText(legacyJavascriptRule.name!)).toHaveCount(0);
+ expect(api.deleteRequests).toBe(1);
+});
+
+test("Groups containing legacy JavaScript rules cannot be renamed", async ({page, manager}) => {
+ const groupedLegacyJavascriptRule = createRealmRule({
+ id: 71003,
+ name: "Legacy JS grouped rule",
+ lang: RulesetLang.JAVASCRIPT,
+ meta: {groupId: "Legacy JS group"},
+ rules: "console.log('grouped');"
+ });
+ const api = await mockRealmRulesApi(page, [groupedLegacyJavascriptRule]);
+
+ await manager.setup("smartcity");
+ await manager.goToRealmStartPage("smartcity");
+ await manager.navigateToTab("Rules");
+
+ await expect(page.locator("or-rule-tree").getByText("Legacy JS group", { exact: true })).toHaveCount(1);
+ await page.locator("or-rule-tree").getByText("Legacy JS group", { exact: true }).click();
+ await page.getByRole("textbox", { name: "Group name"}).fill("Renamed JS group");
+ await page.getByRole("button", {name: "Save"}).isDisabled();
+ expect(api.putRequests).toBe(0);
+});
+
+test("Dragging a legacy JavaScript rule is blocked", async ({page, manager}) => {
+ const legacyJavascriptRule = createRealmRule({
+ id: 71004,
+ name: "Legacy JS drag rule",
+ lang: RulesetLang.JAVASCRIPT,
+ rules: "console.log('drag');"
+ });
+ const api = await mockRealmRulesApi(page, [legacyJavascriptRule]);
+
+ await manager.setup("smartcity");
+ await manager.goToRealmStartPage("smartcity");
+ await manager.navigateToTab("Rules");
+
+ await expect(page.locator("or-rule-tree").getByText(legacyJavascriptRule.name!)).toHaveCount(1);
+
+ const dispatchSucceeded = await page.locator("or-rules").evaluate((element, ruleName) => {
+ const tree = element.shadowRoot?.querySelector("or-rule-tree") as any;
+ const rule = tree?.rules?.find((candidate: any) => candidate.name === ruleName);
+
+ if (!rule) {
+ throw new Error(`Could not find ruleset '${ruleName}' in tree state`);
+ }
+
+ return element.dispatchEvent(new CustomEvent("or-tree-drag", {
+ bubbles: true,
+ composed: true,
+ cancelable: true,
+ detail: {
+ nodes: [{id: String(rule.id), label: rule.name, ruleset: rule}],
+ groupNode: {id: "Target Group", label: "Target Group", children: []},
+ newNodes: []
+ }
+ }));
+ }, legacyJavascriptRule.name!);
+
+ expect(dispatchSucceeded).toBe(false);
+ await expect(page.locator("or-mwc-snackbar")).toContainText("JavaScript rules are legacy and cannot be updated.");
+ expect(api.putRequests).toBe(0);
+});
+
test.afterEach(async ({manager}) => {
await manager.cleanUp();
});
diff --git a/ui/app/shared/locales/en/or.json b/ui/app/shared/locales/en/or.json
index b6d883046..366b42eb5 100644
--- a/ui/app/shared/locales/en/or.json
+++ b/ui/app/shared/locales/en/or.json
@@ -107,6 +107,9 @@
"deleteRulesetGroupsConfirm": "Are you sure you want to delete the selected group(s)? {{groupNames}}",
"saveRulesetFailed": "Failed to save rule",
"confirmContinueRulesetModified": "Rule has been modified, discard changes?",
+ "rulesLegacyJavaScriptWarning": "JavaScript rules are legacy and can only be viewed or deleted.",
+ "rulesLegacyJavaScriptUpdate": "JavaScript rules are legacy and cannot be updated.",
+ "rulesLegacyJavaScriptRename": "Groups containing JavaScript rules cannot be renamed.",
"when": "When",
"then": "Then",
"orWhen": "Or when",
diff --git a/ui/component/or-components/src/or-ace-editor.ts b/ui/component/or-components/src/or-ace-editor.ts
index fb00bb3c0..b0286ff68 100644
--- a/ui/component/or-components/src/or-ace-editor.ts
+++ b/ui/component/or-components/src/or-ace-editor.ts
@@ -105,6 +105,10 @@ export class OrAceEditor extends LitElement {
this._aceEditor.setValue(this._lastValue);
}
}
+
+ if (_changedProperties.has("readonly") && this._aceEditor) {
+ this._aceEditor.setReadOnly(!!this.readonly);
+ }
}
render(): TemplateResult | void {
diff --git a/ui/component/or-rules/src/index.ts b/ui/component/or-rules/src/index.ts
index 75bbc87ac..069df146f 100644
--- a/ui/component/or-rules/src/index.ts
+++ b/ui/component/or-rules/src/index.ts
@@ -738,7 +738,9 @@ export class OrRulesDeleteEvent extends CustomEvent<RulesetUnion[]> {
}
}
-export class OrRulesGroupNameChangeEvent extends CustomEvent<{ value: string }> {
+export type OrRulesGroupNameChangeReason = "exists" | "legacyJavascript";
+
+export class OrRulesGroupNameChangeEvent extends CustomEvent<{ value: string, reason?: OrRulesGroupNameChangeReason }> {
public static readonly NAME = "or-rules-group-name-change";
@@ -748,7 +750,8 @@ export class OrRulesGroupNameChangeEvent extends CustomEvent<{ value: string }>
composed: true,
cancelable: true,
detail: {
- value: name
+ value: name,
+ reason: undefined
}
});
}
@@ -893,6 +896,14 @@ export class OrRules extends translate(i18next)(LitElement) {
return this.readonly || !manager.hasRole(ClientRole.WRITE_RULES);
}
+ protected _isLegacyJavascriptRuleset(ruleset?: RulesetUnion) {
+ return ruleset?.lang === RulesetLang.JAVASCRIPT;
+ }
+
+ protected _containsLegacyJavascriptRuleset(rulesets?: (RulesetUnion | undefined)[]) {
+ return !!rulesets?.some(ruleset => this._isLegacyJavascriptRuleset(ruleset));
+ }
+
protected _confirmContinue(action: (ok: boolean) => void) {
if (this._viewer?.modified) {
showOkCancelDialog(i18next.t("loseChanges"), i18next.t("confirmContinueRulesetModified"), i18next.t("discard"))
@@ -1054,6 +1065,14 @@ export class OrRules extends translate(i18next)(LitElement) {
protected _onRuleDrag(ev: OrTreeDragEvent) {
const isModified = this._viewer?.modified;
const groupId = ev.detail.groupNode?.label;
+ const draggedRulesets = (ev.detail.nodes as RuleTreeNode[])
+ .flatMap(node => node.ruleset ? [node.ruleset] : []);
+
+ if (this._containsLegacyJavascriptRuleset(draggedRulesets)) {
+ ev.preventDefault();
+ showSnackbar(undefined, "rulesLegacyJavaScriptUpdate");
+ return;
+ }
const moveAndSave = (ruleset: RulesetUnion, groupId?: string) => {
move(ruleset, groupId);
@@ -1131,19 +1150,28 @@ export class OrRules extends translate(i18next)(LitElement) {
protected _onGroupNameChange(ev: OrRulesGroupNameChangeEvent) {
const oldValue = this._selectedGroup;
const newValue = ev.detail.value;
+ const groupRules = this._rulesTree?.rules?.filter(r => r.meta?.groupId === oldValue);
// If the group name already exists, we should prevent the event from happening
if(this._rulesTree?.nodes.find(n => n.label === newValue)) {
console.warn(`The group '${newValue}' already exists. Please try again.`);
+ ev.detail.reason = "exists";
ev.preventDefault();
return;
}
+ if (this._containsLegacyJavascriptRuleset(groupRules)) {
+ console.warn(`Prevented renaming group '${oldValue}' because it contains legacy JavaScript rules.`);
+ ev.detail.reason = "legacyJavascript";
+ ev.preventDefault();
+ showSnackbar(undefined, "rulesLegacyJavaScriptRename");
+ return;
+ }
+
console.debug(`Renaming group '${oldValue}' to '${newValue}'`)
// Change the groupId for each child rule, and prepare an HTTP API update
const promises: Promise<any>[] = [];
- const groupRules = this._rulesTree?.rules?.filter(r => r.meta?.groupId === oldValue);
groupRules?.forEach((r) => {
r.meta!.groupId = newValue;
promises.push(this._saveRuleset(r));
@@ -1178,6 +1206,10 @@ export class OrRules extends translate(i18next)(LitElement) {
* @param ruleset - The ruleset to be saved
*/
protected async _saveRuleset(ruleset: RulesetUnion){
+ if (this._isLegacyJavascriptRuleset(ruleset)) {
+ throw new Error(i18next.t("rulesLegacyJavaScriptUpdate"));
+ }
+
let promise;
switch (ruleset.type) {
case "asset": {
diff --git a/ui/component/or-rules/src/or-rule-group-viewer.ts b/ui/component/or-rules/src/or-rule-group-viewer.ts
index c6d8507cb..ae9496316 100644
--- a/ui/component/or-rules/src/or-rule-group-viewer.ts
+++ b/ui/component/or-rules/src/or-rule-group-viewer.ts
@@ -87,10 +87,11 @@ export class OrRuleGroupViewer extends translate(i18next)(LitElement) {
protected _onSaveClicked(): void {
if(this.group && !this._cannotSave()) {
- const success = this.dispatchEvent(new OrRulesGroupNameChangeEvent(this.group));
+ const event = new OrRulesGroupNameChangeEvent(this.group);
+ const success = this.dispatchEvent(event);
if(success) {
this._lastSaved = this.group;
- } else {
+ } else if (event.detail.reason === "exists" || !event.detail.reason) {
showSnackbar(undefined, 'ruleGroupExistsError');
}
}
diff --git a/ui/component/or-rules/src/or-rule-text-viewer.ts b/ui/component/or-rules/src/or-rule-text-viewer.ts
index 31e80530d..89c2e98ed 100644
--- a/ui/component/or-rules/src/or-rule-text-viewer.ts
+++ b/ui/component/or-rules/src/or-rule-text-viewer.ts
@@ -93,7 +93,7 @@ export class OrRuleTextViewer extends LitElement implements RuleView {
protected render(): TemplateResult | void {
return html`
- <or-ace-editor ${ref(this._aceEditor)} @or-ace-editor-changed="${(ev: OrAceEditorChangedEvent) => this._onEditorChanged(ev)}" .mode="${this._getMode()}" .value="${this._getRulesString()}"></or-ace-editor>
+ <or-ace-editor ${ref(this._aceEditor)} @or-ace-editor-changed="${(ev: OrAceEditorChangedEvent) => this._onEditorChanged(ev)}" .mode="${this._getMode()}" .readonly="${this.readonly}" .value="${this._getRulesString()}"></or-ace-editor>
`;
}
@@ -128,7 +128,7 @@ export class OrRuleTextViewer extends LitElement implements RuleView {
}
public beforeSave() {
- if (!this._aceEditor.value) {
+ if (this.readonly || !this._aceEditor.value) {
return;
}
diff --git a/ui/component/or-rules/src/or-rule-tree.ts b/ui/component/or-rules/src/or-rule-tree.ts
index cb59ae8be..6a9e8a30a 100644
--- a/ui/component/or-rules/src/or-rule-tree.ts
+++ b/ui/component/or-rules/src/or-rule-tree.ts
@@ -75,7 +75,7 @@ export enum RuleTreeSorting {
@customElement("or-rule-tree")
export class OrRuleTree extends OrTreeMenu {
- public static DEFAULT_ALLOWED_LANGUAGES = [RulesetLang.JSON, RulesetLang.GROOVY, RulesetLang.JAVASCRIPT, RulesetLang.FLOW];
+ public static DEFAULT_ALLOWED_LANGUAGES = [RulesetLang.JSON, RulesetLang.GROOVY, RulesetLang.FLOW];
/**
* List of rules visible in the tree menu
@@ -197,7 +197,7 @@ export class OrRuleTree extends OrTreeMenu {
</h3>
<div id="tree-header-actions">
${when((this._selectedTypes.size === 1 && this._selectedTypes.has('ruleset')) && !this.readonly, () => html`
- ${when(this._findSelectedTreeNodes().length === 1, () => html`
+ ${when(this._findSelectedTreeNodes().length === 1 && !this._isSelectedLegacyJavascriptRuleset(), () => html`
<or-mwc-input type=${InputType.BUTTON} icon="content-copy" @or-mwc-input-changed=${this._onCopyClicked}></or-mwc-input>
`)}
<or-mwc-input type=${InputType.BUTTON} icon="delete" @or-mwc-input-changed=${this._onDeleteClicked}></or-mwc-input>
@@ -232,6 +232,10 @@ export class OrRuleTree extends OrTreeMenu {
}
const node = selected[0];
+ if (this._isLegacyJavascriptRuleset(node.ruleset)) {
+ return;
+ }
+
const ruleset = JSON.parse(JSON.stringify(node.ruleset)) as RulesetUnion;
delete ruleset.lastModified;
delete ruleset.createdOn;
@@ -463,6 +467,10 @@ export class OrRuleTree extends OrTreeMenu {
* @param global - Whether to create a global ruleset or not.
*/
protected _onRulesetAddClick(lang: RulesetLang, global = this.global) {
+ if (lang === RulesetLang.JAVASCRIPT) {
+ return;
+ }
+
const type = global ? "global" : "realm";
const realm = manager.isSuperUser() ? manager.displayRealm : manager.config.realm;
const ruleset: RulesetUnion = {
@@ -547,7 +555,8 @@ export class OrRuleTree extends OrTreeMenu {
* @param global - Whether only to include global rulesets
*/
protected _getAllowedLanguages(config = this.config, global = this.global): RulesetLang[] | undefined {
- const languages = config?.controls?.allowedLanguages ? [...config.controls.allowedLanguages] : OrRuleTree.DEFAULT_ALLOWED_LANGUAGES;
+ const languages = (config?.controls?.allowedLanguages ? [...config.controls.allowedLanguages] : [...OrRuleTree.DEFAULT_ALLOWED_LANGUAGES])
+ .filter(lang => lang !== RulesetLang.JAVASCRIPT);
const groovyIndex = languages.indexOf(RulesetLang.GROOVY);
const flowIndex = languages.indexOf(RulesetLang.FLOW);
if (!manager.isSuperUser()) {
@@ -561,6 +570,15 @@ export class OrRuleTree extends OrTreeMenu {
return languages;
}
+ protected _isLegacyJavascriptRuleset(ruleset?: RulesetUnion) {
+ return ruleset?.lang === RulesetLang.JAVASCRIPT;
+ }
+
+ protected _isSelectedLegacyJavascriptRuleset() {
+ const selected = this._findSelectedTreeNodes() as RuleTreeNode[];
+ return selected.length === 1 && this._isLegacyJavascriptRuleset(selected[0].ruleset);
+ }
+
/**
* Utility function that gets a Material Design icon based on the ruleset language
* @param lang - The ruleset language to get an icon of.
diff --git a/ui/component/or-rules/src/or-rule-viewer.ts b/ui/component/or-rules/src/or-rule-viewer.ts
index 34558f048..8bca8e970 100644
--- a/ui/component/or-rules/src/or-rule-viewer.ts
+++ b/ui/component/or-rules/src/or-rule-viewer.ts
@@ -28,7 +28,7 @@ import {
RuleView,
RuleViewInfoMap
} from "./index";
-import {ClientRole, RulesetUnion} from "@openremote/model";
+import {ClientRole, RulesetLang, RulesetUnion} from "@openremote/model";
import manager, {Util} from "@openremote/core";
import "./json-viewer/or-rule-json-viewer";
import "./or-rule-text-viewer";
@@ -41,6 +41,7 @@ import {GenericAxiosResponse} from "@openremote/rest";
import {showErrorDialog} from "@openremote/or-mwc-components/or-mwc-dialog";
import {project} from "./flow-viewer/components/flow-editor";
import { INTUITIVE_NOT_APPLICABLE, OrSchedulerChangedEvent, RRulePartKeys } from "@openremote/or-scheduler";
+import {when} from "lit/directives/when.js";
const DISABLED_RRULE_PARTS = [
"interval",
@@ -129,6 +130,16 @@ export const style = css`
margin-left: 10px;
--or-icon-fill: var(--internal-or-rules-list-icon-color-error);
}
+
+ .legacy-warning {
+ width: calc(100% - 40px);
+ box-sizing: border-box;
+ margin: 0 20px 15px;
+ padding: 12px 14px;
+ border-radius: 4px;
+ border: 2px solid var(--internal-or-rules-invalid-color);
+ color: var(--internal-or-rules-invalid-color);
+ }
`;
@customElement("or-rule-viewer")
@@ -203,7 +214,9 @@ export class OrRuleViewer extends translate(i18next)(LitElement) {
return html`<div class="wrapper" style="justify-content: center"><or-translate value="noRuleSelected"></or-translate></div>`;
}
- let viewer = RuleViewInfoMap[this.ruleset!.lang!].viewTemplateProvider(this.ruleset, this.config, this.readonly);
+ const readonly = this._isReadonly();
+ const isLegacyJavascriptRuleset = this._isLegacyJavascriptRuleset();
+ let viewer = RuleViewInfoMap[this.ruleset!.lang!].viewTemplateProvider(this.ruleset, this.config, readonly);
let statusIcon: string = "help";
let statusClass: string = "iconfill-gray";
let statusText: string = "NOSTATUS";
@@ -251,28 +264,36 @@ export class OrRuleViewer extends translate(i18next)(LitElement) {
return html`
<div id="main-wrapper" class="wrapper">
<div id="rule-header">
- <or-mwc-input id="rule-name" outlined .type="${InputType.TEXT}" .label="${i18next.t("ruleName")}" ?focused="${this._focusName}" .value="${this.ruleset ? this.ruleset.name : null}" ?disabled="${this._isReadonly()}" required minlength="1" maxlength="255" @or-mwc-input-changed="${(e: OrInputChangedEvent) => this._changeName(e.detail.value)}"></or-mwc-input>
+ <or-mwc-input id="rule-name" outlined .type="${InputType.TEXT}" .label="${i18next.t("ruleName")}" ?focused="${this._focusName}" .value="${this.ruleset ? this.ruleset.name : null}" ?disabled="${readonly}" required minlength="1" maxlength="255" @or-mwc-input-changed="${(e: OrInputChangedEvent) => this._changeName(e.detail.value)}"></or-mwc-input>
<or-icon class="${statusClass}" title="${i18next.t("rulesetStatus." + statusText)}" icon="${statusIcon}"></or-icon>
<span id="rule-id">${this.ruleset.id ? "ID: " + this.ruleset.id : ""}</span>
<div id="rule-header-controls">
<span id="active-wrapper">
<or-translate value="enabled"></or-translate>
- <or-mwc-input .type="${InputType.CHECKBOX}" .value="${this.ruleset && this.ruleset.enabled}" ?disabled="${!this.ruleset.id}" @or-mwc-input-changed="${this._toggleEnabled}"></or-mwc-input>
+ <or-mwc-input .type="${InputType.CHECKBOX}" .value="${this.ruleset && this.ruleset.enabled}" ?disabled="${readonly || !this.ruleset.id}" @or-mwc-input-changed="${this._toggleEnabled}"></or-mwc-input>
</span>
- <or-scheduler
- id="rule-header-validity"
- header="scheduleRuleActivity"
- defaultEventTypeLabel="validityAlways"
- disableNegativeByPartValues
- .disabledRRuleParts="${DISABLED_RRULE_PARTS}"
- .disabledByPartCombinations="${INTUITIVE_NOT_APPLICABLE}"
- .schedule="${this.ruleset?.meta?.validity}"
- @or-scheduler-changed="${this._onSchedulerChanged}"
- ></or-scheduler>
+ ${when(!readonly, () => html`
+ <or-scheduler
+ id="rule-header-validity"
+ header="scheduleRuleActivity"
+ defaultEventTypeLabel="validityAlways"
+ disableNegativeByPartValues
+ .disabledRRuleParts="${DISABLED_RRULE_PARTS}"
+ .disabledByPartCombinations="${INTUITIVE_NOT_APPLICABLE}"
+ .schedule="${this.ruleset?.meta?.validity}"
+ @or-scheduler-changed="${this._onSchedulerChanged}"
+ ></or-scheduler>
+ `)}
<or-mwc-input .type="${InputType.BUTTON}" id="save-btn" label="save" raised ?disabled="${this._cannotSave()}" @or-mwc-input-changed="${this._onSaveClicked}"></or-mwc-input>
</div>
</div>
+ ${when(isLegacyJavascriptRuleset, () => html`
+ <div class="legacy-warning">
+ <or-translate value="rulesLegacyJavaScriptWarning"></or-translate>
+ </div>
+ `)}
+
${viewer}
</div>
`;
@@ -287,14 +308,22 @@ export class OrRuleViewer extends translate(i18next)(LitElement) {
}
protected _isReadonly() {
- return this.readonly || !manager.hasRole(ClientRole.WRITE_RULES);
+ return this.readonly || this._isLegacyJavascriptRuleset() || !manager.hasRole(ClientRole.WRITE_RULES);
}
protected _cannotSave() {
return this._isReadonly() || !this.ruleset || !this.modified || !this.valid;
}
+ protected _isLegacyJavascriptRuleset(ruleset = this.ruleset) {
+ return ruleset?.lang === RulesetLang.JAVASCRIPT;
+ }
+
protected _changeName(name: string) {
+ if (this._isReadonly()) {
+ return;
+ }
+
if (this.ruleset && this.ruleset.name !== name) {
this.ruleset.name = name;
this.modified = true;
@@ -303,6 +332,10 @@ export class OrRuleViewer extends translate(i18next)(LitElement) {
}
protected _onSchedulerChanged(e?: OrSchedulerChangedEvent) {
+ if (this._isReadonly()) {
+ return;
+ }
+
if (this.ruleset) {
this.ruleset.meta ??= {};
this.ruleset.meta.validity = e?.detail.value;
@@ -312,11 +345,20 @@ export class OrRuleViewer extends translate(i18next)(LitElement) {
}
protected _onRuleChanged(e: OrRulesRuleChangedEvent) {
- this.modified = true;
+ if (!this._isReadonly()) {
+ this.modified = true;
+ }
this._ruleValid = e.detail;
}
protected _onSaveClicked() {
+ if (this._isReadonly()) {
+ if (this._isLegacyJavascriptRuleset()) {
+ showErrorDialog(i18next.t("rulesLegacyJavaScriptWarning"));
+ }
+ return;
+ }
+
if (!this.ruleset || !this.view) {
return;
}
@@ -342,6 +384,13 @@ export class OrRuleViewer extends translate(i18next)(LitElement) {
return;
}
+ if (this._isReadonly()) {
+ if (this._isLegacyJavascriptRuleset(ruleset)) {
+ showErrorDialog(i18next.t("rulesLegacyJavaScriptWarning"));
+ }
+ return;
+ }
+
let fail = false;
const isNew = !ruleset.id;
this.saveBtnElem.disabled = true;
@@ -406,6 +455,10 @@ export class OrRuleViewer extends translate(i18next)(LitElement) {
}
protected _toggleEnabled() {
+ if (this._isReadonly()) {
+ return;
+ }
+
if (this.ruleset) {
this.ruleset.enabled = !this.ruleset.enabled;
this.modified = true;