Skip to content

armgit / core

Public Imported from GitHub
0

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

Cleanup of RulesetStorageService and RulesResource

Rich Turner95761bbeb480
diff --git a/client/src/main/java/org/openremote/app/client/rules/asset/AssetRulesEditorActivity.java b/client/src/main/java/org/openremote/app/client/rules/asset/AssetRulesEditorActivity.java
index 7c60c6e1f..0a407ef0e 100644
--- a/client/src/main/java/org/openremote/app/client/rules/asset/AssetRulesEditorActivity.java
+++ b/client/src/main/java/org/openremote/app/client/rules/asset/AssetRulesEditorActivity.java
@@ -84,7 +84,7 @@ public class AssetRulesEditorActivity
@Override
protected AssetRuleset newRuleset() {
- return new AssetRuleset(assetId, false);
+ return new AssetRuleset(null, null, null, assetId, false);
}
@Override
diff --git a/client/src/main/java/org/openremote/app/client/rules/asset/AssetRulesListActivity.java b/client/src/main/java/org/openremote/app/client/rules/asset/AssetRulesListActivity.java
index 2aca93d88..6bbe7a5c2 100644
--- a/client/src/main/java/org/openremote/app/client/rules/asset/AssetRulesListActivity.java
+++ b/client/src/main/java/org/openremote/app/client/rules/asset/AssetRulesListActivity.java
@@ -114,7 +114,7 @@ public class AssetRulesListActivity
environment.getApp().getRequests().sendAndReturn(
assetRulesetArrayMapper,
- params -> rulesResource.getAssetRulesets(params, assetId),
+ params -> rulesResource.getAssetRulesets(params, assetId, false),
200,
results -> view.setRulesets(new ArrayList<>(Arrays.asList(results)))
);
diff --git a/client/src/main/java/org/openremote/app/client/rules/global/GlobalRulesListActivity.java b/client/src/main/java/org/openremote/app/client/rules/global/GlobalRulesListActivity.java
index cf3a83f84..defae1fcf 100644
--- a/client/src/main/java/org/openremote/app/client/rules/global/GlobalRulesListActivity.java
+++ b/client/src/main/java/org/openremote/app/client/rules/global/GlobalRulesListActivity.java
@@ -78,7 +78,7 @@ public class GlobalRulesListActivity
environment.getApp().getRequests().sendAndReturn(
globalRulesetArrayMapper,
- rulesResource::getGlobalRulesets,
+ requestParams -> rulesResource.getGlobalRulesets(requestParams, false),
200,
results -> view.setRulesets(new ArrayList<>(Arrays.asList(results)))
);
diff --git a/client/src/main/java/org/openremote/app/client/rules/tenant/TenantRulesEditorActivity.java b/client/src/main/java/org/openremote/app/client/rules/tenant/TenantRulesEditorActivity.java
index ecb70a283..3507592d0 100644
--- a/client/src/main/java/org/openremote/app/client/rules/tenant/TenantRulesEditorActivity.java
+++ b/client/src/main/java/org/openremote/app/client/rules/tenant/TenantRulesEditorActivity.java
@@ -84,7 +84,7 @@ public class TenantRulesEditorActivity
@Override
protected TenantRuleset newRuleset() {
- return new TenantRuleset(realm, false);
+ return new TenantRuleset(null, null, null, realm, false);
}
@Override
diff --git a/client/src/main/java/org/openremote/app/client/rules/tenant/TenantRulesListActivity.java b/client/src/main/java/org/openremote/app/client/rules/tenant/TenantRulesListActivity.java
index 14274fdf5..31c751060 100644
--- a/client/src/main/java/org/openremote/app/client/rules/tenant/TenantRulesListActivity.java
+++ b/client/src/main/java/org/openremote/app/client/rules/tenant/TenantRulesListActivity.java
@@ -115,7 +115,7 @@ public class TenantRulesListActivity
environment.getApp().getRequests().sendAndReturn(
tenantRulesetArrayMapper,
- params -> rulesResource.getTenantRulesets(params, realm),
+ params -> rulesResource.getTenantRulesets(params, realm, false),
200,
results -> view.setRulesets(new ArrayList<>(Arrays.asList(results)))
);
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 fe7cbdc99..0b6df9235 100644
--- a/manager/src/main/java/org/openremote/manager/rules/RulesResourceImpl.java
+++ b/manager/src/main/java/org/openremote/manager/rules/RulesResourceImpl.java
@@ -118,11 +118,12 @@ public class RulesResourceImpl extends ManagerWebResource implements RulesResour
}
@Override
- public GlobalRuleset[] getGlobalRulesets(@BeanParam RequestParams requestParams) {
+ public GlobalRuleset[] getGlobalRulesets(@BeanParam RequestParams requestParams, boolean fullyPopulate) {
if (!isSuperUser()) {
throw new WebApplicationException(Response.Status.FORBIDDEN);
}
- List<GlobalRuleset> result = rulesetStorageService.findGlobalRulesets();
+
+ List<GlobalRuleset> result = rulesetStorageService.findGlobalRulesets(false, fullyPopulate);
// Try and retrieve transient status and error data
result.forEach(ruleset ->
@@ -138,7 +139,7 @@ public class RulesResourceImpl extends ManagerWebResource implements RulesResour
}
@Override
- public TenantRuleset[] getTenantRulesets(@BeanParam RequestParams requestParams, String realmId) {
+ public TenantRuleset[] getTenantRulesets(@BeanParam RequestParams requestParams, String realmId, boolean fullyPopulate) {
if (isAuthenticated() && !isRealmAccessibleByUser(realmId)) {
throw new WebApplicationException(Response.Status.FORBIDDEN);
@@ -146,7 +147,7 @@ public class RulesResourceImpl extends ManagerWebResource implements RulesResour
boolean publicOnly = !isAuthenticated() || isRestrictedUser() | !hasResourceRole(ClientRole.READ_RULES.getValue(), Constants.KEYCLOAK_CLIENT_ID);
- List<TenantRuleset> result = rulesetStorageService.findTenantRulesets(realmId, publicOnly);
+ List<TenantRuleset> result = rulesetStorageService.findTenantRulesets(realmId, publicOnly, false, fullyPopulate);
// Try and retrieve transient status and error data
result.forEach(ruleset ->
@@ -162,7 +163,7 @@ public class RulesResourceImpl extends ManagerWebResource implements RulesResour
}
@Override
- public AssetRuleset[] getAssetRulesets(@BeanParam RequestParams requestParams, String assetId) {
+ public AssetRuleset[] getAssetRulesets(@BeanParam RequestParams requestParams, String assetId, boolean fullyPopulate) {
Asset asset = assetStorageService.find(assetId, false);
if (asset == null)
return new AssetRuleset[0];
@@ -173,7 +174,7 @@ public class RulesResourceImpl extends ManagerWebResource implements RulesResour
boolean publicOnly = !isAuthenticated() || (isRestrictedUser() && !assetStorageService.isUserAsset(getUserId(), assetId)) || !hasResourceRole(ClientRole.READ_RULES.getValue(), Constants.KEYCLOAK_CLIENT_ID);
- List<AssetRuleset> result = rulesetStorageService.findAssetRulesets(asset.getRealm(), assetId, publicOnly);
+ List<AssetRuleset> result = rulesetStorageService.findAssetRulesets(asset.getRealm(), assetId, publicOnly, false, fullyPopulate);
// Try and retrieve transient status and error data
result.forEach(ruleset ->
diff --git a/manager/src/main/java/org/openremote/manager/rules/RulesService.java b/manager/src/main/java/org/openremote/manager/rules/RulesService.java
index edef1705f..4d41726bf 100644
--- a/manager/src/main/java/org/openremote/manager/rules/RulesService.java
+++ b/manager/src/main/java/org/openremote/manager/rules/RulesService.java
@@ -214,11 +214,11 @@ public class RulesService extends RouteBuilder implements ContainerService, Asse
}
LOG.info("Deploying global rulesets");
- rulesetStorageService.findEnabledGlobalRulesets().forEach(this::deployGlobalRuleset);
+ rulesetStorageService.findGlobalRulesets(true, true).forEach(this::deployGlobalRuleset);
LOG.info("Deploying tenant rulesets");
tenants = identityService.getIdentityProvider().getTenants();
- rulesetStorageService.findEnabledTenantRulesets()
+ rulesetStorageService.findTenantRulesets(false, true, true)
.stream()
.filter(rd ->
Arrays.stream(tenants)
@@ -227,7 +227,7 @@ public class RulesService extends RouteBuilder implements ContainerService, Asse
LOG.info("Deploying asset rulesets");
// Group by asset ID then tenant and check tenant is enabled
- deployAssetRulesets(rulesetStorageService.findEnabledAssetRulesets());
+ deployAssetRulesets(rulesetStorageService.findAssetRulesets(null, null, false, true, true));
LOG.info("Loading all assets with fact attributes to initialize state of rules engines");
Stream<Pair<Asset, Stream<AssetAttribute>>> assetRuleAttributes = findRuleStateAttributes();
@@ -334,21 +334,21 @@ public class RulesService extends RouteBuilder implements ContainerService, Asse
// Remove any asset rules engines for assets in this realm
assetEngines.values().stream()
- .filter(re -> re.getId().getRealm().map(id -> id.equals(tenant.getRealm())).orElse(false))
+ .filter(re -> re.getId().getRealm().map(realm -> realm.equals(tenant.getRealm())).orElse(false))
.forEach(RulesEngine::stop);
assetEngines.entrySet().removeIf(entry ->
- entry.getValue().getId().getRealm().map(id -> id.equals(tenant.getRealm())).orElse(
+ entry.getValue().getId().getRealm().map(realm -> realm.equals(tenant.getRealm())).orElse(
false)
);
} else {
// Create tenant rules engines for this tenant if it has any rulesets
rulesetStorageService
- .findEnabledTenantRulesets(tenant.getRealm())
+ .findTenantRulesets(tenant.getRealm(), false, true, true)
.forEach(this::deployTenantRuleset);
// Create any asset rules engines for assets in this realm that have rulesets
- deployAssetRulesets(rulesetStorageService.findEnabledAssetRulesets(tenant.getRealm()));
+ deployAssetRulesets(rulesetStorageService.findAssetRulesetsByRealm(tenant.getRealm(), false, true, true));
}
});
}
@@ -484,7 +484,7 @@ public class RulesService extends RouteBuilder implements ContainerService, Asse
} else if (ruleset instanceof AssetRuleset) {
// Must reload from the database, the ruleset might not be completely hydrated on INSERT or UPDATE
- AssetRuleset assetRuleset = rulesetStorageService.findEnabledAssetRuleset(ruleset.getId());
+ AssetRuleset assetRuleset = rulesetStorageService.findById(AssetRuleset.class, ruleset.getId());
RulesEngine newEngine = deployAssetRuleset(assetRuleset);
if (newEngine != null) {
// Push all existing facts for this asset (and it's children into the engine), this is an
diff --git a/manager/src/main/java/org/openremote/manager/rules/RulesetStorageService.java b/manager/src/main/java/org/openremote/manager/rules/RulesetStorageService.java
index 55f0934ea..ec4a39e78 100644
--- a/manager/src/main/java/org/openremote/manager/rules/RulesetStorageService.java
+++ b/manager/src/main/java/org/openremote/manager/rules/RulesetStorageService.java
@@ -30,7 +30,9 @@ import org.openremote.model.rules.AssetRuleset;
import org.openremote.model.rules.GlobalRuleset;
import org.openremote.model.rules.Ruleset;
import org.openremote.model.rules.TenantRuleset;
+import org.openremote.model.util.TextUtil;
+import javax.persistence.TypedQuery;
import java.util.List;
public class RulesetStorageService implements ContainerService {
@@ -49,13 +51,13 @@ public class RulesetStorageService implements ContainerService {
identityService = container.getService(ManagerIdentityService.class);
container.getService(ManagerWebService.class).getApiSingletons().add(
- new RulesResourceImpl(
- container.getService(TimerService.class),
- container.getService(ManagerIdentityService.class),
- this,
- container.getService(AssetStorageService.class),
- container.getService(RulesService.class)
- )
+ new RulesResourceImpl(
+ container.getService(TimerService.class),
+ container.getService(ManagerIdentityService.class),
+ this,
+ container.getService(AssetStorageService.class),
+ container.getService(RulesService.class)
+ )
);
}
@@ -68,185 +70,151 @@ public class RulesetStorageService implements ContainerService {
}
- /**
- * The {@link Ruleset#rules} property is not populated for this query to avoid loading multiple large strings.
- */
- public List<GlobalRuleset> findGlobalRulesets() {
+ public List<GlobalRuleset> findGlobalRulesets(boolean onlyEnabled, boolean fullyPopulate) {
+
+ String query = "select new org.openremote.model.rules.GlobalRuleset(" +
+ "rs.id, rs.version, rs.createdOn, rs.lastModified, rs.enabled, rs.name, rs.lang";
+
+ query += fullyPopulate ? ", rs.rules" : ", cast(null as string)";
+
+ query += ") " +
+ "from GlobalRuleset rs where 1=1 ";
+
+ if (onlyEnabled) {
+ query += "and rs.enabled = true ";
+ }
+
+ query += "order by rs.createdOn asc";
+
+ String finalQuery = query;
return persistenceService.doReturningTransaction(entityManager ->
- entityManager.createQuery(
- "select new org.openremote.model.rules.GlobalRuleset(" +
- "rs.id, rs.version, rs.createdOn, rs.lastModified, rs.name, rs.enabled, rs.rules, rs.lang" +
- ") " +
- "from GlobalRuleset rs " +
- "order by rs.createdOn asc",
- GlobalRuleset.class
- ).getResultList()
+ entityManager.createQuery(
+ finalQuery,
+ GlobalRuleset.class
+ ).getResultList()
);
}
- /**
- * The {@link Ruleset#rules} property is not populated for this query to avoid loading multiple large strings.
- */
- public List<TenantRuleset> findTenantRulesets(String realm, boolean onlyPublic) {
+ public List<TenantRuleset> findTenantRulesets(boolean onlyPublic, boolean onlyEnabled, boolean fullyPopulate) {
+ return findTenantRulesets(null, onlyPublic, onlyEnabled, fullyPopulate);
+ }
+ public List<TenantRuleset> findTenantRulesets(String realm, boolean onlyPublic, boolean onlyEnabled, boolean fullyPopulate) {
String query = "select new org.openremote.model.rules.TenantRuleset(" +
- "rs.id, rs.version, rs.createdOn, rs.lastModified, rs.name, rs.enabled, rs.rules, rs.lang, rs.realm, rs.accessPublicRead" +
- ") " +
+ "rs.id, rs.version, rs.createdOn, rs.lastModified, rs.enabled, rs.name, rs.lang";
+
+ query += fullyPopulate ? ", rs.rules" : ", cast(null as string)";
+
+ query += ", rs.realm, rs.accessPublicRead) " +
"from TenantRuleset rs " +
- "where rs.realm = :realm ";
+ "where 1=1 ";
+
+ boolean includeRealm = !TextUtil.isNullOrEmpty(realm);
+
+ if (includeRealm) {
+ query += "and rs.realm = :realm ";
+ }
if (onlyPublic) {
query += "and rs.accessPublicRead = true ";
}
+ if (onlyEnabled) {
+ query += "and rs.enabled = true ";
+ }
+
query += "order by rs.createdOn asc";
String finalQuery = query;
- return persistenceService.doReturningTransaction(entityManager ->
- entityManager.createQuery(
- finalQuery,
- TenantRuleset.class
- ).setParameter("realm", realm).getResultList()
+ return persistenceService.doReturningTransaction(entityManager -> {
+ TypedQuery<TenantRuleset> qry = entityManager.createQuery(
+ finalQuery,
+ TenantRuleset.class
+ );
+ if (includeRealm) {
+ qry.setParameter("realm", realm);
+ }
+ return qry.getResultList();
+ }
);
}
- /**
- * The {@link Ruleset#rules} property is not populated for this query to avoid loading multiple large strings.
- */
- public List<AssetRuleset> findAssetRulesets(String realm, String assetId, boolean onlyPublic) {
+ public List<AssetRuleset> findAssetRulesetsByRealm(String realm, boolean onlyPublic, boolean onlyEnabled, boolean fullyPopulate) {
+ return findAssetRulesets(realm, null, onlyPublic, onlyEnabled, fullyPopulate);
+ }
+ public List<AssetRuleset> findAssetRulesetsByAssetId(String assetId, boolean onlyPublic, boolean onlyEnabled, boolean fullyPopulate) {
+ return findAssetRulesets(null, assetId, onlyPublic, onlyEnabled, fullyPopulate);
+ }
+ public List<AssetRuleset> findAssetRulesets(String realm, String assetId, boolean onlyPublic, boolean onlyEnabled, boolean fullyPopulate) {
String query = "select new org.openremote.model.rules.AssetRuleset(" +
- "rs.id, rs.version, rs.createdOn, rs.lastModified, rs.name, rs.enabled, rs.rules, rs.assetId, rs.lang, rs.accessPublicRead" +
- ") " +
+ "rs.id, rs.version, rs.createdOn, rs.lastModified, rs.enabled, rs.name, rs.lang";
+
+ query += fullyPopulate ? ", rs.rules" : ", cast(null as string)";
+
+ query += ", a.realm, rs.assetId, rs.accessPublicRead) " +
"from AssetRuleset rs, Asset a " +
- "where rs.assetId = :assetId and rs.assetId = a.id and a.realm = :realm ";
+ "where rs.assetId = a.id ";
+
+ boolean includeRealm = !TextUtil.isNullOrEmpty(realm);
+ boolean includeAssetId = !TextUtil.isNullOrEmpty(assetId);
+
+ if (includeRealm) {
+ query += "and a.realm = :realm ";
+ }
+
+ if (includeAssetId) {
+ query += "and rs.assetId = :assetId ";
+ }
if (onlyPublic) {
query += "and rs.accessPublicRead = true ";
}
+ if (onlyEnabled) {
+ query += "and rs.enabled = true ";
+ }
+
query += "order by rs.createdOn asc";
String finalQuery = query;
- return persistenceService.doReturningTransaction(entityManager ->
- entityManager.createQuery(
- finalQuery,
- AssetRuleset.class
- ).setParameter("realm", realm).setParameter("assetId",
- assetId).getResultList()
- );
- }
-
- /**
- * @return Fully populated rulesets including {@link Ruleset#rules} property.
- */
- public List<GlobalRuleset> findEnabledGlobalRulesets() {
- return persistenceService.doReturningTransaction(entityManager ->
- entityManager.createQuery(
- "select new org.openremote.model.rules.GlobalRuleset(" +
- "rs.id, rs.version, rs.createdOn, rs.lastModified, rs.name, rs.enabled, rs.rules, rs.lang" +
- ") " +
- "from GlobalRuleset rs " +
- "where rs.enabled = true",
- GlobalRuleset.class
- ).getResultList()
- );
- }
-
- /**
- * @return Fully populated rulesets including {@link Ruleset#rules} property.
- */
- public List<TenantRuleset> findEnabledTenantRulesets() {
- return persistenceService.doReturningTransaction(entityManager ->
- entityManager.createQuery(
- "select new org.openremote.model.rules.TenantRuleset(" +
- "rs.id, rs.version, rs.createdOn, rs.lastModified, rs.name, rs.enabled, rs.rules, rs.lang, rs.realm, rs.accessPublicRead" +
- ") " +
- "from TenantRuleset rs " +
- "where rs.enabled = true",
- TenantRuleset.class
- ).getResultList()
- );
- }
-
- /**
- * @return Fully populated rulesets including {@link Ruleset#rules} property.
- */
- public List<TenantRuleset> findEnabledTenantRulesets(String realm) {
- return persistenceService.doReturningTransaction(entityManager ->
- entityManager.createQuery(
- "select new org.openremote.model.rules.TenantRuleset(" +
- "rs.id, rs.version, rs.createdOn, rs.lastModified, rs.name, rs.enabled, rs.rules, rs.lang, rs.realm, rs.accessPublicRead" +
- ") " +
- "from TenantRuleset rs " +
- "where rs.enabled = true and rs.realm = :realm",
- TenantRuleset.class
- ).setParameter("realm", realm).getResultList()
+ return persistenceService.doReturningTransaction(entityManager -> {
+ TypedQuery<AssetRuleset> qry = entityManager.createQuery(
+ finalQuery,
+ AssetRuleset.class
+ );
+
+ if (includeRealm) {
+ qry.setParameter("realm", realm);
+ }
+ if (includeAssetId) {
+ qry.setParameter("assetId", assetId);
+ }
+
+ return qry.getResultList();
+ }
);
}
- /**
- * @return Fully populated rulesets including {@link Ruleset#rules} property.
- */
- public List<AssetRuleset> findEnabledAssetRulesets() {
- return persistenceService.doReturningTransaction(entityManager ->
- entityManager.createQuery(
- "select new org.openremote.model.rules.AssetRuleset(" +
- "rs.id, rs.version, rs.createdOn, rs.lastModified, rs.name, rs.enabled, rs.rules, rs.lang, rs.assetId, a.realm" +
- ", rs.accessPublicRead) " +
- "from AssetRuleset rs, Asset a " +
- "where rs.assetId = a.id " +
- "and rs.enabled = true ",
- AssetRuleset.class
- ).getResultList()
- );
- }
+ public <T extends Ruleset> T findById(Class<T> rulesetType, Long id) {
- /**
- * @return Fully populated ruleset including {@link Ruleset#rules} property.
- */
- public AssetRuleset findEnabledAssetRuleset(Long id) {
- return persistenceService.doReturningTransaction(entityManager -> {
- List<AssetRuleset> result = entityManager.createQuery(
- "select new org.openremote.model.rules.AssetRuleset(" +
- "rs.id, rs.version, rs.createdOn, rs.lastModified, rs.name, rs.enabled, rs.rules, rs.lang, rs.assetId, a.realm, rs.accessPublicRead" +
- ") " +
- "from AssetRuleset rs, Asset a " +
- "where rs.assetId = a.id " +
- "and rs.id = :id " +
- "and rs.enabled = true ",
- AssetRuleset.class
- ).setParameter("id", id).getResultList();
- return result.size() > 0 ? result.get(0) : null;
- }
- );
- }
+ return persistenceService.doReturningTransaction(em -> {
+ T ruleset = em.find(rulesetType, id);
- /**
- * @return Fully populated rulesets including {@link Ruleset#rules} property.
- */
- public List<AssetRuleset> findEnabledAssetRulesets(String realm) {
- return persistenceService.doReturningTransaction(entityManager ->
- entityManager.createQuery(
- "select new org.openremote.model.rules.AssetRuleset(" +
- "rs.id, rs.version, rs.createdOn, rs.lastModified, rs.name, rs.enabled, rs.rules, rs.lang, rs.assetId, a.realm, rs.accessPublicRead" +
- ") " +
- "from AssetRuleset rs, Asset a " +
- "where rs.assetId = a.id and a.realm = :realm " +
- "and rs.enabled = true",
- AssetRuleset.class
- ).setParameter("realm", realm).getResultList()
- );
- }
+ if (rulesetType == AssetRuleset.class && ruleset != null && TextUtil.isNullOrEmpty(((AssetRuleset)ruleset).getRealm())) {
+ // Asset rulesets require special treatment as realm is transient - TODO Should a JPA mapping be used?
+ String realm = em.createQuery("select a.realm from AssetRuleset rs, Asset a where a.id = rs.assetId and rs.id = :id", String.class).setParameter("id", id).getSingleResult();
+ ((AssetRuleset) ruleset).setRealm(realm);
+ }
- public <T extends Ruleset> T findById(Class<T> rulesetType, Long id) {
- return persistenceService.doReturningTransaction(em -> em.find(rulesetType, id));
+ return ruleset;
+ });
}
public <T extends Ruleset> T merge(T ruleset) {
return persistenceService.doReturningTransaction(entityManager ->
- entityManager.merge(ruleset)
+ entityManager.merge(ruleset)
);
}
diff --git a/manager/src/main/java/org/openremote/manager/setup/builtin/KeycloakDemoSetup.java b/manager/src/main/java/org/openremote/manager/setup/builtin/KeycloakDemoSetup.java
index 3c0ef500f..56d89d86d 100644
--- a/manager/src/main/java/org/openremote/manager/setup/builtin/KeycloakDemoSetup.java
+++ b/manager/src/main/java/org/openremote/manager/setup/builtin/KeycloakDemoSetup.java
@@ -41,6 +41,7 @@ import java.util.logging.Logger;
* <li><code>testuser1</code> - (Password: testuser1) A user in the "master" realm with read/write access to assets and rules</li>
* <li><code>testuser2</code> - (Password: testuser2) A user in the "tenantA" realm with only read access to assets</li>
* <li><code>testuser3</code> - (Password: testuser3) A user in the "tenantA" realm with read/write access to a restricted set of assets and their rules</li>
+ * <li><code>building</code> - (Password: building) A user in the "tenantA" realm with read/write access to the building apartment 1 assets and their rules</li>
* <li><code>testuser4</code> - (Password: testuser4) A user in the "tenantB" realm with read/write access to a restricted set of assets and their rules</li>
*
* </ul>
@@ -53,6 +54,7 @@ public class KeycloakDemoSetup extends AbstractKeycloakSetup {
public String testuser2Id;
public String testuser3Id;
public String testuser4Id;
+ public String buildingUserId;
public Tenant masterTenant;
public Tenant tenantA;
public Tenant tenantB;
@@ -83,7 +85,6 @@ public class KeycloakDemoSetup extends AbstractKeycloakSetup {
tenantB = keycloakProvider.getTenant(tenantB.getRealm());
// Users
-
String masterClientObjectId = getClientObjectId(masterClientsResource);
RolesResource masterRolesResource = masterClientsResource.get(masterClientObjectId).roles();
@@ -160,6 +161,30 @@ public class KeycloakDemoSetup extends AbstractKeycloakSetup {
));
LOG.info("Added demo user '" + testuser3.getUsername() + "' with password '" + testuser3Credentials.getValue() + "'");
+ UserRepresentation buildingUser = new UserRepresentation();
+ buildingUser.setUsername("building");
+ buildingUser.setFirstName("Building");
+ buildingUser.setLastName("User");
+ buildingUser.setEmail("[email protected]");
+ buildingUser.setEnabled(true);
+ tenantAUsersResource.create(buildingUser);
+ buildingUser = tenantAUsersResource.search("building", null, null, null, null, null).get(0);
+ this.buildingUserId = buildingUser.getId();
+ CredentialRepresentation buildingUserCredentials = new CredentialRepresentation();
+ buildingUserCredentials.setType("password");
+ buildingUserCredentials.setValue("building");
+ buildingUserCredentials.setTemporary(false);
+ tenantAUsersResource.get(buildingUser.getId()).resetPassword(buildingUserCredentials);
+ tenantAUsersResource.get(buildingUser.getId()).roles().clientLevel(tenantAClientObjectId).add(Arrays.asList(
+ tenantARolesResource.get(ClientRole.WRITE_USER.getValue()).toRepresentation(),
+ tenantARolesResource.get(ClientRole.READ_MAP.getValue()).toRepresentation(),
+ tenantARolesResource.get(ClientRole.READ_ASSETS.getValue()).toRepresentation(),
+ tenantARolesResource.get(ClientRole.WRITE_RULES.getValue()).toRepresentation(),
+ tenantARolesResource.get(ClientRole.WRITE_ASSETS.getValue()).toRepresentation(),
+ tenantARolesResource.get(ClientRole.READ_RULES.getValue()).toRepresentation()
+ ));
+ LOG.info("Added demo user '" + buildingUser.getUsername() + "' with password '" + buildingUserCredentials.getValue() + "'");
+
UsersResource tenantBUsersResource = keycloakProvider.getRealms(accessToken).realm("tenantB").users();
ClientsResource tenantBClientsResource = keycloakProvider.getRealms(accessToken).realm("tenantB").clients();
String tenantBClientObjectId = getClientObjectId(tenantBClientsResource);
diff --git a/manager/src/main/java/org/openremote/manager/setup/builtin/ManagerDemoSetup.java b/manager/src/main/java/org/openremote/manager/setup/builtin/ManagerDemoSetup.java
index 7c7295a16..b41b67967 100644
--- a/manager/src/main/java/org/openremote/manager/setup/builtin/ManagerDemoSetup.java
+++ b/manager/src/main/java/org/openremote/manager/setup/builtin/ManagerDemoSetup.java
@@ -739,9 +739,25 @@ public class ManagerDemoSetup extends AbstractManagerSetup {
assetStorageService.storeUserAsset(new UserAsset(keycloakDemoSetup.tenantA.getRealm(),
keycloakDemoSetup.testuser3Id,
apartment1HallwayId));
-// assetStorageService.storeUserAsset(new UserAsset(keycloakDemoSetup.tenantA.getRealm(),
-// keycloakDemoSetup.testuser2Id,
-// apartment2Id));
+
+ assetStorageService.storeUserAsset(new UserAsset(keycloakDemoSetup.tenantA.getRealm(),
+ keycloakDemoSetup.buildingUserId,
+ apartment1Id));
+ assetStorageService.storeUserAsset(new UserAsset(keycloakDemoSetup.tenantA.getRealm(),
+ keycloakDemoSetup.buildingUserId,
+ apartment1LivingroomId));
+ assetStorageService.storeUserAsset(new UserAsset(keycloakDemoSetup.tenantA.getRealm(),
+ keycloakDemoSetup.buildingUserId,
+ apartment1KitchenId));
+ assetStorageService.storeUserAsset(new UserAsset(keycloakDemoSetup.tenantA.getRealm(),
+ keycloakDemoSetup.buildingUserId,
+ apartment1Bedroom1Id));
+ assetStorageService.storeUserAsset(new UserAsset(keycloakDemoSetup.tenantA.getRealm(),
+ keycloakDemoSetup.buildingUserId,
+ apartment1BathroomId));
+ assetStorageService.storeUserAsset(new UserAsset(keycloakDemoSetup.tenantA.getRealm(),
+ keycloakDemoSetup.buildingUserId,
+ apartment1HallwayId));
// ################################ Make users restricted ###################################
@@ -749,11 +765,14 @@ public class ManagerDemoSetup extends AbstractManagerSetup {
testuser3Config.setRestricted(true);
testuser3Config = identityService.mergeUserConfiguration(testuser3Config);
+ UserConfiguration buildingUserConfig = identityService.getUserConfiguration(keycloakDemoSetup.buildingUserId);
+ testuser3Config.setRestricted(true);
+ buildingUserConfig = identityService.mergeUserConfiguration(buildingUserConfig);
+
// ################################ Realm B ###################################
ObjectValue locationValueB = SMART_CITY_LOCATION.toValue();
-
Asset smartCity = new Asset();
smartCity.setRealm(this.realmBTenant);
smartCity.setName("Smart City");
@@ -843,9 +862,9 @@ public class ManagerDemoSetup extends AbstractManagerSetup {
AssetRuleset camera3Rules = new AssetRuleset(
"Camera3_Rules",
- camera3Asset.getId(),
- IOUtils.toString(getClass().getResource("/demo/rules/DemoSmartCityCamera.groovy"), "UTF-8"),
- GROOVY, false);
+ GROOVY, IOUtils.toString(getClass().getResource("/demo/rules/DemoSmartCityCamera.groovy"), "UTF-8"), camera3Asset.getId(),
+ false
+ );
camera3Rules = rulesetStorageService.merge(camera3Rules);
Asset light3Asset = createDemoLightAsset("Light3", assetArea3);
diff --git a/manager/src/main/java/org/openremote/manager/setup/builtin/RulesDemoSetup.java b/manager/src/main/java/org/openremote/manager/setup/builtin/RulesDemoSetup.java
index 54aa2b5a7..b9b1a6c52 100644
--- a/manager/src/main/java/org/openremote/manager/setup/builtin/RulesDemoSetup.java
+++ b/manager/src/main/java/org/openremote/manager/setup/builtin/RulesDemoSetup.java
@@ -55,35 +55,35 @@ public class RulesDemoSetup extends AbstractManagerSetup {
try (InputStream inputStream = RulesDemoSetup.class.getResourceAsStream("/demo/rules/DemoResidencePresenceDetection.groovy")) {
String rules = IOUtils.toString(inputStream, Charset.forName("utf-8"));
Ruleset ruleset = new AssetRuleset(
- "Demo Residence - Presence Detection with motion and CO2 sensors", managerDemoSetup.apartment1Id, rules, Ruleset.Lang.GROOVY, false
+ "Demo Residence - Presence Detection with motion and CO2 sensors", Ruleset.Lang.GROOVY, rules, managerDemoSetup.apartment1Id, false
);
apartmentActionsRulesetId = rulesetStorageService.merge(ruleset).getId();
}
try (InputStream inputStream = RulesDemoSetup.class.getResourceAsStream("/demo/rules/DemoResidenceVacationMode.groovy")) {
String rules = IOUtils.toString(inputStream, Charset.forName("utf-8"));
Ruleset ruleset = new AssetRuleset(
- "Demo Residence - Vacation Mode", managerDemoSetup.apartment1Id, rules, Ruleset.Lang.GROOVY, false
+ "Demo Residence - Vacation Mode", Ruleset.Lang.GROOVY, rules, managerDemoSetup.apartment1Id, false
);
apartmentActionsRulesetId = rulesetStorageService.merge(ruleset).getId();
}
try (InputStream inputStream = RulesDemoSetup.class.getResourceAsStream("/demo/rules/DemoResidenceAutoVentilation.groovy")) {
String rules = IOUtils.toString(inputStream, Charset.forName("utf-8"));
Ruleset ruleset = new AssetRuleset(
- "Demo Residence - Auto Ventilation", managerDemoSetup.apartment1Id, rules, Ruleset.Lang.GROOVY, false
+ "Demo Residence - Auto Ventilation", Ruleset.Lang.GROOVY, rules, managerDemoSetup.apartment1Id, false
);
apartmentActionsRulesetId = rulesetStorageService.merge(ruleset).getId();
}
try (InputStream inputStream = RulesDemoSetup.class.getResourceAsStream("/demo/rules/DemoResidenceNotifyAlarmTrigger.groovy")) {
String rules = IOUtils.toString(inputStream, Charset.forName("utf-8"));
Ruleset ruleset = new AssetRuleset(
- "Demo Residence - Notify Alarm Trigger", managerDemoSetup.apartment1Id, rules, Ruleset.Lang.GROOVY, false
+ "Demo Residence - Notify Alarm Trigger", Ruleset.Lang.GROOVY, rules, managerDemoSetup.apartment1Id, false
);
apartmentActionsRulesetId = rulesetStorageService.merge(ruleset).getId();
}
try (InputStream inputStream = RulesDemoSetup.class.getResourceAsStream("/demo/rules/DemoResidenceSmartSwitch.groovy")) {
String rules = IOUtils.toString(inputStream, Charset.forName("utf-8"));
Ruleset ruleset = new AssetRuleset(
- "Demo Residence - Smart Start Switch", managerDemoSetup.apartment1Id, rules, Ruleset.Lang.GROOVY, false
+ "Demo Residence - Smart Start Switch", Ruleset.Lang.GROOVY, rules, managerDemoSetup.apartment1Id, false
);
apartmentActionsRulesetId = rulesetStorageService.merge(ruleset).getId();
}
@@ -92,7 +92,7 @@ public class RulesDemoSetup extends AbstractManagerSetup {
try (InputStream inputStream = RulesDemoSetup.class.getResourceAsStream("/demo/rules/DemoResidenceAllLightsOff.js")) {
String rules = IOUtils.toString(inputStream, Charset.forName("utf-8"));
Ruleset ruleset = new AssetRuleset(
- "Demo Residence - All Lights Off", managerDemoSetup.apartment2Id, rules, Ruleset.Lang.JAVASCRIPT, false
+ "Demo Residence - All Lights Off", Ruleset.Lang.JAVASCRIPT, rules, managerDemoSetup.apartment2Id, false
);
apartmentActionsRulesetId = rulesetStorageService.merge(ruleset).getId();
}
@@ -100,7 +100,7 @@ public class RulesDemoSetup extends AbstractManagerSetup {
try (InputStream inputStream = RulesDemoSetup.class.getResourceAsStream("/demo/rules/DemoConsoleLocation.groovy")) {
String rules = IOUtils.toString(inputStream, Charset.forName("utf-8"));
Ruleset ruleset = new TenantRuleset(
- "Demo Console Location", keycloakDemoSetup.tenantA.getRealm(), rules, Ruleset.Lang.GROOVY, true
+ "Demo Console Location", Ruleset.Lang.GROOVY, rules, keycloakDemoSetup.tenantA.getRealm(), true
);
tenantARulesetId = rulesetStorageService.merge(ruleset).getId();
}
diff --git a/model/src/main/java/org/openremote/model/rules/AssetRuleset.java b/model/src/main/java/org/openremote/model/rules/AssetRuleset.java
index eb7d8791b..80c844bac 100644
--- a/model/src/main/java/org/openremote/model/rules/AssetRuleset.java
+++ b/model/src/main/java/org/openremote/model/rules/AssetRuleset.java
@@ -19,10 +19,7 @@
*/
package org.openremote.model.rules;
-import javax.persistence.Column;
-import javax.persistence.Entity;
-import javax.persistence.Table;
-import javax.persistence.Transient;
+import javax.persistence.*;
import java.util.Date;
/**
@@ -47,22 +44,13 @@ public class AssetRuleset extends Ruleset {
public AssetRuleset() {
}
- public AssetRuleset(String assetId, boolean accessPublicRead) {
- this.assetId = assetId;
- this.accessPublicRead = accessPublicRead;
- }
-
- public AssetRuleset(long id, long version, Date createdOn, Date lastModified, String name, boolean enabled, String assetId, Lang lang, boolean accessPublicRead) {
- this(id, version, createdOn, lastModified, name, enabled, null, lang, assetId, null, accessPublicRead);
- }
-
- public AssetRuleset(String name, String assetId, String rules, Lang lang, boolean accessPublicRead) {
+ public AssetRuleset(String name, Lang lang, String rules, String assetId, boolean accessPublicRead) {
super(name, rules, lang);
this.assetId = assetId;
this.accessPublicRead = accessPublicRead;
}
- public AssetRuleset(long id, long version, Date createdOn, Date lastModified, String name, boolean enabled, String rules, Lang lang, String assetId, String realm, boolean accessPublicRead) {
+ public AssetRuleset(long id, long version, Date createdOn, Date lastModified, boolean enabled, String name, Lang lang, String rules, String realm, String assetId, boolean accessPublicRead) {
super(id, version, createdOn, lastModified, name, enabled, rules, lang);
this.assetId = assetId;
this.realm = realm;
diff --git a/model/src/main/java/org/openremote/model/rules/GlobalRuleset.java b/model/src/main/java/org/openremote/model/rules/GlobalRuleset.java
index 4813856d2..3c1ccd6e5 100644
--- a/model/src/main/java/org/openremote/model/rules/GlobalRuleset.java
+++ b/model/src/main/java/org/openremote/model/rules/GlobalRuleset.java
@@ -35,15 +35,11 @@ public class GlobalRuleset extends Ruleset {
public GlobalRuleset() {
}
- public GlobalRuleset(long id, long version, Date createdOn, Date lastModified, String name, boolean enabled, Lang lang) {
- super(id, version, createdOn, lastModified, name, enabled, lang);
- }
-
- public GlobalRuleset(long id, long version, Date createdOn, Date lastModified, String name, boolean enabled, String rules, Lang lang) {
+ public GlobalRuleset(long id, long version, Date createdOn, Date lastModified, boolean enabled, String name, Lang lang, String rules) {
super(id, version, createdOn, lastModified, name, enabled, rules, lang);
}
- public GlobalRuleset(String name, String rules, Lang lang) {
+ public GlobalRuleset(String name, Lang lang, String rules) {
super(name, rules, lang);
}
diff --git a/model/src/main/java/org/openremote/model/rules/RulesResource.java b/model/src/main/java/org/openremote/model/rules/RulesResource.java
index 0702aaf7f..dd7b0f312 100644
--- a/model/src/main/java/org/openremote/model/rules/RulesResource.java
+++ b/model/src/main/java/org/openremote/model/rules/RulesResource.java
@@ -73,7 +73,7 @@ public interface RulesResource {
@SuccessStatusCode(200)
@RolesAllowed({"read:rules"})
@SuppressWarnings("unusable-by-js")
- GlobalRuleset[] getGlobalRulesets(@BeanParam RequestParams requestParams);
+ GlobalRuleset[] getGlobalRulesets(@BeanParam RequestParams requestParams, @QueryParam("fullyPopulate") boolean fullyPopulate);
/**
* Retrieve rules of a tenant. The superuser can retrieve rules of all realms, a 403 status is returned if a regular
@@ -85,7 +85,7 @@ public interface RulesResource {
@Produces(APPLICATION_JSON)
@SuccessStatusCode(200)
@SuppressWarnings("unusable-by-js")
- TenantRuleset[] getTenantRulesets(@BeanParam RequestParams requestParams, @PathParam("realm") String realm);
+ TenantRuleset[] getTenantRulesets(@BeanParam RequestParams requestParams, @PathParam("realm") String realm, @QueryParam("fullyPopulate") boolean fullyPopulate);
/**
* Retrieve rules of an asset. The superuser can retrieve rules of all realms and assets, a 403 status is returned
@@ -97,7 +97,7 @@ public interface RulesResource {
@Produces(APPLICATION_JSON)
@SuccessStatusCode(200)
@SuppressWarnings("unusable-by-js")
- AssetRuleset[] getAssetRulesets(@BeanParam RequestParams requestParams, @PathParam("assetId") String assetId);
+ AssetRuleset[] getAssetRulesets(@BeanParam RequestParams requestParams, @PathParam("assetId") String assetId, @QueryParam("fullyPopulate") boolean fullyPopulate);
/* ################################################################################################# */
diff --git a/model/src/main/java/org/openremote/model/rules/TenantRuleset.java b/model/src/main/java/org/openremote/model/rules/TenantRuleset.java
index 4a7cfab71..55ceab559 100644
--- a/model/src/main/java/org/openremote/model/rules/TenantRuleset.java
+++ b/model/src/main/java/org/openremote/model/rules/TenantRuleset.java
@@ -43,28 +43,18 @@ public class TenantRuleset extends Ruleset {
public TenantRuleset() {
}
- public TenantRuleset(long id, long version, Date createdOn, Date lastModified, String name, boolean enabled, String realm, Lang lang, boolean accessPublicRead) {
- super(id, version, createdOn, lastModified, name, enabled, lang);
+ public TenantRuleset(String name, Lang lang, String rules, String realm, boolean accessPublicRead) {
+ super(name, rules, lang);
this.realm = realm;
this.accessPublicRead = accessPublicRead;
}
- public TenantRuleset(long id, long version, Date createdOn, Date lastModified, String name, boolean enabled, String rules, Lang lang, String realm, boolean accessPublicRead) {
+ public TenantRuleset(long id, long version, Date createdOn, Date lastModified, boolean enabled, String name, Lang lang, String rules, String realm, boolean accessPublicRead) {
super(id, version, createdOn, lastModified, name, enabled, rules, lang);
this.realm = realm;
this.accessPublicRead = accessPublicRead;
}
- public TenantRuleset(String realm, boolean accessPublicRead) {
- this(null, realm, null, Lang.GROOVY, accessPublicRead);
- }
-
- public TenantRuleset(String name, String realm, String rules, Lang lang, boolean accessPublicRead) {
- super(name, rules, lang);
- this.realm = realm;
- this.accessPublicRead = accessPublicRead;
- }
-
public String getRealm() {
return realm;
}
diff --git a/test/src/test/groovy/org/openremote/test/assets/AssetUserLinkingTest.groovy b/test/src/test/groovy/org/openremote/test/assets/AssetUserLinkingTest.groovy
index cc1515dd0..96d498066 100644
--- a/test/src/test/groovy/org/openremote/test/assets/AssetUserLinkingTest.groovy
+++ b/test/src/test/groovy/org/openremote/test/assets/AssetUserLinkingTest.groovy
@@ -51,7 +51,7 @@ class AssetUserLinkingTest extends Specification implements ManagerContainerTrai
def userAssets = assetResource.getUserAssetLinks(null, keycloakDemoSetup.tenantA.realm, null, null)
then: "result should match"
- userAssets.length == 6
+ userAssets.length == 12
userAssets.any {
it.id.realm == keycloakDemoSetup.tenantA.realm &&
it.id.userId == keycloakDemoSetup.testuser3Id &&
@@ -125,7 +125,7 @@ class AssetUserLinkingTest extends Specification implements ManagerContainerTrai
userAssets = assetResource.getUserAssetLinks(null, keycloakDemoSetup.tenantA.realm, null, managerDemoSetup.apartment1Id)
then: "result should match"
- userAssets.length == 1
+ userAssets.length == 2
userAssets.any {
it.id.realm == keycloakDemoSetup.tenantA.realm &&
it.id.userId == keycloakDemoSetup.testuser3Id &&
diff --git a/test/src/test/groovy/org/openremote/test/console/ConsoleTest.groovy b/test/src/test/groovy/org/openremote/test/console/ConsoleTest.groovy
index 2df43746a..224c9bb53 100644
--- a/test/src/test/groovy/org/openremote/test/console/ConsoleTest.groovy
+++ b/test/src/test/groovy/org/openremote/test/console/ConsoleTest.groovy
@@ -97,10 +97,9 @@ class ConsoleTest extends Specification implements ManagerContainerTrait {
and: "the demo location predicate console rules are loaded"
Ruleset ruleset = new TenantRuleset(
- "Demo Tenant A - Console Location",
- keycloakDemoSetup.tenantA.realm,
- getClass().getResource("/demo/rules/DemoConsoleLocation.groovy").text,
- Ruleset.Lang.GROOVY, false
+ "Demo Tenant A - Console Location", Ruleset.Lang.GROOVY, getClass().getResource("/demo/rules/DemoConsoleLocation.groovy").text,
+ keycloakDemoSetup.tenantA.realm
+ , false
)
rulesetStorageService.merge(ruleset)
@@ -500,10 +499,8 @@ class ConsoleTest extends Specification implements ManagerContainerTrait {
when: "a new ruleset is deployed on the console parent asset with multiple location predicate rules (including a duplicate and a rectangular predicate)"
def newRuleset = new AssetRuleset(
- "Console test location predicates",
- testUser3Console1.parentId,
- getClass().getResource("/org/openremote/test/rules/BasicLocationPredicates.groovy").text,
- Ruleset.Lang.GROOVY, false
+ "Console test location predicates", Ruleset.Lang.GROOVY, getClass().getResource("/org/openremote/test/rules/BasicLocationPredicates.groovy").text,
+ testUser3Console1.parentId, false
)
newRuleset = rulesetStorageService.merge(newRuleset)
RulesEngine consoleParentEngine = null
diff --git a/test/src/test/groovy/org/openremote/test/failure/RulesExecutionFailureTest.groovy b/test/src/test/groovy/org/openremote/test/failure/RulesExecutionFailureTest.groovy
index 866f19b12..8e50032f6 100644
--- a/test/src/test/groovy/org/openremote/test/failure/RulesExecutionFailureTest.groovy
+++ b/test/src/test/groovy/org/openremote/test/failure/RulesExecutionFailureTest.groovy
@@ -1,21 +1,15 @@
package org.openremote.test.failure
-import org.openremote.manager.notification.NotificationService
-import org.openremote.manager.notification.PushNotificationHandler
+
import org.openremote.manager.rules.RulesEngine
import org.openremote.manager.rules.RulesFacts
import org.openremote.manager.rules.RulesService
import org.openremote.manager.rules.RulesetStorageService
import org.openremote.manager.setup.SetupService
-import org.openremote.manager.setup.builtin.KeycloakDemoSetup
import org.openremote.manager.setup.builtin.ManagerDemoSetup
-import org.openremote.model.notification.AbstractNotificationMessage
-import org.openremote.model.notification.Notification
-import org.openremote.model.notification.NotificationSendResult
import org.openremote.model.rules.AssetRuleset
import org.openremote.model.rules.Ruleset
import org.openremote.model.rules.RulesetStatus
-import org.openremote.model.rules.TenantRuleset
import org.openremote.test.ManagerContainerTrait
import spock.lang.Specification
import spock.util.concurrent.PollingConditions
@@ -35,10 +29,8 @@ class RulesExecutionFailureTest extends Specification implements ManagerContaine
and: "some rules"
Ruleset ruleset = new AssetRuleset(
- "Failure Ruleset",
- managerDemoSetup.apartment2Id,
- getClass().getResource("/org/openremote/test/failure/RulesFailureConditionInvalidReturn.groovy").text,
- Ruleset.Lang.GROOVY, false
+ "Failure Ruleset", Ruleset.Lang.GROOVY, getClass().getResource("/org/openremote/test/failure/RulesFailureConditionInvalidReturn.groovy").text,
+ managerDemoSetup.apartment2Id, false
)
ruleset = rulesetStorageService.merge(ruleset)
@@ -71,10 +63,8 @@ class RulesExecutionFailureTest extends Specification implements ManagerContaine
and: "some rules"
Ruleset ruleset = new AssetRuleset(
- "Failure Ruleset",
- managerDemoSetup.apartment2Id,
- getClass().getResource("/org/openremote/test/failure/RulesFailureConditionThrowsException.groovy").text,
- Ruleset.Lang.GROOVY, false
+ "Failure Ruleset", Ruleset.Lang.GROOVY, getClass().getResource("/org/openremote/test/failure/RulesFailureConditionThrowsException.groovy").text,
+ managerDemoSetup.apartment2Id, false
)
ruleset = rulesetStorageService.merge(ruleset)
@@ -107,10 +97,8 @@ class RulesExecutionFailureTest extends Specification implements ManagerContaine
and: "some rules"
Ruleset ruleset = new AssetRuleset(
- "Failure Ruleset",
- managerDemoSetup.apartment2Id,
- getClass().getResource("/org/openremote/test/failure/RulesFailureActionThrowsException.groovy").text,
- Ruleset.Lang.GROOVY, false
+ "Failure Ruleset", Ruleset.Lang.GROOVY, getClass().getResource("/org/openremote/test/failure/RulesFailureActionThrowsException.groovy").text,
+ managerDemoSetup.apartment2Id, false
)
ruleset = rulesetStorageService.merge(ruleset)
@@ -143,10 +131,8 @@ class RulesExecutionFailureTest extends Specification implements ManagerContaine
and: "some rules"
Ruleset ruleset = new AssetRuleset(
- "Failure Ruleset",
- managerDemoSetup.apartment2Id,
- getClass().getResource("/org/openremote/test/failure/RulesFailureLoop.groovy").text,
- Ruleset.Lang.GROOVY, false
+ "Failure Ruleset", Ruleset.Lang.GROOVY, getClass().getResource("/org/openremote/test/failure/RulesFailureLoop.groovy").text,
+ managerDemoSetup.apartment2Id, false
)
ruleset = rulesetStorageService.merge(ruleset)
diff --git a/test/src/test/groovy/org/openremote/test/notification/NotificationTest.groovy b/test/src/test/groovy/org/openremote/test/notification/NotificationTest.groovy
index 6beb0d89f..3f0ebc341 100644
--- a/test/src/test/groovy/org/openremote/test/notification/NotificationTest.groovy
+++ b/test/src/test/groovy/org/openremote/test/notification/NotificationTest.groovy
@@ -582,8 +582,8 @@ class NotificationTest extends Specification implements ManagerContainerTrait {
then: "the email should have been sent to all tenant users"
conditions.eventually {
- assert notificationMessages.size() == 2
- assert toAddresses.size() == 2
+ assert notificationMessages.size() == 3
+ assert toAddresses.size() == 3
assert ((EmailNotificationMessage) notificationMessages.get(0)).getText() == "Hello world!"
assert ((EmailNotificationMessage) notificationMessages.get(0)).getSubject() == "Test"
assert ((EmailNotificationMessage) notificationMessages.get(0)).getFrom().getAddress() == mockEmailNotificationHandler.defaultFrom
@@ -592,6 +592,7 @@ class NotificationTest extends Specification implements ManagerContainerTrait {
assert ((EmailNotificationMessage) notificationMessages.get(1)).getFrom().getAddress() == mockEmailNotificationHandler.defaultFrom
assert toAddresses.any { ((EmailNotificationMessage.Recipient)it).getAddress() == "[email protected]" }
assert toAddresses.any { ((EmailNotificationMessage.Recipient)it).getAddress() == "[email protected]" }
+ assert toAddresses.any { ((EmailNotificationMessage.Recipient)it).getAddress() == "[email protected]" }
}
when: "an email attribute is added to an asset"
@@ -605,8 +606,8 @@ class NotificationTest extends Specification implements ManagerContainerTrait {
then: "the child asset with the email attribute should have been sent an email"
conditions.eventually {
- assert notificationMessages.size() == 3
- assert toAddresses.size() == 3
+ assert notificationMessages.size() == 4
+ assert toAddresses.size() == 4
assert toAddresses.any { ((EmailNotificationMessage.Recipient)it).getAddress() == "[email protected]" }
}
diff --git a/test/src/test/groovy/org/openremote/test/rules/BasicRulesDeploymentTest.groovy b/test/src/test/groovy/org/openremote/test/rules/BasicRulesDeploymentTest.groovy
index fc3102222..ce95c634c 100644
--- a/test/src/test/groovy/org/openremote/test/rules/BasicRulesDeploymentTest.groovy
+++ b/test/src/test/groovy/org/openremote/test/rules/BasicRulesDeploymentTest.groovy
@@ -56,9 +56,8 @@ class BasicRulesDeploymentTest extends Specification implements ManagerContainer
when: "a new global rule definition is added"
def ruleset = new GlobalRuleset(
- "Some more global rules",
- getClass().getResource("/org/openremote/test/rules/BasicMatchAllAssetStates2.groovy").text,
- GROOVY
+ "Some more global rules", GROOVY,
+ getClass().getResource("/org/openremote/test/rules/BasicMatchAllAssetStates2.groovy").text
)
rulesetStorageService.merge(ruleset)
@@ -73,10 +72,9 @@ class BasicRulesDeploymentTest extends Specification implements ManagerContainer
when: "a new tenant rule definition is added to Tenant A"
ruleset = new TenantRuleset(
- "Some more tenantA tenant rules",
- keycloakDemoSetup.tenantA.realm,
- getClass().getResource("/org/openremote/test/rules/BasicMatchAllAssetStates2.groovy").text,
- GROOVY, false
+ "Some more tenantA tenant rules", GROOVY, getClass().getResource("/org/openremote/test/rules/BasicMatchAllAssetStates2.groovy").text,
+ keycloakDemoSetup.tenantA.realm
+ , false
)
rulesetStorageService.merge(ruleset)
@@ -92,10 +90,9 @@ class BasicRulesDeploymentTest extends Specification implements ManagerContainer
when: "a new tenant rule definition is added to Tenant B"
ruleset = new TenantRuleset(
- "Some more tenantB tenant rules",
- keycloakDemoSetup.tenantB.realm,
- getClass().getResource("/org/openremote/test/rules/BasicMatchAllAssetStates2.groovy").text,
- GROOVY, false
+ "Some more tenantB tenant rules", GROOVY, getClass().getResource("/org/openremote/test/rules/BasicMatchAllAssetStates2.groovy").text,
+ keycloakDemoSetup.tenantB.realm
+ , false
)
rulesetStorageService.merge(ruleset)
@@ -155,9 +152,8 @@ class BasicRulesDeploymentTest extends Specification implements ManagerContainer
when: "a broken rule definition is added to the global rules engine"
ruleset = new GlobalRuleset(
- "Some broken global rules",
- getClass().getResource("/org/openremote/test/rules/BasicBrokenRules.groovy").text,
- GROOVY
+ "Some broken global rules", GROOVY,
+ getClass().getResource("/org/openremote/test/rules/BasicBrokenRules.groovy").text
)
ruleset = rulesetStorageService.merge(ruleset)
@@ -193,10 +189,10 @@ class BasicRulesDeploymentTest extends Specification implements ManagerContainer
then: "the tenants rule engine should stop and all asset rule engines in this realm should also stop"
conditions.eventually {
- assert tenantAEngine.isRunning() == false
+ assert !tenantAEngine.isRunning()
assert tenantAEngine.deployments.size() == 2
assert rulesService.tenantEngines.get(keycloakDemoSetup.tenantA.realm) == null
- assert apartment3Engine.isRunning() == false
+ assert !apartment3Engine.isRunning()
assert apartment3Engine.deployments.size() == 1
assert rulesService.assetEngines.get(managerDemoSetup.apartment3Id) == null
}
diff --git a/test/src/test/groovy/org/openremote/test/rules/BasicRulesImport.groovy b/test/src/test/groovy/org/openremote/test/rules/BasicRulesImport.groovy
index 5fd59edec..f33e378fa 100644
--- a/test/src/test/groovy/org/openremote/test/rules/BasicRulesImport.groovy
+++ b/test/src/test/groovy/org/openremote/test/rules/BasicRulesImport.groovy
@@ -36,67 +36,56 @@ class BasicRulesImport {
ManagerDemoSetup managerDemoSetup) {
Ruleset ruleset = new GlobalRuleset(
- "Some global demo rules",
- getClass().getResource("/org/openremote/test/rules/BasicMatchAllAssetStates.groovy").text,
- GROOVY
+ "Some global demo rules", GROOVY,
+ getClass().getResource("/org/openremote/test/rules/BasicMatchAllAssetStates.groovy").text
)
globalRulesetId = rulesetStorageService.merge(ruleset).id
ruleset = new GlobalRuleset(
- "Other global demo rules with a long name that should fill up space in UI",
- getClass().getResource("/org/openremote/test/rules/BasicMatchAllAssetStates.groovy").text,
- GROOVY
+ "Other global demo rules with a long name that should fill up space in UI", GROOVY,
+ getClass().getResource("/org/openremote/test/rules/BasicMatchAllAssetStates.groovy").text
)
ruleset.setEnabled(false)
globalRuleset2Id = rulesetStorageService.merge(ruleset).id
ruleset = new TenantRuleset(
- "Some master tenant demo rules",
- keycloakDemoSetup.masterTenant.realm,
- getClass().getResource("/org/openremote/test/rules/BasicMatchAllAssetStates.groovy").text,
- GROOVY, false
+ "Some master tenant demo rules", GROOVY, getClass().getResource("/org/openremote/test/rules/BasicMatchAllAssetStates.groovy").text,
+ keycloakDemoSetup.masterTenant.realm
+ , false
)
masterRulesetId = rulesetStorageService.merge(ruleset).id
ruleset = new TenantRuleset(
- "Some tenantA tenant demo rules",
- keycloakDemoSetup.tenantA.realm,
- getClass().getResource("/org/openremote/test/rules/BasicMatchAllAssetStates.groovy").text,
- GROOVY, false
+ "Some tenantA tenant demo rules", GROOVY, getClass().getResource("/org/openremote/test/rules/BasicMatchAllAssetStates.groovy").text,
+ keycloakDemoSetup.tenantA.realm
+ , false
)
tenantARulesetId = rulesetStorageService.merge(ruleset).id
ruleset = new TenantRuleset(
- "Some tenantB tenant demo rules",
- keycloakDemoSetup.tenantB.realm,
- getClass().getResource("/org/openremote/test/rules/BasicMatchAllAssetStates.groovy").text,
- GROOVY, false
+ "Some tenantB tenant demo rules", GROOVY, getClass().getResource("/org/openremote/test/rules/BasicMatchAllAssetStates.groovy").text,
+ keycloakDemoSetup.tenantB.realm
+ , false
)
ruleset.setEnabled(false)
tenantBRulesetId = rulesetStorageService.merge(ruleset).id
ruleset = new AssetRuleset(
- "Some apartment 1 demo rules",
- managerDemoSetup.apartment1Id,
- getClass().getResource("/org/openremote/test/rules/BasicMatchAllAssetStates.groovy").text,
- GROOVY, false
+ "Some apartment 1 demo rules", GROOVY, getClass().getResource("/org/openremote/test/rules/BasicMatchAllAssetStates.groovy").text,
+ managerDemoSetup.apartment1Id, false
)
ruleset.setEnabled(false)
apartment1RulesetId = rulesetStorageService.merge(ruleset).id
ruleset = new AssetRuleset(
- "Some apartment 2 demo rules",
- managerDemoSetup.apartment2Id,
- getClass().getResource("/org/openremote/test/rules/BasicMatchAllAssetStates.groovy").text,
- GROOVY, false
+ "Some apartment 2 demo rules", GROOVY, getClass().getResource("/org/openremote/test/rules/BasicMatchAllAssetStates.groovy").text,
+ managerDemoSetup.apartment2Id, false
)
apartment2RulesetId = rulesetStorageService.merge(ruleset).id
ruleset = new AssetRuleset(
- "Some apartment 3 demo rules",
- managerDemoSetup.apartment3Id,
- getClass().getResource("/org/openremote/test/rules/BasicMatchAllAssetStates.groovy").text,
- GROOVY, false
+ "Some apartment 3 demo rules", GROOVY, getClass().getResource("/org/openremote/test/rules/BasicMatchAllAssetStates.groovy").text,
+ managerDemoSetup.apartment3Id, false
)
apartment3RulesetId = rulesetStorageService.merge(ruleset).id
}
diff --git a/test/src/test/groovy/org/openremote/test/rules/BasicRulesProcessingTest.groovy b/test/src/test/groovy/org/openremote/test/rules/BasicRulesProcessingTest.groovy
index 84a55ac1c..92276c6c8 100644
--- a/test/src/test/groovy/org/openremote/test/rules/BasicRulesProcessingTest.groovy
+++ b/test/src/test/groovy/org/openremote/test/rules/BasicRulesProcessingTest.groovy
@@ -129,10 +129,8 @@ class BasicRulesProcessingTest extends Specification implements ManagerContainer
when: "a LHS filtering test rule definition is loaded into the Smart Building asset"
def assetRuleset = new AssetRuleset(
- "Some Smart Building asset rules",
- managerDemoSetup.smartBuildingId,
- getClass().getResource("/org/openremote/test/rules/BasicSmartHomeMatchAllAssetStates.groovy").text,
- Ruleset.Lang.GROOVY, false
+ "Some Smart Building asset rules", Ruleset.Lang.GROOVY, getClass().getResource("/org/openremote/test/rules/BasicSmartHomeMatchAllAssetStates.groovy").text,
+ managerDemoSetup.smartBuildingId, false
)
rulesetStorageService.merge(assetRuleset)
RulesEngine smartHomeEngine = null
@@ -377,10 +375,9 @@ class BasicRulesProcessingTest extends Specification implements ManagerContainer
when: "a broken RHS rule is loaded into the tenantA engine"
def ruleset = new TenantRuleset(
- "Some broken test rules",
- keycloakDemoSetup.tenantA.realm,
- getClass().getResource("/org/openremote/test/rules/BasicBrokenRules.groovy").text,
- Ruleset.Lang.GROOVY, false
+ "Some broken test rules", Ruleset.Lang.GROOVY, getClass().getResource("/org/openremote/test/rules/BasicBrokenRules.groovy").text,
+ keycloakDemoSetup.tenantA.realm
+ , false
)
rulesetStorageService.merge(ruleset)
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 6a8a1dd41..1a5e04562 100644
--- a/test/src/test/groovy/org/openremote/test/rules/BasicRulesetResourceTest.groovy
+++ b/test/src/test/groovy/org/openremote/test/rules/BasicRulesetResourceTest.groovy
@@ -55,7 +55,7 @@ class BasicRulesetResourceTest extends Specification implements ManagerContainer
/* ############################################## READ ####################################### */
when: "the global rules are retrieved"
- def ruleDefinitions = rulesetResource.getGlobalRulesets(null)
+ def ruleDefinitions = rulesetResource.getGlobalRulesets(null, false)
then: "result should match"
ruleDefinitions.length == 2
@@ -64,7 +64,7 @@ class BasicRulesetResourceTest extends Specification implements ManagerContainer
ruleDefinitions[0].rules == null // Don't retrieve the (large) rules data when getting a list of rule definitions
when: "some tenant rules are retrieved"
- ruleDefinitions = rulesetResource.getTenantRulesets(null, keycloakDemoSetup.masterTenant.realm)
+ ruleDefinitions = rulesetResource.getTenantRulesets(null, keycloakDemoSetup.masterTenant.realm, false)
then: "result should match"
ruleDefinitions.length == 1
@@ -72,7 +72,7 @@ class BasicRulesetResourceTest extends Specification implements ManagerContainer
ruleDefinitions[0].lang == GROOVY
when: "some tenant rules in a non-authenticated realm are retrieved"
- ruleDefinitions = rulesetResource.getTenantRulesets(null, keycloakDemoSetup.tenantA.realm)
+ ruleDefinitions = rulesetResource.getTenantRulesets(null, keycloakDemoSetup.tenantA.realm, false)
then: "result should match"
ruleDefinitions.length == 1
@@ -80,7 +80,7 @@ class BasicRulesetResourceTest extends Specification implements ManagerContainer
ruleDefinitions[0].enabled
when: "some asset rules are retrieved"
- ruleDefinitions = rulesetResource.getAssetRulesets(null, managerDemoSetup.apartment2Id)
+ ruleDefinitions = rulesetResource.getAssetRulesets(null, managerDemoSetup.apartment2Id, false)
then: "result should match"
ruleDefinitions.length == 1
@@ -90,9 +90,9 @@ class BasicRulesetResourceTest extends Specification implements ManagerContainer
/* ############################################## WRITE ####################################### */
when: "global ruleset is created"
- def globalRuleset = new GlobalRuleset("Test global definition", "SomeRulesCode", GROOVY)
+ def globalRuleset = new GlobalRuleset("Test global definition", GROOVY, "SomeRulesCode")
rulesetResource.createGlobalRuleset(null, globalRuleset)
- def rulesetId = rulesetResource.getGlobalRulesets(null)[2].id
+ def rulesetId = rulesetResource.getGlobalRulesets(null, false)[2].id
globalRuleset = rulesetResource.getGlobalRuleset(null, rulesetId)
def lastModified = globalRuleset.lastModified
@@ -135,9 +135,9 @@ class BasicRulesetResourceTest extends Specification implements ManagerContainer
ex.response.status == 404
when: "a tenant ruleset is created in the authenticated realm"
- def tenantRuleset = new TenantRuleset("Test tenant definition", keycloakDemoSetup.masterTenant.realm, "SomeRulesCode", GROOVY, false)
+ def tenantRuleset = new TenantRuleset("Test tenant definition", GROOVY, "SomeRulesCode", keycloakDemoSetup.masterTenant.realm, false)
rulesetResource.createTenantRuleset(null, tenantRuleset)
- rulesetId = rulesetResource.getTenantRulesets(null, keycloakDemoSetup.masterTenant.realm)[1].id
+ rulesetId = rulesetResource.getTenantRulesets(null, keycloakDemoSetup.masterTenant.realm, false)[1].id
tenantRuleset = rulesetResource.getTenantRuleset(null, rulesetId)
lastModified = tenantRuleset.lastModified
@@ -198,9 +198,9 @@ class BasicRulesetResourceTest extends Specification implements ManagerContainer
ex.response.status == 404
when: "a tenant ruleset is created in a non-authenticated realm"
- tenantRuleset = new TenantRuleset("Test tenant definition", keycloakDemoSetup.tenantA.realm, "SomeRulesCode", GROOVY, false)
+ tenantRuleset = new TenantRuleset("Test tenant definition", GROOVY, "SomeRulesCode", keycloakDemoSetup.tenantA.realm, false)
rulesetResource.createTenantRuleset(null, tenantRuleset)
- rulesetId = rulesetResource.getTenantRulesets(null, keycloakDemoSetup.tenantA.realm)[1].id
+ rulesetId = rulesetResource.getTenantRulesets(null, keycloakDemoSetup.tenantA.realm, false)[1].id
tenantRuleset = rulesetResource.getTenantRuleset(null, rulesetId)
lastModified = tenantRuleset.lastModified
@@ -214,9 +214,9 @@ class BasicRulesetResourceTest extends Specification implements ManagerContainer
tenantRuleset.realm == keycloakDemoSetup.tenantA.realm
when: "an asset ruleset is created in the authenticated realm"
- def assetRuleset = new AssetRuleset("Test asset definition", managerDemoSetup.smartOfficeId, "SomeRulesCode", GROOVY, false)
+ def assetRuleset = new AssetRuleset("Test asset definition", GROOVY, "SomeRulesCode", managerDemoSetup.smartOfficeId, false)
rulesetResource.createAssetRuleset(null, assetRuleset)
- rulesetId = rulesetResource.getAssetRulesets(null, managerDemoSetup.smartOfficeId)[0].id
+ rulesetId = rulesetResource.getAssetRulesets(null, managerDemoSetup.smartOfficeId, false)[0].id
assetRuleset = rulesetResource.getAssetRuleset(null, rulesetId)
lastModified = assetRuleset.lastModified
@@ -277,9 +277,9 @@ class BasicRulesetResourceTest extends Specification implements ManagerContainer
ex.response.status == 404
when: "an asset ruleset is created in a non-authenticated realm"
- assetRuleset = new AssetRuleset("Test asset definition", managerDemoSetup.apartment2Id, "SomeRulesCode", GROOVY, false)
+ assetRuleset = new AssetRuleset("Test asset definition", GROOVY, "SomeRulesCode", managerDemoSetup.apartment2Id, false)
rulesetResource.createAssetRuleset(null, assetRuleset)
- rulesetId = rulesetResource.getAssetRulesets(null, managerDemoSetup.apartment2Id)[1].id
+ rulesetId = rulesetResource.getAssetRulesets(null, managerDemoSetup.apartment2Id, false)[1].id
assetRuleset = rulesetResource.getAssetRuleset(null, rulesetId)
lastModified = assetRuleset.lastModified
@@ -329,28 +329,28 @@ class BasicRulesetResourceTest extends Specification implements ManagerContainer
/* ############################################## READ ####################################### */
when: "the global rules are retrieved"
- rulesetResource.getGlobalRulesets(null)
+ rulesetResource.getGlobalRulesets(null, false)
then: "access should be forbidden"
WebApplicationException ex = thrown()
ex.response.status == 403
when: "some tenant rules are retrieved"
- def ruleDefinitions = rulesetResource.getTenantRulesets(null, keycloakDemoSetup.masterTenant.realm)
+ def ruleDefinitions = rulesetResource.getTenantRulesets(null, keycloakDemoSetup.masterTenant.realm, false)
then: "result should match"
ruleDefinitions.length == 1
ruleDefinitions[0].name == "Some master tenant demo rules"
when: "some tenant rules in a non-authenticated realm are retrieved"
- rulesetResource.getTenantRulesets(null, keycloakDemoSetup.tenantA.realm)
+ rulesetResource.getTenantRulesets(null, keycloakDemoSetup.tenantA.realm, false)
then: "access should be forbidden"
ex = thrown()
ex.response.status == 403
when: "some asset rules in a non-authenticated realm are retrieved"
- rulesetResource.getAssetRulesets(null, managerDemoSetup.apartment2Id)
+ rulesetResource.getAssetRulesets(null, managerDemoSetup.apartment2Id, false)
then: "access should be forbidden"
ex = thrown()
@@ -359,7 +359,7 @@ class BasicRulesetResourceTest extends Specification implements ManagerContainer
/* ############################################## WRITE ####################################### */
when: "a global rule is created"
- def ruleDefinition = new GlobalRuleset("Test definition", "SomeRulesCode", GROOVY)
+ def ruleDefinition = new GlobalRuleset("Test definition", GROOVY, "SomeRulesCode")
rulesetResource.createGlobalRuleset(null, ruleDefinition)
then: "access should be forbidden"
@@ -381,9 +381,9 @@ class BasicRulesetResourceTest extends Specification implements ManagerContainer
ex.response.status == 403
when: "a tenant ruleset is created in the authenticated realm"
- def tenantRuleset = new TenantRuleset("Test tenant definition", keycloakDemoSetup.masterTenant.realm, "SomeRulesCode", GROOVY, false)
+ def tenantRuleset = new TenantRuleset("Test tenant definition", GROOVY, "SomeRulesCode", keycloakDemoSetup.masterTenant.realm, false)
rulesetResource.createTenantRuleset(null, tenantRuleset)
- def rulesetId = rulesetResource.getTenantRulesets(null, keycloakDemoSetup.masterTenant.realm)[1].id
+ def rulesetId = rulesetResource.getTenantRulesets(null, keycloakDemoSetup.masterTenant.realm, false)[1].id
tenantRuleset = rulesetResource.getTenantRuleset(null, rulesetId)
def lastModified = tenantRuleset.lastModified
@@ -444,7 +444,7 @@ class BasicRulesetResourceTest extends Specification implements ManagerContainer
ex.response.status == 404
when: "a tenant ruleset is created in a non-authenticated realm"
- tenantRuleset = new TenantRuleset("Test tenant definition", keycloakDemoSetup.tenantA.realm, "SomeRulesCode", GROOVY, false)
+ tenantRuleset = new TenantRuleset("Test tenant definition", GROOVY, "SomeRulesCode", keycloakDemoSetup.tenantA.realm, false)
rulesetResource.createTenantRuleset(null, tenantRuleset)
then: "access should be forbidden"
@@ -452,9 +452,9 @@ class BasicRulesetResourceTest extends Specification implements ManagerContainer
ex.response.status == 403
when: "an asset ruleset is created in the authenticated realm"
- def assetRuleset = new AssetRuleset("Test asset definition", managerDemoSetup.smartOfficeId, "SomeRulesCode", GROOVY, false)
+ def assetRuleset = new AssetRuleset("Test asset definition", GROOVY, "SomeRulesCode", managerDemoSetup.smartOfficeId, false)
rulesetResource.createAssetRuleset(null, assetRuleset)
- rulesetId = rulesetResource.getAssetRulesets(null, managerDemoSetup.smartOfficeId)[0].id
+ rulesetId = rulesetResource.getAssetRulesets(null, managerDemoSetup.smartOfficeId, false)[0].id
assetRuleset = rulesetResource.getAssetRuleset(null, rulesetId)
lastModified = assetRuleset.lastModified
@@ -515,7 +515,7 @@ class BasicRulesetResourceTest extends Specification implements ManagerContainer
ex.response.status == 404
when: "an asset ruleset is created in a non-authenticated realm"
- assetRuleset = new AssetRuleset("Test asset definition", managerDemoSetup.apartment2Id, "SomeRulesCode", GROOVY, false)
+ assetRuleset = new AssetRuleset("Test asset definition", GROOVY, "SomeRulesCode", managerDemoSetup.apartment2Id, false)
rulesetResource.createAssetRuleset(null, assetRuleset)
then: "access should be forbidden"
@@ -559,27 +559,27 @@ class BasicRulesetResourceTest extends Specification implements ManagerContainer
/* ############################################## READ ####################################### */
when: "the global rules are retrieved"
- rulesetResource.getGlobalRulesets(null)
+ rulesetResource.getGlobalRulesets(null, false)
then: "access should be forbidden"
WebApplicationException ex = thrown()
ex.response.status == 403
when: "some tenant rules in a non-authenticated realm are retrieved"
- rulesetResource.getTenantRulesets(null, keycloakDemoSetup.masterTenant.realm)
+ rulesetResource.getTenantRulesets(null, keycloakDemoSetup.masterTenant.realm, false)
then: "access should be forbidden"
ex = thrown()
ex.response.status == 403
when: "some tenant rules in the authenticated realm are retrieved by user without rules read role"
- def rulesets = rulesetResource.getTenantRulesets(null, keycloakDemoSetup.tenantA.realm)
+ def rulesets = rulesetResource.getTenantRulesets(null, keycloakDemoSetup.tenantA.realm, false)
then: "no rulesets should be returned"
rulesets.length == 0
when: "some asset rules in the authenticated realm are retrieved by the user without rules read role"
- rulesets = rulesetResource.getAssetRulesets(null, managerDemoSetup.apartment2Id)
+ rulesets = rulesetResource.getAssetRulesets(null, managerDemoSetup.apartment2Id, false)
then: "no rulesets should be returned"
rulesets.length == 0
@@ -587,7 +587,7 @@ class BasicRulesetResourceTest extends Specification implements ManagerContainer
/* ############################################## WRITE ####################################### */
when: "a global rule is created"
- def ruleDefinition = new GlobalRuleset("Test definition", "SomeRulesCode", GROOVY)
+ def ruleDefinition = new GlobalRuleset("Test definition", GROOVY, "SomeRulesCode")
rulesetResource.createGlobalRuleset(null, ruleDefinition)
then: "access should be forbidden"
@@ -609,7 +609,7 @@ class BasicRulesetResourceTest extends Specification implements ManagerContainer
ex.response.status == 403
when: "a tenant ruleset is created in the authenticated realm"
- def tenantRuleset = new TenantRuleset("Test tenant definition", keycloakDemoSetup.tenantA.realm, "SomeRulesCode", GROOVY, false)
+ def tenantRuleset = new TenantRuleset("Test tenant definition", GROOVY, "SomeRulesCode", keycloakDemoSetup.tenantA.realm, false)
rulesetResource.createTenantRuleset(null, tenantRuleset)
then: "access should be forbidden"
@@ -631,7 +631,7 @@ class BasicRulesetResourceTest extends Specification implements ManagerContainer
ex.response.status == 403
when: "a tenant ruleset is created in a non-authenticated realm"
- tenantRuleset = new TenantRuleset("Test tenant definition", keycloakDemoSetup.tenantB.realm, "SomeRulesCode", GROOVY, false)
+ tenantRuleset = new TenantRuleset("Test tenant definition", GROOVY, "SomeRulesCode", keycloakDemoSetup.tenantB.realm, false)
rulesetResource.createTenantRuleset(null, tenantRuleset)
then: "access should be forbidden"
@@ -639,7 +639,7 @@ class BasicRulesetResourceTest extends Specification implements ManagerContainer
ex.response.status == 403
when: "a tenant ruleset is created in the authenticated realm"
- def assetRuleset = new AssetRuleset("Test asset definition", keycloakDemoSetup.tenantA.realm, "SomeRulesCode", GROOVY, false)
+ def assetRuleset = new AssetRuleset("Test asset definition", GROOVY, "SomeRulesCode", keycloakDemoSetup.tenantA.realm, false)
rulesetResource.createAssetRuleset(null, assetRuleset)
then: "access should be forbidden"
@@ -661,7 +661,7 @@ class BasicRulesetResourceTest extends Specification implements ManagerContainer
ex.response.status == 403
when: "a tenant ruleset is created in a non-authenticated realm"
- assetRuleset = new AssetRuleset("Test asset definition", keycloakDemoSetup.tenantB.realm, "SomeRulesCode", GROOVY, false)
+ assetRuleset = new AssetRuleset("Test asset definition", GROOVY, "SomeRulesCode", keycloakDemoSetup.tenantB.realm, false)
rulesetResource.createAssetRuleset(null, assetRuleset)
then: "access should be forbidden"
@@ -705,34 +705,34 @@ class BasicRulesetResourceTest extends Specification implements ManagerContainer
/* ############################################## READ ####################################### */
when: "the global rules are retrieved"
- rulesetResource.getGlobalRulesets(null)
+ rulesetResource.getGlobalRulesets(null, false)
then: "access should be forbidden"
WebApplicationException ex = thrown()
ex.response.status == 403
when: "some tenant rules in a non-authenticated realm are retrieved"
- rulesetResource.getTenantRulesets(null, keycloakDemoSetup.masterTenant.realm)
+ rulesetResource.getTenantRulesets(null, keycloakDemoSetup.masterTenant.realm, false)
then: "access should be forbidden"
ex = thrown()
ex.response.status == 403
when: "some tenant rules in the authenticated realm are retrieved by the restricted user"
- def rulesets = rulesetResource.getTenantRulesets(null, keycloakDemoSetup.tenantA.realm)
+ def rulesets = rulesetResource.getTenantRulesets(null, keycloakDemoSetup.tenantA.realm, false)
then: "no rulesets should be returned"
rulesets.length == 0
when: "some asset rules of a protected assigned asset are retrieved"
- def ruleDefinitions = rulesetResource.getAssetRulesets(null, managerDemoSetup.apartment1Id)
+ def ruleDefinitions = rulesetResource.getAssetRulesets(null, managerDemoSetup.apartment1Id, false)
then: "result should match"
ruleDefinitions.length == 1
ruleDefinitions[0].name == "Some apartment 1 demo rules"
when: "some asset rules of a protected but not assigned asset are retrieved"
- rulesetResource.getAssetRulesets(null, managerDemoSetup.apartment2Id)
+ rulesetResource.getAssetRulesets(null, managerDemoSetup.apartment2Id, false)
then: "no rulesets should be returned"
rulesets.length == 0
@@ -740,7 +740,7 @@ class BasicRulesetResourceTest extends Specification implements ManagerContainer
/* ############################################## WRITE ####################################### */
when: "a global rule is created"
- def ruleDefinition = new GlobalRuleset("Test definition", "SomeRulesCode", GROOVY)
+ def ruleDefinition = new GlobalRuleset("Test definition", GROOVY, "SomeRulesCode")
rulesetResource.createGlobalRuleset(null, ruleDefinition)
then: "access should be forbidden"
@@ -762,7 +762,7 @@ class BasicRulesetResourceTest extends Specification implements ManagerContainer
ex.response.status == 403
when: "a tenant ruleset is created in the authenticated realm"
- def tenantRuleset = new TenantRuleset("Test tenant definition", keycloakDemoSetup.tenantA.realm, "SomeRulesCode", GROOVY, false)
+ def tenantRuleset = new TenantRuleset("Test tenant definition", GROOVY, "SomeRulesCode", keycloakDemoSetup.tenantA.realm, false)
rulesetResource.createTenantRuleset(null, tenantRuleset)
then: "access should be forbidden"
@@ -785,7 +785,7 @@ class BasicRulesetResourceTest extends Specification implements ManagerContainer
ex.response.status == 404
when: "a tenant ruleset is created in a non-authenticated realm"
- tenantRuleset = new TenantRuleset("Test tenant definition", keycloakDemoSetup.tenantB.realm, "SomeRulesCode", GROOVY, false)
+ tenantRuleset = new TenantRuleset("Test tenant definition", GROOVY, "SomeRulesCode", keycloakDemoSetup.tenantB.realm, false)
rulesetResource.createTenantRuleset(null, tenantRuleset)
then: "access should be forbidden"
@@ -793,9 +793,9 @@ class BasicRulesetResourceTest extends Specification implements ManagerContainer
ex.response.status == 403
when: "an asset ruleset is created in the authenticated realm"
- def assetRuleset = new AssetRuleset("Test asset definition", managerDemoSetup.apartment1Id, "SomeRulesCode", GROOVY, false)
+ def assetRuleset = new AssetRuleset("Test asset definition", GROOVY, "SomeRulesCode", managerDemoSetup.apartment1Id, false)
rulesetResource.createAssetRuleset(null, assetRuleset)
- def rulesetId = rulesetResource.getAssetRulesets(null, managerDemoSetup.apartment1Id)[1].id
+ def rulesetId = rulesetResource.getAssetRulesets(null, managerDemoSetup.apartment1Id, false)[1].id
assetRuleset = rulesetResource.getAssetRuleset(null, rulesetId)
def lastModified = assetRuleset.lastModified
@@ -864,7 +864,7 @@ class BasicRulesetResourceTest extends Specification implements ManagerContainer
ex.response.status == 404
when: "an asset ruleset is created in the authenticated realm but on a forbidden asset "
- assetRuleset = new AssetRuleset("Test asset definition", managerDemoSetup.apartment3Id, "SomeRulesCode", GROOVY, false)
+ assetRuleset = new AssetRuleset("Test asset definition", GROOVY, "SomeRulesCode", managerDemoSetup.apartment3Id, false)
rulesetResource.createAssetRuleset(null, assetRuleset)
then: "access should be forbidden"
@@ -872,7 +872,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("Test asset definition", managerDemoSetup.smartOfficeId, "SomeRulesCode", GROOVY, false)
+ assetRuleset = new AssetRuleset("Test asset definition", GROOVY, "SomeRulesCode", managerDemoSetup.smartOfficeId, false)
rulesetResource.createAssetRuleset(null, assetRuleset)
then: "access should be forbidden"
diff --git a/test/src/test/groovy/org/openremote/test/rules/residence/JsonRulesTest.groovy b/test/src/test/groovy/org/openremote/test/rules/residence/JsonRulesTest.groovy
index 6ec011598..dcb50fb00 100644
--- a/test/src/test/groovy/org/openremote/test/rules/residence/JsonRulesTest.groovy
+++ b/test/src/test/groovy/org/openremote/test/rules/residence/JsonRulesTest.groovy
@@ -74,10 +74,9 @@ class JsonRulesTest extends Specification implements ManagerContainerTrait {
and: "some rules"
Ruleset ruleset = new TenantRuleset(
- "Demo Apartment - All Lights Off",
- keycloakDemoSetup.tenantA.realm,
- getClass().getResource("/org/openremote/test/rules/BasicJsonRules.json").text,
- Ruleset.Lang.JSON, false
+ "Demo Apartment - All Lights Off", Ruleset.Lang.JSON, getClass().getResource("/org/openremote/test/rules/BasicJsonRules.json").text,
+ keycloakDemoSetup.tenantA.realm
+ , false
)
rulesetStorageService.merge(ruleset)
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
index 1c15827e4..e0ae05d73 100644
--- a/test/src/test/groovy/org/openremote/test/rules/residence/ResidenceAllLightsOffTest.groovy
+++ b/test/src/test/groovy/org/openremote/test/rules/residence/ResidenceAllLightsOffTest.groovy
@@ -35,10 +35,8 @@ class ResidenceAllLightsOffTest extends Specification implements ManagerContaine
and: "some rules"
Ruleset ruleset = new AssetRuleset(
- "Demo Apartment - All Lights Off",
- managerDemoSetup.apartment2Id,
- getClass().getResource("/demo/rules/DemoResidenceAllLightsOff.js").text,
- Ruleset.Lang.JAVASCRIPT, false
+ "Demo Apartment - All Lights Off", Ruleset.Lang.JAVASCRIPT, getClass().getResource("/demo/rules/DemoResidenceAllLightsOff.js").text,
+ managerDemoSetup.apartment2Id, false
)
rulesetStorageService.merge(ruleset)
diff --git a/test/src/test/groovy/org/openremote/test/rules/residence/ResidenceAutoVentilationTest.groovy b/test/src/test/groovy/org/openremote/test/rules/residence/ResidenceAutoVentilationTest.groovy
index 709be4e70..e2d515645 100644
--- a/test/src/test/groovy/org/openremote/test/rules/residence/ResidenceAutoVentilationTest.groovy
+++ b/test/src/test/groovy/org/openremote/test/rules/residence/ResidenceAutoVentilationTest.groovy
@@ -38,10 +38,8 @@ class ResidenceAutoVentilationTest extends Specification implements ManagerConta
and: "some rules"
Ruleset ruleset = new AssetRuleset(
- "Demo Apartment - Auto Ventilation",
- managerDemoSetup.apartment1Id,
- getClass().getResource("/demo/rules/DemoResidenceAutoVentilation.groovy").text,
- Ruleset.Lang.GROOVY, false
+ "Demo Apartment - Auto Ventilation", Ruleset.Lang.GROOVY, getClass().getResource("/demo/rules/DemoResidenceAutoVentilation.groovy").text,
+ managerDemoSetup.apartment1Id, false
)
rulesetStorageService.merge(ruleset)
diff --git a/test/src/test/groovy/org/openremote/test/rules/residence/ResidenceNotifyAlarmTriggerTest.groovy b/test/src/test/groovy/org/openremote/test/rules/residence/ResidenceNotifyAlarmTriggerTest.groovy
index 68f9f87df..a224762c7 100644
--- a/test/src/test/groovy/org/openremote/test/rules/residence/ResidenceNotifyAlarmTriggerTest.groovy
+++ b/test/src/test/groovy/org/openremote/test/rules/residence/ResidenceNotifyAlarmTriggerTest.groovy
@@ -80,10 +80,8 @@ class ResidenceNotifyAlarmTriggerTest extends Specification implements ManagerCo
and: "some rules"
Ruleset ruleset = new AssetRuleset(
- "Demo Apartment - Notify Alarm Trigger",
- managerDemoSetup.apartment1Id,
- getClass().getResource("/demo/rules/DemoResidenceNotifyAlarmTrigger.groovy").text,
- Ruleset.Lang.GROOVY, false
+ "Demo Apartment - Notify Alarm Trigger", Ruleset.Lang.GROOVY, getClass().getResource("/demo/rules/DemoResidenceNotifyAlarmTrigger.groovy").text,
+ managerDemoSetup.apartment1Id, false
)
rulesetStorageService.merge(ruleset)
diff --git a/test/src/test/groovy/org/openremote/test/rules/residence/ResidencePresenceDetectionTest.groovy b/test/src/test/groovy/org/openremote/test/rules/residence/ResidencePresenceDetectionTest.groovy
index 2a77d2cd9..d0dcb24dd 100644
--- a/test/src/test/groovy/org/openremote/test/rules/residence/ResidencePresenceDetectionTest.groovy
+++ b/test/src/test/groovy/org/openremote/test/rules/residence/ResidencePresenceDetectionTest.groovy
@@ -37,10 +37,8 @@ class ResidencePresenceDetectionTest extends Specification implements ManagerCon
and: "some rules"
Ruleset ruleset = new AssetRuleset(
- "Demo Apartment - Presence Detection with motion and CO2 sensors",
- managerDemoSetup.apartment1Id,
- getClass().getResource("/demo/rules/DemoResidencePresenceDetection.groovy").text,
- Ruleset.Lang.GROOVY, false
+ "Demo Apartment - Presence Detection with motion and CO2 sensors", Ruleset.Lang.GROOVY, getClass().getResource("/demo/rules/DemoResidencePresenceDetection.groovy").text,
+ managerDemoSetup.apartment1Id, false
)
rulesetStorageService.merge(ruleset)
@@ -171,10 +169,8 @@ class ResidencePresenceDetectionTest extends Specification implements ManagerCon
and: "some rules"
Ruleset ruleset = new AssetRuleset(
- "Demo Apartment - Presence Detection with motion sensor",
- managerDemoSetup.apartment1Id,
- getClass().getResource("/demo/rules/DemoResidencePresenceDetection.groovy").text,
- Ruleset.Lang.GROOVY, false
+ "Demo Apartment - Presence Detection with motion sensor", Ruleset.Lang.GROOVY, getClass().getResource("/demo/rules/DemoResidencePresenceDetection.groovy").text,
+ managerDemoSetup.apartment1Id, false
)
rulesetStorageService.merge(ruleset)
diff --git a/test/src/test/groovy/org/openremote/test/rules/residence/ResidenceSmartSwitchTest.groovy b/test/src/test/groovy/org/openremote/test/rules/residence/ResidenceSmartSwitchTest.groovy
index a3e198914..6799aa5ae 100644
--- a/test/src/test/groovy/org/openremote/test/rules/residence/ResidenceSmartSwitchTest.groovy
+++ b/test/src/test/groovy/org/openremote/test/rules/residence/ResidenceSmartSwitchTest.groovy
@@ -37,10 +37,8 @@ class ResidenceSmartSwitchTest extends Specification implements ManagerContainer
and: "some rules"
Ruleset ruleset = new AssetRuleset(
- "Demo Apartment - Smart Start",
- managerDemoSetup.apartment1Id,
- getClass().getResource("/demo/rules/DemoResidenceSmartSwitch.groovy").text,
- Ruleset.Lang.GROOVY, false
+ "Demo Apartment - Smart Start", Ruleset.Lang.GROOVY, getClass().getResource("/demo/rules/DemoResidenceSmartSwitch.groovy").text,
+ managerDemoSetup.apartment1Id, false
)
rulesetStorageService.merge(ruleset)
@@ -167,10 +165,8 @@ class ResidenceSmartSwitchTest extends Specification implements ManagerContainer
and: "some rules"
Ruleset ruleset = new AssetRuleset(
- "Demo Apartment - Smart Start",
- managerDemoSetup.apartment1Id,
- getClass().getResource("/demo/rules/DemoResidenceSmartSwitch.groovy").text,
- Ruleset.Lang.GROOVY, false
+ "Demo Apartment - Smart Start", Ruleset.Lang.GROOVY, getClass().getResource("/demo/rules/DemoResidenceSmartSwitch.groovy").text,
+ managerDemoSetup.apartment1Id, false
)
rulesetStorageService.merge(ruleset)
@@ -265,10 +261,8 @@ class ResidenceSmartSwitchTest extends Specification implements ManagerContainer
and: "some rules"
Ruleset ruleset = new AssetRuleset(
- "Demo Apartment - Smart Start",
- managerDemoSetup.apartment1Id,
- getClass().getResource("/demo/rules/DemoResidenceSmartSwitch.groovy").text,
- Ruleset.Lang.GROOVY, false
+ "Demo Apartment - Smart Start", Ruleset.Lang.GROOVY, getClass().getResource("/demo/rules/DemoResidenceSmartSwitch.groovy").text,
+ managerDemoSetup.apartment1Id, false
)
rulesetStorageService.merge(ruleset)
@@ -387,10 +381,8 @@ class ResidenceSmartSwitchTest extends Specification implements ManagerContainer
and: "some rules"
Ruleset ruleset = new AssetRuleset(
- "Demo Apartment - Smart Start",
- managerDemoSetup.apartment1Id,
- getClass().getResource("/demo/rules/DemoResidenceSmartSwitch.groovy").text,
- Ruleset.Lang.GROOVY, false
+ "Demo Apartment - Smart Start", Ruleset.Lang.GROOVY, getClass().getResource("/demo/rules/DemoResidenceSmartSwitch.groovy").text,
+ managerDemoSetup.apartment1Id, false
)
rulesetStorageService.merge(ruleset)
@@ -486,10 +478,8 @@ class ResidenceSmartSwitchTest extends Specification implements ManagerContainer
and: "some rules"
Ruleset ruleset = new AssetRuleset(
- "Demo Apartment - Smart Start",
- managerDemoSetup.apartment1Id,
- getClass().getResource("/demo/rules/DemoResidenceSmartSwitch.groovy").text,
- Ruleset.Lang.GROOVY, false
+ "Demo Apartment - Smart Start", Ruleset.Lang.GROOVY, getClass().getResource("/demo/rules/DemoResidenceSmartSwitch.groovy").text,
+ managerDemoSetup.apartment1Id, false
)
rulesetStorageService.merge(ruleset)
diff --git a/test/src/test/groovy/org/openremote/test/rules/residence/ResidenceVacationModeTest.groovy b/test/src/test/groovy/org/openremote/test/rules/residence/ResidenceVacationModeTest.groovy
index c1bf2f76e..589863926 100644
--- a/test/src/test/groovy/org/openremote/test/rules/residence/ResidenceVacationModeTest.groovy
+++ b/test/src/test/groovy/org/openremote/test/rules/residence/ResidenceVacationModeTest.groovy
@@ -40,10 +40,8 @@ class ResidenceVacationModeTest extends Specification implements ManagerContaine
and: "some rules"
Ruleset ruleset = new AssetRuleset(
- "Demo Apartment - Vacation Mode",
- managerDemoSetup.apartment1Id,
- getClass().getResource("/demo/rules/DemoResidenceVacationMode.groovy").text,
- Ruleset.Lang.GROOVY, false
+ "Demo Apartment - Vacation Mode", Ruleset.Lang.GROOVY, getClass().getResource("/demo/rules/DemoResidenceVacationMode.groovy").text,
+ managerDemoSetup.apartment1Id, false
)
rulesetStorageService.merge(ruleset)