Skip to content

armgit / core

Public Imported from GitHub
0

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

Hotfix for webhook, and other frontend bugfixes for Rules (#890)

Martin Peetersd77289d9f953
diff --git a/manager/src/main/java/org/openremote/manager/rules/JsonRulesBuilder.java b/manager/src/main/java/org/openremote/manager/rules/JsonRulesBuilder.java
index 5cd2b4bbc..54b3f0fc3 100644
--- a/manager/src/main/java/org/openremote/manager/rules/JsonRulesBuilder.java
+++ b/manager/src/main/java/org/openremote/manager/rules/JsonRulesBuilder.java
@@ -47,6 +47,7 @@ import org.openremote.model.webhook.Webhook;
import org.quartz.CronExpression;
import org.shredzone.commons.suncalc.SunTimes;
+import javax.ws.rs.core.MediaType;
import java.time.ZonedDateTime;
import java.util.*;
import java.util.concurrent.ScheduledExecutorService;
@@ -874,16 +875,22 @@ public class JsonRulesBuilder extends RulesBuilder {
if (!TextUtil.isNullOrEmpty(webhook.getPayload()) && webhook.getPayload().contains(PLACEHOLDER_TRIGGER_ASSETS)) {
String triggeredAssetInfo = buildTriggeredAssetInfo(useUnmatched, ruleState, false, true);
webhook.setPayload(webhook.getPayload()
- .replace(PLACEHOLDER_TRIGGER_ASSETS, triggeredAssetInfo)
.replace(('"' + PLACEHOLDER_TRIGGER_ASSETS + '"'), triggeredAssetInfo)
+ .replace(PLACEHOLDER_TRIGGER_ASSETS, triggeredAssetInfo)
);
}
+ if (webhookAction.mediaType == null) {
+ Optional<Map.Entry<String, List<String>>> contentTypeHeader = webhook.getHeaders().entrySet().stream().filter((entry) -> entry.getKey().equalsIgnoreCase("content-type")).findFirst();
+ String contentType = contentTypeHeader.isPresent() ? contentTypeHeader.get().getValue().get(0) : MediaType.APPLICATION_JSON;
+ webhookAction.mediaType = MediaType.valueOf(contentType);
+ }
+
if(webhookAction.target == null) {
webhookAction.target = webhooksFacade.buildTarget(webhook);
}
- return new RuleActionExecution(() -> webhooksFacade.send(webhook, webhookAction.target), 0);
+ return new RuleActionExecution(() -> webhooksFacade.send(webhook, webhookAction.mediaType, webhookAction.target), 0);
}
}
diff --git a/manager/src/main/java/org/openremote/manager/rules/facade/WebhooksFacade.java b/manager/src/main/java/org/openremote/manager/rules/facade/WebhooksFacade.java
index aa2b0e64e..b3b7015c9 100644
--- a/manager/src/main/java/org/openremote/manager/rules/facade/WebhooksFacade.java
+++ b/manager/src/main/java/org/openremote/manager/rules/facade/WebhooksFacade.java
@@ -26,6 +26,7 @@ import org.openremote.model.rules.Webhooks;
import org.openremote.model.webhook.Webhook;
import javax.ws.rs.client.WebTarget;
+import javax.ws.rs.core.MediaType;
public class WebhooksFacade<T extends Ruleset> extends Webhooks {
@@ -38,8 +39,8 @@ public class WebhooksFacade<T extends Ruleset> extends Webhooks {
}
@Override
- public void send(Webhook webhook, WebTarget target) {
- webhookService.sendHttpRequest(webhook, target);
+ public void send(Webhook webhook, MediaType mediaType, WebTarget target) {
+ webhookService.sendHttpRequest(webhook, mediaType, target);
}
@Override
diff --git a/manager/src/main/java/org/openremote/manager/webhook/WebhookService.java b/manager/src/main/java/org/openremote/manager/webhook/WebhookService.java
index eca519fe0..1bbf0166f 100644
--- a/manager/src/main/java/org/openremote/manager/webhook/WebhookService.java
+++ b/manager/src/main/java/org/openremote/manager/webhook/WebhookService.java
@@ -22,8 +22,6 @@ package org.openremote.manager.webhook;
import org.apache.camel.builder.RouteBuilder;
import org.jboss.resteasy.client.jaxrs.ResteasyClient;
import org.jboss.resteasy.client.jaxrs.ResteasyClientBuilder;
-import org.jboss.resteasy.client.jaxrs.ResteasyWebTarget;
-import org.openremote.container.web.WebClient;
import org.openremote.container.web.WebTargetBuilder;
import org.openremote.manager.rules.RulesEngine;
import org.openremote.model.Container;
@@ -34,6 +32,7 @@ import org.openremote.model.webhook.Webhook;
import javax.ws.rs.ProcessingException;
import javax.ws.rs.client.Entity;
import javax.ws.rs.client.WebTarget;
+import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import java.net.URI;
import java.util.concurrent.TimeUnit;
@@ -84,13 +83,14 @@ public class WebhookService extends RouteBuilder implements ContainerService {
// empty
}
- public void sendHttpRequest(Webhook webhook, WebTarget target) {
+ public void sendHttpRequest(Webhook webhook, MediaType mediaType, WebTarget target) {
Response response = null;
try {
- ResteasyWebTarget webTarget = (ResteasyWebTarget) target;
- response = this.buildRequest(webTarget, webhook.getHttpMethod(), webhook.getPayload());
+ response = this.buildRequest(target, webhook.getHttpMethod(), mediaType, webhook.getPayload());
if (response.getStatusInfo().getFamily() != Response.Status.Family.SUCCESSFUL) {
- RulesEngine.LOG.warning("Webhook request responded with error " + response.getStatus());
+ RulesEngine.LOG.warning("Webhook request responded with error " + response.getStatus() + ": " + response.getStatusInfo().getReasonPhrase());
+ } else {
+ RulesEngine.LOG.info("Webhook request executed successfully with response status " + response.getStatus());
}
} catch (Exception e) {
LOG.warning(e.getMessage());
@@ -102,7 +102,8 @@ public class WebhookService extends RouteBuilder implements ContainerService {
}
public WebTarget buildWebTarget(Webhook webhook) {
- ResteasyClient client = WebClient.registerDefaults(clientBuilder).build();
+
+ ResteasyClient client = this.clientBuilder.build();
WebTargetBuilder builder = new WebTargetBuilder(client, URI.create(webhook.getUrl()));
// Authentication
@@ -117,12 +118,7 @@ public class WebhookService extends RouteBuilder implements ContainerService {
return builder.build();
}
- private Response buildRequest(ResteasyWebTarget target, HTTPMethod method, String payload) throws ProcessingException {
- Response response = target.request().method(method.name());
- if (payload != null) {
- return target.request().method(method.name(), Entity.entity(payload, response.getMediaType()));
- } else {
- return response;
- }
+ private Response buildRequest(WebTarget target, HTTPMethod method, MediaType mediaType, String payload) throws ProcessingException {
+ return target.request().method(method.name(), (payload != null ? Entity.entity(payload, mediaType) : null));
}
}
diff --git a/model/src/main/java/org/openremote/model/rules/Webhooks.java b/model/src/main/java/org/openremote/model/rules/Webhooks.java
index 3fe5d5f59..c48248a52 100644
--- a/model/src/main/java/org/openremote/model/rules/Webhooks.java
+++ b/model/src/main/java/org/openremote/model/rules/Webhooks.java
@@ -23,10 +23,11 @@ import org.openremote.model.util.TsIgnore;
import org.openremote.model.webhook.Webhook;
import javax.ws.rs.client.WebTarget;
+import javax.ws.rs.core.MediaType;
@TsIgnore
public abstract class Webhooks {
- public abstract void send(Webhook webhook, WebTarget target);
+ public abstract void send(Webhook webhook, MediaType mediaType, WebTarget target);
public abstract WebTarget buildTarget(Webhook webhook);
}
diff --git a/model/src/main/java/org/openremote/model/rules/json/RuleActionWebhook.java b/model/src/main/java/org/openremote/model/rules/json/RuleActionWebhook.java
index b2b40b572..85d187f85 100644
--- a/model/src/main/java/org/openremote/model/rules/json/RuleActionWebhook.java
+++ b/model/src/main/java/org/openremote/model/rules/json/RuleActionWebhook.java
@@ -22,8 +22,10 @@ package org.openremote.model.rules.json;
import org.openremote.model.webhook.Webhook;
import javax.ws.rs.client.WebTarget;
+import javax.ws.rs.core.MediaType;
public class RuleActionWebhook extends RuleAction {
public Webhook webhook;
+ public MediaType mediaType;
public WebTarget target;
}
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 16e7bfbee..fae32f60d 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
@@ -1,5 +1,6 @@
package org.openremote.test.rules.residence
+import com.fasterxml.jackson.databind.JsonNode
import com.fasterxml.jackson.databind.node.ObjectNode
import com.google.firebase.messaging.Message
import net.fortuna.ical4j.model.Recur
@@ -13,6 +14,7 @@ import org.openremote.manager.notification.PushNotificationHandler
import org.openremote.manager.rules.*
import org.openremote.manager.rules.geofence.ORConsoleGeofenceAssetAdapter
import org.openremote.manager.setup.SetupService
+import org.openremote.manager.webhook.WebhookService
import org.openremote.model.asset.Asset
import org.openremote.model.asset.UserAssetLink
import org.openremote.model.asset.impl.ThingAsset
@@ -39,9 +41,14 @@ import org.openremote.setup.integration.KeycloakTestSetup
import org.openremote.setup.integration.ManagerTestSetup
import org.openremote.test.ManagerContainerTrait
import org.simplejavamail.email.Email
+import spock.lang.Shared
import spock.lang.Specification
import spock.util.concurrent.PollingConditions
+import javax.ws.rs.client.ClientRequestContext
+import javax.ws.rs.client.ClientRequestFilter
+import javax.ws.rs.core.MediaType
+import javax.ws.rs.core.Response
import java.time.Duration
import java.time.Instant
import java.time.temporal.ChronoUnit
@@ -50,11 +57,53 @@ import java.util.concurrent.TimeUnit
import static java.util.concurrent.TimeUnit.HOURS
import static java.util.concurrent.TimeUnit.MILLISECONDS
import static org.openremote.model.Constants.KEYCLOAK_CLIENT_ID
+import static org.openremote.model.rules.RulesetStatus.DEPLOYED
import static org.openremote.model.util.ValueUtil.parse
+import static org.openremote.model.value.ValueType.TEXT
import static org.openremote.setup.integration.ManagerTestSetup.DEMO_RULE_STATES_SMART_BUILDING
class JsonRulesTest extends Specification implements ManagerContainerTrait {
+ @Shared
+ def mockServer = new ClientRequestFilter() {
+
+ private int successCount = 0
+ private int failureCount = 0
+
+ @Override
+ void filter(ClientRequestContext requestContext) throws IOException {
+ def requestUri = requestContext.uri
+ def requestPath = requestUri.scheme + "://" + requestUri.host + requestUri.path
+
+ switch (requestPath) {
+ case "https://basicserver/webhookplain":
+ if (requestContext.method == "POST" && requestContext.mediaType == MediaType.TEXT_PLAIN_TYPE && requestContext.hasEntity() && requestContext.entity == "test-value") {
+ successCount++
+ requestContext.abortWith(Response.ok().build()); return
+ }
+ break
+ case "https://basicserver/webhookjson":
+ if (requestContext.method == "POST" && requestContext.mediaType == MediaType.APPLICATION_JSON_TYPE && requestContext.getHeaderString('test-header') == "test-value" && requestContext.hasEntity()) {
+ Optional<JsonNode> jsonBody = parse(requestContext.entity.toString())
+ if (jsonBody.isPresent() && jsonBody.get().size() == 1
+ && jsonBody.get().iterator().next().get(0).get("assetName").asText() == "TestThing"
+ && jsonBody.get().iterator().next().get(0).get("value").asText() == "test_message") {
+ successCount++
+ requestContext.abortWith(Response.ok().build()); return
+ }
+ }
+ break
+ }
+ failureCount++
+ requestContext.abortWith(Response.serverError().build())
+ }
+ }
+
+ def cleanup() {
+ mockServer.successCount = 0
+ mockServer.failureCount = 0
+ }
+
def "Turn all lights off when console exits the residence geofence"() {
List<PushNotificationMessage> pushMessages = []
@@ -732,4 +781,82 @@ class JsonRulesTest extends Specification implements ManagerContainerTrait {
notificationService.notificationHandlerMap.put(pushNotificationHandler.getTypeName(), pushNotificationHandler)
}
}
+
+ def "Trigger webhook when thing asset has changed"() {
+
+ given: "the container environment is started"
+ def conditions = new PollingConditions(timeout: 15, delay: 0.2)
+ def container = startContainer(defaultConfig(), defaultServices())
+ def keycloakTestSetup = container.getService(SetupService.class).getTaskOfType(KeycloakTestSetup.class)
+ def rulesService = container.getService(RulesService.class)
+ def rulesetStorageService = container.getService(RulesetStorageService.class)
+ def assetStorageService = container.getService(AssetStorageService.class)
+ def assetProcessingService = container.getService(AssetProcessingService.class)
+ def webhookService = container.getService(WebhookService.class)
+ RulesEngine realmBuildingEngine
+
+ and: "the web target builder is configured to use the mock server"
+ if (!webhookService.clientBuilder.configuration.isRegistered(mockServer)) {
+ webhookService.clientBuilder.register(mockServer, Integer.MAX_VALUE)
+ }
+ assert webhookService.clientBuilder.configuration.isRegistered(mockServer)
+
+ and: "a thing asset is added to the building realm"
+ def thingId = UniqueIdentifierGenerator.generateId("TestThing")
+ def thingAsset = new ThingAsset("TestThing")
+ .setId(thingId)
+ .setRealm(keycloakTestSetup.realmBuilding.name)
+ .setLocation(new GeoJSONPoint(0, 0))
+ .addAttributes(
+ new Attribute<>("webhookAttribute", TEXT).addMeta(
+ new MetaItem<>(MetaItemType.RULE_STATE)
+ )
+ )
+ thingAsset = assetStorageService.merge(thingAsset)
+
+ and: "a ruleset with 'has value' condition is added whose action triggers the webhook"
+ Ruleset ruleset = new RealmRuleset(
+ keycloakTestSetup.realmBuilding.name,
+ "Webhook Rule",
+ Ruleset.Lang.JSON,
+ getClass().getResource("/org/openremote/test/rules/JsonRuleWebhook.json").text)
+ ruleset = rulesetStorageService.merge(ruleset)
+ assert ruleset != null
+
+ expect: "the attribute we will change being unset"
+ conditions.eventually {
+ thingAsset = assetStorageService.find(thingId) as ThingAsset
+ assert thingAsset != null
+ assert thingAsset.getAttribute("webhookAttribute").get() != null
+ assert !thingAsset.getAttribute("webhookAttribute").get().getValue().isPresent()
+ }
+
+ and: "the rule engines to become available and be running with asset states and deployments inserted"
+ conditions.eventually {
+ realmBuildingEngine = rulesService.realmEngines.get(keycloakTestSetup.realmBuilding.name)
+ assert realmBuildingEngine != null
+ assert realmBuildingEngine.isRunning()
+ assert realmBuildingEngine.deployments.size() == 1
+ assert realmBuildingEngine.deployments.values().iterator().next().name == "Webhook Rule"
+ assert realmBuildingEngine.deployments.values().iterator().next().status == DEPLOYED
+ assert realmBuildingEngine.assetStates.size() == (DEMO_RULE_STATES_SMART_BUILDING + 1)
+ assert realmBuildingEngine.lastFireTimestamp > 0
+ }
+
+ when: "the webhook attribute is changing"
+ assetProcessingService.sendAttributeEvent(new AttributeEvent(thingId, "webhookAttribute", "test_message"))
+
+ then: "the webhook attribute should have been updated"
+ conditions.eventually {
+ def thingAsset2 = assetStorageService.find(thingId, true)
+ assert thingAsset2 != null
+ assert thingAsset2.getAttribute("webhookAttribute").get().value.get() == "test_message"
+ }
+
+ expect: "The mock server has received a successful response"
+ conditions.eventually {
+ assert mockServer.successCount == 2
+ assert mockServer.failureCount == 0
+ }
+ }
}
diff --git a/test/src/test/resources/org/openremote/test/rules/JsonRuleWebhook.json b/test/src/test/resources/org/openremote/test/rules/JsonRuleWebhook.json
new file mode 100644
index 000000000..754deeba1
--- /dev/null
+++ b/test/src/test/resources/org/openremote/test/rules/JsonRuleWebhook.json
@@ -0,0 +1,77 @@
+{
+ "rules": [
+ {
+ "name": "Webhook Rule",
+ "when": {
+ "operator": "OR",
+ "groups": [
+ {
+ "operator": "AND",
+ "items": [
+ {
+ "assets": {
+ "types": [
+ "ThingAsset"
+ ],
+ "attributes": {
+ "items": [
+ {
+ "name": {
+ "predicateType": "string",
+ "match": "EXACT",
+ "value": "webhookAttribute"
+ },
+ "value": {
+ "match": "EXACT",
+ "negate": false,
+ "predicateType": "string",
+ "value": "test_message"
+ }
+ }
+ ]
+ }
+ }
+ }
+ ]
+ }
+ ]
+ },
+ "then": [
+ {
+ "action": "webhook",
+ "webhook": {
+ "httpMethod": "POST",
+ "payload": "test-value",
+ "headers": {
+ "": [],
+ "content-type": [
+ "text/plain"
+ ]
+ },
+ "url": "https://basicserver/webhookplain"
+ }
+ },
+ {
+ "action": "webhook",
+ "webhook": {
+ "httpMethod": "POST",
+ "payload": "%TRIGGER_ASSETS%",
+ "headers": {
+ "": [],
+ "test-header": [
+ "test-value"
+ ],
+ "content-type": [
+ "application/json"
+ ]
+ },
+ "url": "https://basicserver/webhookjson"
+ }
+ }
+ ],
+ "recurrence": {
+ "mins": 0
+ }
+ }
+ ]
+}
diff --git a/ui/component/or-rules/src/index.ts b/ui/component/or-rules/src/index.ts
index 2132d7ca9..860c63bac 100644
--- a/ui/component/or-rules/src/index.ts
+++ b/ui/component/or-rules/src/index.ts
@@ -497,20 +497,27 @@ export function getAssetInfos(config: RulesConfig | undefined, useActionConfig:
// Function for getting assets by type
// loadedAssets is an object given as parameter that will be updated if new assets are fetched.
-export async function getAssetsByType(type: string, loadedAssets?: Map<string, Asset[]>): Promise<{ assets?: Asset[], loadedAssets?: Map<string, Asset[]>}> {
+export async function getAssetsByType(type: string, realm?: string, loadedAssets?: Map<string, Asset[]>): Promise<{ assets?: Asset[], loadedAssets?: Map<string, Asset[]>}> {
if(loadedAssets?.has(type)) {
return {
assets: loadedAssets?.get(type),
loadedAssets: loadedAssets
}
} else {
- const response = await manager.rest.api.AssetResource.queryAssets({
- types: [ type ],
+ if(!loadedAssets) {
+ loadedAssets = new Map<string, any[]>();
+ }
+ const assetQuery: AssetQuery = {
+ types: [type],
orderBy: {
property: AssetQueryOrderBy$Property.NAME
}
- });
- loadedAssets?.set(type, response.data);
+ }
+ if(realm != undefined) {
+ assetQuery.realm = { name: realm }
+ }
+ const response = await manager.rest.api.AssetResource.queryAssets(assetQuery);
+ loadedAssets.set(type, response.data);
return {
assets: response.data,
loadedAssets: loadedAssets
@@ -791,6 +798,7 @@ export class OrRules extends translate(i18next)(LitElement) {
}
public refresh() {
+ this._viewer.ruleset = undefined;
this._rulesList.refresh();
}
diff --git a/ui/component/or-rules/src/json-viewer/forms/or-rule-form-webhook.ts b/ui/component/or-rules/src/json-viewer/forms/or-rule-form-webhook.ts
index 66d2c6477..13a5f6c6a 100644
--- a/ui/component/or-rules/src/json-viewer/forms/or-rule-form-webhook.ts
+++ b/ui/component/or-rules/src/json-viewer/forms/or-rule-form-webhook.ts
@@ -89,7 +89,6 @@ export class OrRuleFormWebhook extends LitElement {
/* ---------------- */
// Template rendering
-
render() {
return when(!this.webhook, () => html`
${i18next.t('errorOccurred')}
diff --git a/ui/component/or-rules/src/json-viewer/or-rule-json-viewer.ts b/ui/component/or-rules/src/json-viewer/or-rule-json-viewer.ts
index 97b83c806..a02dd4f54 100644
--- a/ui/component/or-rules/src/json-viewer/or-rule-json-viewer.ts
+++ b/ui/component/or-rules/src/json-viewer/or-rule-json-viewer.ts
@@ -22,7 +22,7 @@ import {
RulesetUnion,
ValuePredicateUnion
} from "@openremote/model";
-import {Util} from "@openremote/core";
+import manager, {Util} from "@openremote/core";
import "./or-rule-when";
import "./or-rule-then-otherwise";
import "@openremote/or-components/or-panel";
@@ -120,8 +120,8 @@ export class OrRuleJsonViewer extends translate(i18next)(LitElement) implements
@property({attribute: false})
protected _ruleset!: RulesetUnion;
- @state()
- protected _loadedAssets: Map<string, Asset[]> = new Map<string, []>();
+ @state() // to be exact: Map<AssetType name, Asset[]>
+ protected _loadedAssets: Map<string, Asset[]> = new Map<string, Asset[]>();
protected _rule!: JsonRule;
protected _unsupported = false;
@@ -223,11 +223,10 @@ export class OrRuleJsonViewer extends translate(i18next)(LitElement) implements
const data = await (this._activeAssetPromises.get(type)); // await for the already existing fetch
return data.assets;
} else {
- const promise = getAssetsByType(type, this._loadedAssets);
+ const promise = getAssetsByType(type, (this._ruleset.type == "realm" ? this._ruleset.realm : undefined), this._loadedAssets);
this._activeAssetPromises.set(type, promise);
const data = await promise;
this._activeAssetPromises.delete(type);
- this._loadedAssets = data.loadedAssets!;
return data.assets;
}
}
diff --git a/ui/component/or-rules/src/json-viewer/or-rule-then-otherwise.ts b/ui/component/or-rules/src/json-viewer/or-rule-then-otherwise.ts
index 7fe93b9b4..09529fe66 100644
--- a/ui/component/or-rules/src/json-viewer/or-rule-then-otherwise.ts
+++ b/ui/component/or-rules/src/json-viewer/or-rule-then-otherwise.ts
@@ -5,6 +5,7 @@ import "./or-rule-asset-query";
import {ActionType, getAssetTypeFromQuery, RulesConfig} from "../index";
import {OrRulesJsonRuleChangedEvent} from "./or-rule-json-viewer";
import {
+ Asset,
AssetModelUtil,
AssetTypeInfo,
HTTPMethod,
@@ -13,8 +14,7 @@ import {
RuleActionUnion,
RuleActionWebhook,
RuleRecurrence,
- WellknownAssets,
- Asset
+ WellknownAssets
} from "@openremote/model";
import i18next from "i18next";
import {InputType} from "@openremote/or-mwc-components/or-mwc-input";
diff --git a/ui/component/or-rules/src/or-rule-list.ts b/ui/component/or-rules/src/or-rule-list.ts
index 490776025..24e885c20 100644
--- a/ui/component/or-rules/src/or-rule-list.ts
+++ b/ui/component/or-rules/src/or-rule-list.ts
@@ -1,6 +1,6 @@
import {css, html, LitElement, PropertyValues, TemplateResult} from "lit";
import {customElement, property} from "lit/decorators.js";
-import {CalendarEvent, ClientRole, RulesetLang, RulesetUnion, RealmRuleset, WellknownRulesetMetaItems} from "@openremote/model";
+import {CalendarEvent, ClientRole, RulesetLang, RulesetUnion, RealmRuleset, GlobalRuleset} from "@openremote/model";
import "@openremote/or-translate";
import manager, {Util} from "@openremote/core";
import "@openremote/or-mwc-components/or-mwc-input";
@@ -123,6 +123,7 @@ export class OrRuleList extends translate(i18next)(LitElement) {
protected _globalRulesets: boolean = false;
protected _selectedNodes: RulesetNode[] = [];
+ protected _rulesetPromises: Map<string, Promise<any[]>> = new Map<string, Promise<any[]>>();
protected _ready = false;
static get styles() {
@@ -134,7 +135,7 @@ export class OrRuleList extends translate(i18next)(LitElement) {
public async refresh() {
this._nodes = undefined;
- await this._loadRulesets();
+ // reloading rulesets is automatically done in shouldUpdate()
}
protected get _allowedLanguages(): RulesetLang[] | undefined {
@@ -637,28 +638,37 @@ export class OrRuleList extends translate(i18next)(LitElement) {
protected async _loadRulesets() {
const sortFunction = this._getSortFunction();
-
- if(this._globalRulesets) {
- manager.rest.api.RulesResource.getGlobalRulesets({fullyPopulate: true }).then((response: any) => {
- if (response && response.data) {
- this._buildTreeNodes(response.data, sortFunction);
- }
- }).catch((reason: any) => {
- console.error("Error: " + reason);
- });
- } else {
- const params = {
- fullyPopulate: true,
- language: this._allowedLanguages
+ let data;
+
+ // Global rulesets
+ if (this._globalRulesets) {
+ if (this._rulesetPromises.size == 0 && !this._rulesetPromises.has("global")) {
+ this._rulesetPromises.set("global", new Promise<GlobalRuleset[]>(async (resolve) => {
+ const response = await manager.rest.api.RulesResource.getGlobalRulesets({fullyPopulate: true});
+ resolve(response.data);
+ }));
}
- try {
- const response = await manager.rest.api.RulesResource.getRealmRulesets(this._getRealm() || manager.displayRealm, params);
- if (response && response.data) {
- this._buildTreeNodes(response.data, sortFunction);
- }
- } catch (e) {
- console.error("Error: " + e);
+ data = await this._rulesetPromises.get("global");
+ this._rulesetPromises.delete("global");
+ }
+
+ // Realm rulesets
+ else {
+ const ruleRealm: string = this._getRealm() || manager.displayRealm;
+ if (this._rulesetPromises.size == 0 && !this._rulesetPromises.has(ruleRealm)) {
+ this._rulesetPromises.set(ruleRealm, new Promise<RealmRuleset[]>(async (resolve) => {
+ const params = {fullyPopulate: true, language: this._allowedLanguages}
+ const response = await manager.rest.api.RulesResource.getRealmRulesets(ruleRealm, params);
+ resolve(response.data);
+ }));
}
+ data = await this._rulesetPromises.get(ruleRealm);
+ this._rulesetPromises.delete(ruleRealm);
+ }
+
+ // ... building the nodes
+ if (data) {
+ this._buildTreeNodes(data, sortFunction);
}
}