From 533fb83ec7ee74c25a0d47c2af0738f5a0997988 Mon Sep 17 00:00:00 2001 From: nick Date: Wed, 27 Sep 2023 15:12:34 +0300 Subject: [PATCH 01/43] tbe: fix_bug Integer from Json to Long --- pom.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pom.xml b/pom.xml index 6eba036d51..02d610fd9f 100755 --- a/pom.xml +++ b/pom.xml @@ -78,7 +78,7 @@ 3.8.1 3.21.9 1.42.1 - 1.1.1 + 1.1.2 1.18.18 1.2.4 1.2.5 From 8c94ec5c5277610c1dd494c75c1c677898885210 Mon Sep 17 00:00:00 2001 From: Volodymyr Babak Date: Mon, 16 Oct 2023 18:05:12 +0300 Subject: [PATCH 02/43] Edge: do not sync User login actions. Edge: do not save particular edge events in case edge is not activated or disconnected --- .../edge/EdgeEventSourcingListener.java | 42 +++++++++++--- .../edge/rpc/processor/BaseEdgeProcessor.java | 58 +++++++++++++++++++ .../server/edge/AbstractEdgeTest.java | 49 +++++++--------- .../server/edge/DeviceEdgeTest.java | 2 - .../thingsboard/server/edge/UserEdgeTest.java | 8 --- .../dao/eventsourcing/SaveEntityEvent.java | 1 + .../server/dao/user/UserServiceImpl.java | 7 ++- 7 files changed, 119 insertions(+), 48 deletions(-) diff --git a/application/src/main/java/org/thingsboard/server/service/edge/EdgeEventSourcingListener.java b/application/src/main/java/org/thingsboard/server/service/edge/EdgeEventSourcingListener.java index 43b05094a4..707dbec964 100644 --- a/application/src/main/java/org/thingsboard/server/service/edge/EdgeEventSourcingListener.java +++ b/application/src/main/java/org/thingsboard/server/service/edge/EdgeEventSourcingListener.java @@ -15,6 +15,8 @@ */ package org.thingsboard.server.service.edge; +import com.fasterxml.jackson.databind.node.NullNode; +import com.fasterxml.jackson.databind.node.ObjectNode; import lombok.RequiredArgsConstructor; import lombok.extern.slf4j.Slf4j; import org.springframework.stereotype.Component; @@ -36,6 +38,7 @@ import org.thingsboard.server.dao.eventsourcing.ActionEntityEvent; import org.thingsboard.server.dao.eventsourcing.DeleteEntityEvent; import org.thingsboard.server.dao.eventsourcing.RelationActionEvent; import org.thingsboard.server.dao.eventsourcing.SaveEntityEvent; +import org.thingsboard.server.dao.user.UserServiceImpl; import javax.annotation.PostConstruct; @@ -75,7 +78,7 @@ public class EdgeEventSourcingListener { return; } try { - if (!isValidEdgeEventEntity(event.getEntity())) { + if (!isValidEdgeEventEntity(event.getEntity(), event.getOldEntity())) { return; } log.trace("[{}] SaveEntityEvent called: {}", event.getTenantId(), event); @@ -83,7 +86,7 @@ public class EdgeEventSourcingListener { tbClusterService.sendNotificationMsgToEdge(event.getTenantId(), null, event.getEntityId(), null, null, action); } catch (Exception e) { - log.error("[{}] failed to process SaveEntityEvent: {}", event.getTenantId(), event); + log.error("[{}] failed to process SaveEntityEvent: {}", event.getTenantId(), event, e); } } @@ -97,7 +100,7 @@ public class EdgeEventSourcingListener { tbClusterService.sendNotificationMsgToEdge(event.getTenantId(), event.getEdgeId(), event.getEntityId(), JacksonUtil.toString(event.getEntity()), null, EdgeEventActionType.DELETED); } catch (Exception e) { - log.error("[{}] failed to process DeleteEntityEvent: {}", event.getTenantId(), event); + log.error("[{}] failed to process DeleteEntityEvent: {}", event.getTenantId(), event, e); } } @@ -111,7 +114,7 @@ public class EdgeEventSourcingListener { tbClusterService.sendNotificationMsgToEdge(event.getTenantId(), event.getEdgeId(), event.getEntityId(), event.getBody(), null, edgeTypeByActionType(event.getActionType())); } catch (Exception e) { - log.error("[{}] failed to process ActionEntityEvent: {}", event.getTenantId(), event); + log.error("[{}] failed to process ActionEntityEvent: {}", event.getTenantId(), event, e); } } @@ -134,11 +137,11 @@ public class EdgeEventSourcingListener { tbClusterService.sendNotificationMsgToEdge(event.getTenantId(), null, null, JacksonUtil.toString(relation), EdgeEventType.RELATION, edgeTypeByActionType(event.getActionType())); } catch (Exception e) { - log.error("[{}] failed to process RelationActionEvent: {}", event.getTenantId(), event); + log.error("[{}] failed to process RelationActionEvent: {}", event.getTenantId(), event, e); } } - private boolean isValidEdgeEventEntity(Object entity) { + private boolean isValidEdgeEventEntity(Object entity, Object oldEntity) { if (entity instanceof OtaPackageInfo) { OtaPackageInfo otaPackageInfo = (OtaPackageInfo) entity; return otaPackageInfo.hasUrl() || otaPackageInfo.isHasData(); @@ -147,7 +150,15 @@ public class EdgeEventSourcingListener { return RuleChainType.EDGE.equals(ruleChain.getType()); } else if (entity instanceof User) { User user = (User) entity; - return !Authority.SYS_ADMIN.equals(user.getAuthority()); + if (Authority.SYS_ADMIN.equals(user.getAuthority())) { + return false; + } + if (oldEntity != null) { + User oldUser = (User) oldEntity; + cleanUpUserAdditionalInfo(oldUser); + cleanUpUserAdditionalInfo(user); + return !user.equals(oldUser); + } } else if (entity instanceof AlarmApiCallResult) { AlarmApiCallResult alarmApiCallResult = (AlarmApiCallResult) entity; return alarmApiCallResult.isModified(); @@ -155,4 +166,21 @@ public class EdgeEventSourcingListener { // Default: If the entity doesn't match any of the conditions, consider it as valid. return true; } + + private void cleanUpUserAdditionalInfo(User user) { + // reset FAILED_LOGIN_ATTEMPTS and LAST_LOGIN_TS - edge is not interested in this information + if (user.getAdditionalInfo() instanceof NullNode) { + user.setAdditionalInfo(null); + } + if (user.getAdditionalInfo() instanceof ObjectNode) { + ObjectNode additionalInfo = ((ObjectNode) user.getAdditionalInfo()); + additionalInfo.remove(UserServiceImpl.FAILED_LOGIN_ATTEMPTS); + additionalInfo.remove(UserServiceImpl.LAST_LOGIN_TS); + if (additionalInfo.isEmpty()) { + user.setAdditionalInfo(null); + } else { + user.setAdditionalInfo(additionalInfo); + } + } + } } diff --git a/application/src/main/java/org/thingsboard/server/service/edge/rpc/processor/BaseEdgeProcessor.java b/application/src/main/java/org/thingsboard/server/service/edge/rpc/processor/BaseEdgeProcessor.java index 328a64efe2..2d86c1e184 100644 --- a/application/src/main/java/org/thingsboard/server/service/edge/rpc/processor/BaseEdgeProcessor.java +++ b/application/src/main/java/org/thingsboard/server/service/edge/rpc/processor/BaseEdgeProcessor.java @@ -24,6 +24,7 @@ import org.springframework.context.annotation.Lazy; import org.thingsboard.common.util.JacksonUtil; import org.thingsboard.server.cluster.TbClusterService; import org.thingsboard.server.common.data.Dashboard; +import org.thingsboard.server.common.data.DataConstants; import org.thingsboard.server.common.data.Device; import org.thingsboard.server.common.data.DeviceProfile; import org.thingsboard.server.common.data.EdgeUtils; @@ -46,6 +47,7 @@ import org.thingsboard.server.common.data.id.EntityViewId; import org.thingsboard.server.common.data.id.RuleChainId; import org.thingsboard.server.common.data.id.TenantId; import org.thingsboard.server.common.data.id.UserId; +import org.thingsboard.server.common.data.kv.AttributeKvEntry; import org.thingsboard.server.common.data.msg.TbMsgType; import org.thingsboard.server.common.data.page.PageData; import org.thingsboard.server.common.data.page.PageLink; @@ -110,11 +112,13 @@ import org.thingsboard.server.service.entitiy.TbNotificationEntityService; import org.thingsboard.server.service.executors.DbCallbackExecutorService; import org.thingsboard.server.service.profile.TbAssetProfileCache; import org.thingsboard.server.service.profile.TbDeviceProfileCache; +import org.thingsboard.server.service.state.DefaultDeviceStateService; import org.thingsboard.server.service.state.DeviceStateService; import org.thingsboard.server.service.telemetry.TelemetrySubscriptionService; import java.util.ArrayList; import java.util.List; +import java.util.Optional; import java.util.UUID; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; @@ -305,6 +309,60 @@ public abstract class BaseEdgeProcessor { EdgeEventActionType action, EntityId entityId, JsonNode body) { + ListenableFuture> future = attributesService.find(tenantId, edgeId, DataConstants.SERVER_SCOPE, DefaultDeviceStateService.ACTIVITY_STATE); + return Futures.transformAsync(future, activeOpt -> { + if (activeOpt.isEmpty()) { + log.trace("Edge is not activated. Skipping event. tenantId [{}], edgeId [{}], type[{}], " + + "action [{}], entityId [{}], body [{}]", + tenantId, edgeId, type, action, entityId, body); + return Futures.immediateFuture(null); + } + if (activeOpt.get().getBooleanValue().isPresent() && activeOpt.get().getBooleanValue().get()) { + return doSaveEdgeEvent(tenantId, edgeId, type, action, entityId, body); + } else { + if (doSaveIfEdgeIsOffline(type, action)) { + return doSaveEdgeEvent(tenantId, edgeId, type, action, entityId, body); + } else { + log.trace("Edge is not active at the moment. Skipping event. tenantId [{}], edgeId [{}], type[{}], " + + "action [{}], entityId [{}], body [{}]", + tenantId, edgeId, type, action, entityId, body); + return Futures.immediateFuture(null); + } + } + }, dbCallbackExecutorService); + } + + private boolean doSaveIfEdgeIsOffline(EdgeEventType type, + EdgeEventActionType action) { + switch (action) { + case TIMESERIES_UPDATED: + case ALARM_ACK: + case ALARM_CLEAR: + case ALARM_ASSIGNED: + case ALARM_UNASSIGNED: + case CREDENTIALS_REQUEST: + return true; + } + switch (type) { + case ALARM: + case RULE_CHAIN: + case RULE_CHAIN_METADATA: + case USER: + case CUSTOMER: + case TENANT: + case TENANT_PROFILE: + case WIDGETS_BUNDLE: + case WIDGET_TYPE: + case ADMIN_SETTINGS: + case OTA_PACKAGE: + case QUEUE: + case RELATION: + return true; + } + return false; + } + + private ListenableFuture doSaveEdgeEvent(TenantId tenantId, EdgeId edgeId, EdgeEventType type, EdgeEventActionType action, EntityId entityId, JsonNode body) { log.debug("Pushing event to edge queue. tenantId [{}], edgeId [{}], type[{}], " + "action [{}], entityId [{}], body [{}]", tenantId, edgeId, type, action, entityId, body); diff --git a/application/src/test/java/org/thingsboard/server/edge/AbstractEdgeTest.java b/application/src/test/java/org/thingsboard/server/edge/AbstractEdgeTest.java index 689847416c..43544dd5cf 100644 --- a/application/src/test/java/org/thingsboard/server/edge/AbstractEdgeTest.java +++ b/application/src/test/java/org/thingsboard/server/edge/AbstractEdgeTest.java @@ -130,7 +130,7 @@ abstract public class AbstractEdgeTest extends AbstractControllerTest { installation(); edgeImitator = new EdgeImitator("localhost", 7070, edge.getRoutingKey(), edge.getSecret()); - edgeImitator.expectMessageAmount(26); + edgeImitator.expectMessageAmount(21); edgeImitator.connect(); requestEdgeRuleChainMetadata(); @@ -163,9 +163,7 @@ abstract public class AbstractEdgeTest extends AbstractControllerTest { @After public void teardownEdgeTest() { try { - edgeImitator.expectMessageAmount(2); loginTenantAdmin(); - Assert.assertTrue(edgeImitator.waitForMessages()); doDelete("/api/edge/" + edge.getId().toString()) .andExpect(status().isOk()); @@ -228,33 +226,33 @@ abstract public class AbstractEdgeTest extends AbstractControllerTest { // 1 message from queue fetcher validateQueues(); - // 2 messages - 1 from rule chain fetcher and 1 from rule chain controller + // 1 from rule chain fetcher UUID ruleChainUUID = validateRuleChains(); // 1 from request message validateRuleChainMetadataUpdates(ruleChainUUID); - // 4 messages - 4 messages from fetcher - 2 from system level ('mail', 'mailTemplates') and 2 from admin level ('mail', 'mailTemplates') + // 4 messages + // - 2 from fetcher - system level ('mail', 'mailTemplates') + // - 2 from fetcher - admin level ('mail', 'mailTemplates') validateAdminSettings(); - // 5 messages + // 4 messages // - 1 from default profile fetcher // - 2 from device profile fetcher (default and thermostat) // - 1 from device fetcher - // - 1 from device controller (thermostat) validateDeviceProfiles(); - // 4 messages + // 3 messages // - 1 from default profile fetcher // - 1 message from asset profile fetcher // - 1 message from asset fetcher - // - 1 message from asset controller validateAssetProfiles(); - // 2 messages - 1 from device fetcher and 1 from device controller + // 1 from device fetcher validateDevices(); - // 2 messages - 1 from asset fetcher and 1 from asset controller + // 1 from asset fetcher validateAssets(); // 1 message from public customer fetcher @@ -308,8 +306,7 @@ abstract public class AbstractEdgeTest extends AbstractControllerTest { // default msg device profile from fetcher // thermostat msg from device profile fetcher // thermostat msg from device fetcher - // thermostat msg from creation of device - Assert.assertEquals(5, deviceProfileUpdateMsgList.size()); + Assert.assertEquals(4, deviceProfileUpdateMsgList.size()); Optional thermostatProfileUpdateMsgOpt = deviceProfileUpdateMsgList.stream().filter(dfum -> THERMOSTAT_DEVICE_PROFILE_NAME.equals(dfum.getName())).findAny(); Assert.assertTrue(thermostatProfileUpdateMsgOpt.isPresent()); @@ -326,10 +323,9 @@ abstract public class AbstractEdgeTest extends AbstractControllerTest { } private void validateDevices() throws Exception { - List deviceUpdateMsgs = edgeImitator.findAllMessagesByType(DeviceUpdateMsg.class); - Assert.assertEquals(2, deviceUpdateMsgs.size()); - validateDevice(deviceUpdateMsgs.get(0)); - validateDevice(deviceUpdateMsgs.get(1)); + Optional deviceUpdateMsgOpt = edgeImitator.findMessageByType(DeviceUpdateMsg.class); + Assert.assertTrue(deviceUpdateMsgOpt.isPresent()); + validateDevice(deviceUpdateMsgOpt.get()); } private void validateDevice(DeviceUpdateMsg deviceUpdateMsg) throws Exception { @@ -345,10 +341,9 @@ abstract public class AbstractEdgeTest extends AbstractControllerTest { } private void validateAssets() throws Exception { - List assetUpdateMsgs = edgeImitator.findAllMessagesByType(AssetUpdateMsg.class); - Assert.assertEquals(2, assetUpdateMsgs.size()); - validateAsset(assetUpdateMsgs.get(0)); - validateAsset(assetUpdateMsgs.get(1)); + Optional assetUpdateMsgOpt = edgeImitator.findMessageByType(AssetUpdateMsg.class); + Assert.assertTrue(assetUpdateMsgOpt.isPresent()); + validateAsset(assetUpdateMsgOpt.get()); } private void validateAsset(AssetUpdateMsg assetUpdateMsg) throws Exception { @@ -365,12 +360,10 @@ abstract public class AbstractEdgeTest extends AbstractControllerTest { } private UUID validateRuleChains() throws Exception { - List ruleChainUpdateMsgs = edgeImitator.findAllMessagesByType(RuleChainUpdateMsg.class); - Assert.assertEquals(2, ruleChainUpdateMsgs.size()); - RuleChainUpdateMsg ruleChainCreateMsg = ruleChainUpdateMsgs.get(0); - RuleChainUpdateMsg ruleChainUpdateMsg = ruleChainUpdateMsgs.get(1); - validateRuleChain(ruleChainCreateMsg, UpdateMsgType.ENTITY_CREATED_RPC_MESSAGE); - validateRuleChain(ruleChainUpdateMsg, UpdateMsgType.ENTITY_UPDATED_RPC_MESSAGE); + Optional ruleChainUpdateMsgOpt = edgeImitator.findMessageByType(RuleChainUpdateMsg.class); + Assert.assertTrue(ruleChainUpdateMsgOpt.isPresent()); + RuleChainUpdateMsg ruleChainUpdateMsg = ruleChainUpdateMsgOpt.get(); + validateRuleChain(ruleChainUpdateMsg, UpdateMsgType.ENTITY_CREATED_RPC_MESSAGE); return new UUID(ruleChainUpdateMsg.getIdMSB(), ruleChainUpdateMsg.getIdLSB()); } @@ -429,7 +422,7 @@ abstract public class AbstractEdgeTest extends AbstractControllerTest { private void validateAssetProfiles() throws Exception { List assetProfileUpdateMsgs = edgeImitator.findAllMessagesByType(AssetProfileUpdateMsg.class); - Assert.assertEquals(4, assetProfileUpdateMsgs.size()); + Assert.assertEquals(3, assetProfileUpdateMsgs.size()); AssetProfileUpdateMsg assetProfileUpdateMsg = assetProfileUpdateMsgs.get(0); Assert.assertEquals(UpdateMsgType.ENTITY_CREATED_RPC_MESSAGE, assetProfileUpdateMsg.getMsgType()); UUID assetProfileUUID = new UUID(assetProfileUpdateMsg.getIdMSB(), assetProfileUpdateMsg.getIdLSB()); diff --git a/application/src/test/java/org/thingsboard/server/edge/DeviceEdgeTest.java b/application/src/test/java/org/thingsboard/server/edge/DeviceEdgeTest.java index aed99b4cba..ca8dd5dbf0 100644 --- a/application/src/test/java/org/thingsboard/server/edge/DeviceEdgeTest.java +++ b/application/src/test/java/org/thingsboard/server/edge/DeviceEdgeTest.java @@ -274,9 +274,7 @@ public class DeviceEdgeTest extends AbstractEdgeTest { tenantProfile.getProfileData().setConfiguration(profileConfiguration); doPost("/api/tenantProfile/", tenantProfile, TenantProfile.class); - edgeImitator.expectMessageAmount(2); loginTenantAdmin(); - Assert.assertTrue(edgeImitator.waitForMessages()); UUID uuid = Uuids.timeBased(); diff --git a/application/src/test/java/org/thingsboard/server/edge/UserEdgeTest.java b/application/src/test/java/org/thingsboard/server/edge/UserEdgeTest.java index 3fd39328d5..3dc398b9f3 100644 --- a/application/src/test/java/org/thingsboard/server/edge/UserEdgeTest.java +++ b/application/src/test/java/org/thingsboard/server/edge/UserEdgeTest.java @@ -79,9 +79,7 @@ public class UserEdgeTest extends AbstractEdgeTest { Assert.assertEquals(savedTenantAdmin.getLastName(), userUpdateMsg.getLastName()); // update user credentials - edgeImitator.expectMessageAmount(2); login(savedTenantAdmin.getEmail(), "tenant"); - Assert.assertTrue(edgeImitator.waitForMessages()); edgeImitator.expectMessageAmount(1); ChangePasswordRequest changePasswordRequest = new ChangePasswordRequest(); @@ -96,9 +94,7 @@ public class UserEdgeTest extends AbstractEdgeTest { Assert.assertEquals(savedTenantAdmin.getUuidId().getLeastSignificantBits(), userCredentialsUpdateMsg.getUserIdLSB()); Assert.assertTrue(passwordEncoder.matches(changePasswordRequest.getNewPassword(), userCredentialsUpdateMsg.getPassword())); - edgeImitator.expectMessageAmount(2); loginTenantAdmin(); - Assert.assertTrue(edgeImitator.waitForMessages()); // delete user edgeImitator.expectMessageAmount(1); @@ -164,9 +160,7 @@ public class UserEdgeTest extends AbstractEdgeTest { Assert.assertEquals(savedCustomerUser.getLastName(), userUpdateMsg.getLastName()); // update user credentials - edgeImitator.expectMessageAmount(2); login(savedCustomerUser.getEmail(), "customer"); - Assert.assertTrue(edgeImitator.waitForMessages()); edgeImitator.expectMessageAmount(1); ChangePasswordRequest changePasswordRequest = new ChangePasswordRequest(); @@ -181,9 +175,7 @@ public class UserEdgeTest extends AbstractEdgeTest { Assert.assertEquals(savedCustomerUser.getUuidId().getLeastSignificantBits(), userCredentialsUpdateMsg.getUserIdLSB()); Assert.assertTrue(passwordEncoder.matches(changePasswordRequest.getNewPassword(), userCredentialsUpdateMsg.getPassword())); - edgeImitator.expectMessageAmount(2); loginTenantAdmin(); - Assert.assertTrue(edgeImitator.waitForMessages()); // delete user edgeImitator.expectMessageAmount(1); diff --git a/dao/src/main/java/org/thingsboard/server/dao/eventsourcing/SaveEntityEvent.java b/dao/src/main/java/org/thingsboard/server/dao/eventsourcing/SaveEntityEvent.java index 205f592d43..cc2e854f59 100644 --- a/dao/src/main/java/org/thingsboard/server/dao/eventsourcing/SaveEntityEvent.java +++ b/dao/src/main/java/org/thingsboard/server/dao/eventsourcing/SaveEntityEvent.java @@ -25,6 +25,7 @@ import org.thingsboard.server.common.data.id.TenantId; public class SaveEntityEvent { private final TenantId tenantId; private final T entity; + private final T oldEntity; private final EntityId entityId; private final Boolean added; } diff --git a/dao/src/main/java/org/thingsboard/server/dao/user/UserServiceImpl.java b/dao/src/main/java/org/thingsboard/server/dao/user/UserServiceImpl.java index 4db1eb668a..a584fef86c 100644 --- a/dao/src/main/java/org/thingsboard/server/dao/user/UserServiceImpl.java +++ b/dao/src/main/java/org/thingsboard/server/dao/user/UserServiceImpl.java @@ -70,8 +70,8 @@ public class UserServiceImpl extends AbstractEntityService implements UserServic public static final String USER_PASSWORD_HISTORY = "userPasswordHistory"; - private static final String LAST_LOGIN_TS = "lastLoginTs"; - private static final String FAILED_LOGIN_ATTEMPTS = "failedLoginAttempts"; + public static final String LAST_LOGIN_TS = "lastLoginTs"; + public static final String FAILED_LOGIN_ATTEMPTS = "failedLoginAttempts"; private static final int DEFAULT_TOKEN_LENGTH = 30; public static final String INCORRECT_USER_ID = "Incorrect userId "; @@ -126,7 +126,7 @@ public class UserServiceImpl extends AbstractEntityService implements UserServic @Override public User saveUser(TenantId tenantId, User user) { log.trace("Executing saveUser [{}]", user); - userValidator.validate(user, User::getTenantId); + User oldUser = userValidator.validate(user, User::getTenantId); if (!userLoginCaseSensitive) { user.setEmail(user.getEmail().toLowerCase()); } @@ -143,6 +143,7 @@ public class UserServiceImpl extends AbstractEntityService implements UserServic eventPublisher.publishEvent(SaveEntityEvent.builder() .tenantId(tenantId == null ? TenantId.SYS_TENANT_ID : tenantId) .entity(savedUser) + .oldEntity(oldUser) .entityId(savedUser.getId()) .added(user.getId() == null).build()); return savedUser; From 9d19a15413cc2ec629aaed4d8ab6fef81542595d Mon Sep 17 00:00:00 2001 From: YevhenBondarenko Date: Tue, 17 Oct 2023 15:12:48 +0200 Subject: [PATCH 03/43] used bouncycastle for parsing cert pem credentials --- .../credentials/CertPemCredentials.java | 302 +++++------------- .../credentials/CertPemCredentialsTest.java | 28 ++ .../src/test/resources/pem/ec_key.pem | 8 + .../test/resources/pem/rsa_encrypted_key.pem | 30 ++ .../pem/rsa_encrypted_traditional_key.pem | 30 ++ .../src/test/resources/pem/rsa_key.pem | 52 +++ 6 files changed, 226 insertions(+), 224 deletions(-) create mode 100644 rule-engine/rule-engine-components/src/test/resources/pem/ec_key.pem create mode 100644 rule-engine/rule-engine-components/src/test/resources/pem/rsa_encrypted_key.pem create mode 100644 rule-engine/rule-engine-components/src/test/resources/pem/rsa_encrypted_traditional_key.pem create mode 100644 rule-engine/rule-engine-components/src/test/resources/pem/rsa_key.pem diff --git a/rule-engine/rule-engine-components/src/main/java/org/thingsboard/rule/engine/credentials/CertPemCredentials.java b/rule-engine/rule-engine-components/src/main/java/org/thingsboard/rule/engine/credentials/CertPemCredentials.java index 0137887aaf..c17f71bc33 100644 --- a/rule-engine/rule-engine-components/src/main/java/org/thingsboard/rule/engine/credentials/CertPemCredentials.java +++ b/rule-engine/rule-engine-components/src/main/java/org/thingsboard/rule/engine/credentials/CertPemCredentials.java @@ -20,68 +20,57 @@ import io.netty.handler.ssl.SslContext; import io.netty.handler.ssl.SslContextBuilder; import lombok.Data; import lombok.extern.slf4j.Slf4j; -import org.apache.commons.codec.binary.Base64; +import org.bouncycastle.asn1.pkcs.PrivateKeyInfo; +import org.bouncycastle.cert.X509CertificateHolder; +import org.bouncycastle.cert.jcajce.JcaX509CertificateConverter; import org.bouncycastle.jce.provider.BouncyCastleProvider; import org.bouncycastle.openssl.PEMDecryptorProvider; import org.bouncycastle.openssl.PEMEncryptedKeyPair; import org.bouncycastle.openssl.PEMKeyPair; +import org.bouncycastle.openssl.PEMParser; import org.bouncycastle.openssl.jcajce.JcaPEMKeyConverter; import org.bouncycastle.openssl.jcajce.JcePEMDecryptorProviderBuilder; -import org.bouncycastle.util.encoders.Hex; +import org.bouncycastle.operator.InputDecryptorProvider; +import org.bouncycastle.pkcs.PKCS8EncryptedPrivateKeyInfo; +import org.bouncycastle.pkcs.PKCSException; +import org.bouncycastle.pkcs.jcajce.JcePKCSPBEInputDecryptorProviderBuilder; import org.thingsboard.server.common.data.StringUtils; -import javax.crypto.Cipher; -import javax.crypto.EncryptedPrivateKeyInfo; -import javax.crypto.SecretKey; -import javax.crypto.SecretKeyFactory; -import javax.crypto.spec.IvParameterSpec; -import javax.crypto.spec.PBEKeySpec; -import javax.crypto.spec.SecretKeySpec; import javax.net.ssl.KeyManagerFactory; import javax.net.ssl.TrustManagerFactory; -import java.io.ByteArrayInputStream; -import java.io.InputStream; -import java.math.BigInteger; -import java.nio.ByteBuffer; -import java.security.AlgorithmParameters; -import java.security.Key; -import java.security.KeyFactory; -import java.security.KeyPair; +import java.io.IOException; +import java.io.StringReader; +import java.security.GeneralSecurityException; import java.security.KeyStore; -import java.security.MessageDigest; import java.security.PrivateKey; import java.security.Security; +import java.security.cert.CertPath; import java.security.cert.Certificate; import java.security.cert.CertificateFactory; import java.security.cert.X509Certificate; -import java.security.spec.KeySpec; -import java.security.spec.PKCS8EncodedKeySpec; -import java.security.spec.RSAPrivateCrtKeySpec; import java.util.ArrayList; -import java.util.Collections; import java.util.List; -import java.util.regex.Matcher; -import java.util.regex.Pattern; +import java.util.stream.Collectors; @Data @Slf4j @JsonIgnoreProperties(ignoreUnknown = true) public class CertPemCredentials implements ClientCredentials { - private static final String TLS_VERSION = "TLSv1.2"; + public static final String PRIVATE_KEY_ALIAS = "private-key"; + public static final String X_509 = "X.509"; + public static final String CERT_ALIAS_PREFIX = "cert-"; + public static final String CA_CERT_CERT_ALIAS_PREFIX = "caCert-cert-"; protected String caCert; private String cert; private String privateKey; private String password; - static final String OPENSSL_ENCRYPTED_RSA_PRIVATEKEY_REGEX = "\\s*" - + "-----BEGIN RSA PRIVATE KEY-----" + "\\s*" - + "Proc-Type: 4,ENCRYPTED" + "\\s*" - + "DEK-Info:" + "\\s*([^\\s]+)" + "\\s+" - + "([\\s\\S]*)" - + "-----END RSA PRIVATE KEY-----" + "\\s*"; - - static final Pattern OPENSSL_ENCRYPTED_RSA_PRIVATEKEY_PATTERN = Pattern.compile(OPENSSL_ENCRYPTED_RSA_PRIVATEKEY_REGEX); + public CertPemCredentials() { + if (Security.getProvider(BouncyCastleProvider.PROVIDER_NAME) == null) { + Security.addProvider(new BouncyCastleProvider()); + } + } @Override public CredentialsType getType() { @@ -91,7 +80,6 @@ public class CertPemCredentials implements ClientCredentials { @Override public SslContext initSslContext() { try { - Security.addProvider(new BouncyCastleProvider()); SslContextBuilder builder = SslContextBuilder.forClient(); if (StringUtils.hasLength(caCert)) { builder.trustManager(createAndInitTrustManagerFactory()); @@ -106,51 +94,13 @@ public class CertPemCredentials implements ClientCredentials { } } - private KeyManagerFactory createAndInitKeyManagerFactory() throws Exception { - List certHolders = readCertFile(cert); - Object keyObject = readPrivateKeyFile(privateKey); - char[] passwordCharArray = "".toCharArray(); - if (!StringUtils.isEmpty(password)) { - passwordCharArray = password.toCharArray(); - } - - JcaPEMKeyConverter keyConverter = new JcaPEMKeyConverter().setProvider("BC"); - - PrivateKey privateKey; - if (keyObject instanceof PEMEncryptedKeyPair) { - PEMDecryptorProvider provider = new JcePEMDecryptorProviderBuilder().build(passwordCharArray); - KeyPair key = keyConverter.getKeyPair(((PEMEncryptedKeyPair) keyObject).decryptKeyPair(provider)); - privateKey = key.getPrivate(); - } else if (keyObject instanceof PEMKeyPair) { - KeyPair key = keyConverter.getKeyPair((PEMKeyPair) keyObject); - privateKey = key.getPrivate(); - } else if (keyObject instanceof PrivateKey) { - privateKey = (PrivateKey) keyObject; - } else { - throw new RuntimeException("Unable to get private key from object: " + keyObject.getClass()); - } - - KeyStore clientKeyStore = KeyStore.getInstance(KeyStore.getDefaultType()); - clientKeyStore.load(null, null); - for (X509Certificate certHolder : certHolders) { - clientKeyStore.setCertificateEntry("cert-" + certHolder.getSubjectDN().getName(), certHolder); - } - clientKeyStore.setKeyEntry("private-key", - privateKey, - passwordCharArray, - certHolders.toArray(new Certificate[]{})); - KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm()); - keyManagerFactory.init(clientKeyStore, passwordCharArray); - return keyManagerFactory; - } - protected TrustManagerFactory createAndInitTrustManagerFactory() throws Exception { - List caCertHolders = readCertFile(caCert); + List caCerts = readCertFile(caCert); KeyStore caKeyStore = KeyStore.getInstance(KeyStore.getDefaultType()); caKeyStore.load(null, null); - for (X509Certificate caCertHolder : caCertHolders) { - caKeyStore.setCertificateEntry("caCert-cert-" + caCertHolder.getSubjectDN().getName(), caCertHolder); + for (X509Certificate caCert : caCerts) { + caKeyStore.setCertificateEntry(CA_CERT_CERT_ALIAS_PREFIX + caCert.getSubjectDN().getName(), caCert); } TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm()); @@ -158,170 +108,74 @@ public class CertPemCredentials implements ClientCredentials { return trustManagerFactory; } - List readCertFile(String fileContent) throws Exception { - if (fileContent == null || fileContent.trim().isEmpty()) { - return Collections.emptyList(); + protected KeyManagerFactory createAndInitKeyManagerFactory() throws Exception { + KeyManagerFactory kmf = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm()); + kmf.init(loadKeyStore(), password.toCharArray()); + return kmf; + } + + private KeyStore loadKeyStore() throws Exception { + List certificates = readCertFile(this.cert); + PrivateKey privateKey = readPrivateKey(this.privateKey, this.password); + + KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType()); + keyStore.load(null); + List unique = certificates.stream().distinct().collect(Collectors.toList()); + for (X509Certificate cert : unique) { + keyStore.setCertificateEntry(CERT_ALIAS_PREFIX + cert.getSubjectDN().getName(), cert); } + if (privateKey != null) { + CertificateFactory factory = CertificateFactory.getInstance(X_509); + CertPath certPath = factory.generateCertPath(certificates); + List path = certPath.getCertificates(); + Certificate[] x509Certificates = path.toArray(new Certificate[0]); + keyStore.setKeyEntry(PRIVATE_KEY_ALIAS, privateKey, password.toCharArray(), x509Certificates); + } + return keyStore; + } + + protected List readCertFile(String fileContent) throws IOException, GeneralSecurityException { List certificates = new ArrayList<>(); - String[] pems = fileContent.trim().split("-----END CERTIFICATE-----"); - for (String pem : pems) { - if (pem.trim().isEmpty()) { - continue; - } - pem = pem.replace("-----BEGIN CERTIFICATE-----", "") - .replace("-----END CERTIFICATE-----", "") - .replaceAll("\\s", ""); - byte[] decoded = Base64.decodeBase64(pem); - CertificateFactory certFactory = CertificateFactory.getInstance("X.509"); - try (InputStream inStream = new ByteArrayInputStream(decoded)) { - certificates.add((X509Certificate) certFactory.generateCertificate(inStream)); + JcaX509CertificateConverter certConverter = new JcaX509CertificateConverter(); + try (PEMParser pemParser = new PEMParser(new StringReader(fileContent))) { + Object object; + while ((object = pemParser.readObject()) != null) { + if (object instanceof X509CertificateHolder) { + X509Certificate x509Cert = certConverter.getCertificate((X509CertificateHolder) object); + certificates.add(x509Cert); + } } } return certificates; } - private PrivateKey readPrivateKeyFile(String fileContent) throws Exception { + protected PrivateKey readPrivateKey(String fileContent, String password) throws IOException, PKCSException { PrivateKey privateKey = null; - if (fileContent != null && !fileContent.isEmpty()) { - KeyFactory keyFactory = KeyFactory.getInstance("RSA"); - KeySpec keySpec = getKeySpec(fileContent); - privateKey = keyFactory.generatePrivate(keySpec); - } - return privateKey; - } - - private KeySpec getKeySpec(String encodedKey) throws Exception { - KeySpec keySpec = null; - Matcher matcher = OPENSSL_ENCRYPTED_RSA_PRIVATEKEY_PATTERN.matcher(encodedKey); - if (matcher.matches()) { - String encryptionDetails = matcher.group(1).trim(); - String encryptedKey = matcher.group(2).replaceAll("\\s", ""); - byte[] encryptedBinaryKey = java.util.Base64.getDecoder().decode(encryptedKey); - String[] encryptionDetailsParts = encryptionDetails.split(","); - if (encryptionDetailsParts.length == 2) { - String encryptionAlgorithm = encryptionDetailsParts[0]; - String encryptedAlgorithmParams = encryptionDetailsParts[1]; - byte[] pw = password.getBytes(); - byte[] iv = Hex.decode(encryptedAlgorithmParams); - - MessageDigest digest = MessageDigest.getInstance("MD5"); - digest.update(pw); - digest.update(iv, 0, 8); - - byte[] round1Digest = digest.digest(); - digest.update(round1Digest); - digest.update(pw); - digest.update(iv, 0, 8); - - byte[] round2Digest = digest.digest(); - Cipher cipher = null; - SecretKey secretKey = null; - byte[] key = null; - - switch(encryptionAlgorithm) { - case "AES-256-CBC": - cipher = Cipher.getInstance("AES/CBC/PKCS5Padding"); - key = new byte[32]; - System.arraycopy(round1Digest, 0, key, 0, 16); - System.arraycopy(round2Digest, 0, key, 16, 16); - secretKey = new SecretKeySpec(key, "AES"); - break; - case "AES-192-CBC": - cipher = Cipher.getInstance("AES/CBC/PKCS5Padding"); - key = new byte[24]; - System.arraycopy(round1Digest, 0, key, 0, 16); - System.arraycopy(round2Digest, 0, key, 16, 8); - secretKey = new SecretKeySpec(key, "AES"); + JcaPEMKeyConverter keyConverter = new JcaPEMKeyConverter(); + + if (StringUtils.isNotEmpty(fileContent)) { + try (PEMParser pemParser = new PEMParser(new StringReader(fileContent))) { + Object object; + while ((object = pemParser.readObject()) != null) { + if (object instanceof PEMEncryptedKeyPair) { + PEMDecryptorProvider decProv = new JcePEMDecryptorProviderBuilder().build(password.toCharArray()); + privateKey = keyConverter.getKeyPair(((PEMEncryptedKeyPair) object).decryptKeyPair(decProv)).getPrivate(); break; - case "AES-128-CBC": - cipher = Cipher.getInstance("AES/CBC/PKCS5Padding"); - key = new byte[16]; - System.arraycopy(round1Digest, 0, key, 0, 16); - secretKey = new SecretKeySpec(key, "AES"); + } else if (object instanceof PKCS8EncryptedPrivateKeyInfo) { + InputDecryptorProvider decProv = + new JcePKCSPBEInputDecryptorProviderBuilder().setProvider(new BouncyCastleProvider()).build(password.toCharArray()); + privateKey = keyConverter.getPrivateKey(((PKCS8EncryptedPrivateKeyInfo) object).decryptPrivateKeyInfo(decProv)); break; - case "DES-EDE3-CBC": - cipher = Cipher.getInstance("DESede/CBC/PKCS5Padding"); - key = new byte[24]; - System.arraycopy(round1Digest, 0, key, 0, 16); - System.arraycopy(round2Digest, 0, key, 16, 8); - secretKey = new SecretKeySpec(key, "DESede"); - break; - case "DES-CBC": - cipher = Cipher.getInstance("DES/CBC/PKCS5Padding"); - key = new byte[8]; - System.arraycopy(round1Digest, 0, key, 0, 8); - secretKey = new SecretKeySpec(key, "DES"); + } else if (object instanceof PEMKeyPair) { + privateKey = keyConverter.getKeyPair((PEMKeyPair) object).getPrivate(); break; + } else if (object instanceof PrivateKeyInfo) { + privateKey = keyConverter.getPrivateKey((PrivateKeyInfo) object); } - if (cipher != null) { - cipher.init(Cipher.DECRYPT_MODE, secretKey, new IvParameterSpec(iv)); - byte[] pkcs1 = cipher.doFinal(encryptedBinaryKey); - keySpec = decodeRSAPrivatePKCS1(pkcs1); - } else { - throw new RuntimeException("Unknown Encryption algorithm!"); } - } else { - throw new RuntimeException("Wrong encryption details!"); } - } else { - encodedKey = encodedKey.replaceAll(".*BEGIN.*PRIVATE KEY.*", "") - .replaceAll(".*END.*PRIVATE KEY.*", "") - .replaceAll("\\s", ""); - byte[] decoded = Base64.decodeBase64(encodedKey); - if (password == null || password.isEmpty()) { - keySpec = new PKCS8EncodedKeySpec(decoded); - } else { - PBEKeySpec pbeKeySpec = new PBEKeySpec(password.toCharArray()); - - EncryptedPrivateKeyInfo privateKeyInfo = new EncryptedPrivateKeyInfo(decoded); - String algorithmName = privateKeyInfo.getAlgName(); - Cipher cipher = Cipher.getInstance(algorithmName); - SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance(algorithmName); - - Key pbeKey = secretKeyFactory.generateSecret(pbeKeySpec); - AlgorithmParameters algParams = privateKeyInfo.getAlgParameters(); - cipher.init(Cipher.DECRYPT_MODE, pbeKey, algParams); - keySpec = privateKeyInfo.getKeySpec(cipher); - } - } - return keySpec; - } - - private static BigInteger derint(ByteBuffer input) { - int len = der(input, 0x02); - byte[] value = new byte[len]; - input.get(value); - return new BigInteger(+1, value); - } - - private static int der(ByteBuffer input, int exp) { - int tag = input.get() & 0xFF; - if (tag != exp) throw new IllegalArgumentException("Unexpected tag"); - int n = input.get() & 0xFF; - if (n < 128) return n; - n &= 0x7F; - if ((n < 1) || (n > 2)) throw new IllegalArgumentException("Invalid length"); - int len = 0; - while (n-- > 0) { - len <<= 8; - len |= input.get() & 0xFF; } - return len; - } - - static RSAPrivateCrtKeySpec decodeRSAPrivatePKCS1(byte[] encoded) { - ByteBuffer input = ByteBuffer.wrap(encoded); - if (der(input, 0x30) != input.remaining()) throw new IllegalArgumentException("Excess data"); - if (!BigInteger.ZERO.equals(derint(input))) throw new IllegalArgumentException("Unsupported version"); - BigInteger n = derint(input); - BigInteger e = derint(input); - BigInteger d = derint(input); - BigInteger p = derint(input); - BigInteger q = derint(input); - BigInteger ep = derint(input); - BigInteger eq = derint(input); - BigInteger c = derint(input); - return new RSAPrivateCrtKeySpec(n, e, d, p, q, ep, eq, c); + return privateKey; } } diff --git a/rule-engine/rule-engine-components/src/test/java/org/thingsboard/rule/engine/credentials/CertPemCredentialsTest.java b/rule-engine/rule-engine-components/src/test/java/org/thingsboard/rule/engine/credentials/CertPemCredentialsTest.java index 904f470001..fd7f0d3378 100644 --- a/rule-engine/rule-engine-components/src/test/java/org/thingsboard/rule/engine/credentials/CertPemCredentialsTest.java +++ b/rule-engine/rule-engine-components/src/test/java/org/thingsboard/rule/engine/credentials/CertPemCredentialsTest.java @@ -18,16 +18,27 @@ package org.thingsboard.rule.engine.credentials; import org.apache.commons.io.FileUtils; import org.junit.Assert; import org.junit.Test; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; import java.io.File; import java.io.IOException; +import java.security.PrivateKey; import java.security.cert.X509Certificate; import java.util.List; +import java.util.stream.Stream; public class CertPemCredentialsTest { private final CertPemCredentials credentials = new CertPemCredentials(); + private static final String PASS = "test"; + private static final String EMPTY_PASS = ""; + private static final String RSA = "RSA"; + private static final String ECDSA = "ECDSA"; + @Test public void testChainOfCertificates() throws Exception { String fileContent = fileContent("pem/tb-cloud-chain.pem"); @@ -65,6 +76,23 @@ public class CertPemCredentialsTest { Assert.assertEquals(0, x509Certificates.size()); } + private static Stream testReadPrivateKey() { + return Stream.of( + Arguments.of("pem/rsa_key.pem", EMPTY_PASS, RSA), + Arguments.of("pem/rsa_encrypted_key.pem", PASS, RSA), + Arguments.of("pem/rsa_encrypted_traditional_key.pem", PASS, RSA), + Arguments.of("pem/ec_key.pem", EMPTY_PASS, ECDSA) + ); + } + + @ParameterizedTest + @MethodSource + public void testReadPrivateKey(String keyPath, String password, String algorithm) throws Exception { + PrivateKey privateKey = credentials.readPrivateKey(fileContent(keyPath), password); + Assertions.assertNotNull(privateKey); + Assertions.assertEquals(algorithm, privateKey.getAlgorithm()); + } + private String fileContent(String fileName) throws IOException { ClassLoader classLoader = getClass().getClassLoader(); File file = new File(classLoader.getResource(fileName).getFile()); diff --git a/rule-engine/rule-engine-components/src/test/resources/pem/ec_key.pem b/rule-engine/rule-engine-components/src/test/resources/pem/ec_key.pem new file mode 100644 index 0000000000..74e0716259 --- /dev/null +++ b/rule-engine/rule-engine-components/src/test/resources/pem/ec_key.pem @@ -0,0 +1,8 @@ +-----BEGIN EC PARAMETERS----- +BggqhkjOPQMBBw== +-----END EC PARAMETERS----- +-----BEGIN EC PRIVATE KEY----- +MHcCAQEEIIEd0mMh0EEy3fMbOpbUY6kW0oAYcaYoTvoVpZxDr5qZoAoGCCqGSM49 +AwEHoUQDQgAEz4MgawieJfVc5zUOPiw5WFxfHGJf7dOMsHvudDxdOs27PXPbJfi0 +9BVJ3+JjNxA2wQz9KUk877oWRYrN/e+MbA== +-----END EC PRIVATE KEY----- \ No newline at end of file diff --git a/rule-engine/rule-engine-components/src/test/resources/pem/rsa_encrypted_key.pem b/rule-engine/rule-engine-components/src/test/resources/pem/rsa_encrypted_key.pem new file mode 100644 index 0000000000..045a44ce28 --- /dev/null +++ b/rule-engine/rule-engine-components/src/test/resources/pem/rsa_encrypted_key.pem @@ -0,0 +1,30 @@ +-----BEGIN ENCRYPTED PRIVATE KEY----- +MIIFLTBXBgkqhkiG9w0BBQ0wSjApBgkqhkiG9w0BBQwwHAQILTHGLs8mGUkCAggA +MAwGCCqGSIb3DQIJBQAwHQYJYIZIAWUDBAEqBBAUnb+mChJ9Wu9F7q6ingLYBIIE +0Mwe8Zl6fs5kiT1AL7gXrSSXmyOVvxDFt0V3TX1w399VIadcUUO0RQeEqXoMEUzl +5at99Xmoo7ByvZSPWCdV4d/j5Yw+Z15euxzclSZJnmBgvQx8cFPLCTTaqlgv5r/Y +lTzBrczbgruMFKtzkvHgvZYiagccOtFHDNC1fUBcUR8dkOOsgTiy4QCVo5kkXHt/ +rblE/uVWI8/E318WZBZaz68HcmGIG6ivdMEsKskSKrH6zA3eLjyGB+zSAIPRB/Mp +s7Rj+RK74zFSYyaq6fgdTG8lug2f3rHImSOtQThcfme5XL4P66rUgJsh/sml1vqH +e848VArGoVy3wfvkss6CyXIJevhFh2xVWRyVqG1nraw2QssEnVqIZvdAnaJJONX8 +r1trjHkZ1JD0nO9Mns1c/bw6hjK6W3UwGfgEMM9VQ7wNI2B6CFOXHKTHg6r3us4k +UqaQtfbpTv+d0YKF/rolDcK+mK/rkxP3rtJA7Ud8nQ4VjxyYX4jTs3/BzDkP7Tsj +5gKy9e1zuTF+MUWs3G5oKGQUKVcbgoYJ+iOqgVSd1JbecRo7Pl8XgDv3I9RWHzUr +EAMjVJjRU9tJuPvILFBkpl1/OPC9sGxJz9Hy9qLtEGhGLUhNz6XmIy/aWPCyA4ea +ZES/n7f+aYmXIxulcxS7MUejkwl1EtNqVyrKvLiRBXjBk2HPCb7Te8fRu/LpHZXN +D7wjymg1fGZPPFzdKh7wMdAKiK50KIMGXTxS6kHb6qW/755oSUjWRLPGcPCfdbjn +UiC5WC9FCog6jfRq1rMlz5b8yjyb+UbJ6N4qFSHeQf+7WLeS0Di8k3cLDSWl6T7M +z82ePof2V2TrADNpXvAcR78uiDfUpfa7DhkimvbBZpRVaaQVU7unxUPVc93WgCWV +a7kBuFJAGt+Wt1LPPD/5KOQ5pRINSoh4VhiZzmnY/m7RDPWEaL5gsMjF5bFoP2UZ +MuyAiTmvO299lJDrdQyQds7yafO9PrTE4msuqpuZSHW7ZZIdRO6EXlfZ1We3icWr ++jE47bUIEl04k1PvXyv9LeoqlHZJTagxZIerMOEwq976MaVR7RJbqUpRUV9FFNCL +gTouPCwUcVtLCaTYQjz/+12/YeVkiBHIWkI8Vv5Mn3Vkwy303ygGCQ+brht1e8x+ +BbgzSpiX8aHiEuDAKooewxnKrf3Dk9BcwbnftxajOZcZ3iphk07t5VLRy86zLKCq +ZOY+KymcDCGaOPnSHFrZK3lZOOT+BB9Vi6EYAkxZCZgoDsb/voMEdpPlxK7ultf6 +is5/JQeQbeP9wbNh4Ru2x3p5Ir4wffhh1KT3UsMobusosTo55ErhMHPvH5amppwq +IrxdM7heo7JMaNKmtol4y45IqSt58iluF5m2Ds4m85xjDteRgEOjtNBStFxPCMAB +KUEzRxEaplAcJfzYzpYtoHZuZ8W3Gi7yeXQ+BV8Q9DeaZc5DDDhIcIkOoHOAKhit +d7Gpr8hpwc60AgHRjua8OdbhM4ntT1xnyDEqZbP8mN+UBAohOHMrqo+f4DL1ibB9 +qSwfdLiVItsEBqlfANV3i9rEeKNH5tOFwFCmmH1yBCSDCtWPmPUJ5tZae6fIetK5 +uSstFXLaDpm6fcHgkeqrnyteWpnk5X5SQQ+fMHPjQ2vp +-----END ENCRYPTED PRIVATE KEY----- diff --git a/rule-engine/rule-engine-components/src/test/resources/pem/rsa_encrypted_traditional_key.pem b/rule-engine/rule-engine-components/src/test/resources/pem/rsa_encrypted_traditional_key.pem new file mode 100644 index 0000000000..0b0e128a25 --- /dev/null +++ b/rule-engine/rule-engine-components/src/test/resources/pem/rsa_encrypted_traditional_key.pem @@ -0,0 +1,30 @@ +-----BEGIN RSA PRIVATE KEY----- +Proc-Type: 4,ENCRYPTED +DEK-Info: DES-EDE3-CBC,FB5DE36A7A8B25DA + +skR15rUvZmdLzGqU5/BF4Yc3E6dxtXTvlOhuGnqH/idItMKUMWIIlQ7ZfWYF/CrC +CkeAUqhF4y+y+2eR4ejUzZKs6bYjTtkXAXAqQvCsTrTBdQSCcLwbHWLWMro0UG24 +e23Rx8kD0YC7VHqyr08NlLh94wR7kanhEeRUbmKBonZT/I9AZ5ntiBxq9QVBtc8M +f7LKIsnQDcd39cVXSo3LOJ/x7YVB//Ln1R1dexwxE0sXOyLq2hhrxzfHGuGXXW41 +/3+CeTgmX9Rzpawrq9vbVabPUgFcJlrogNRSnUAm9kz4b2zadCxEaCejVmhBy4wx +z2AJGcmE+D4VkQK1AAj5+AQQrPOIIFQnyGjwHkJSTGVTcKmttRYZBvUjdfQfj1fK +NsKOSZLzZGknM8Pz5MHgHqk70C7f+nm0uVhVuAiykA4PY4JdCAuTWJxMM2LWM3/q +rYCEMwxCGa6U92dakfC+W+d9pAbeN+xYOWkDrqG7BdAYg1P70cuMRPdd5bsq3YPp +G4n5NVyQvLlocGhZgC7NVzUtc18+rGblV4D657+GZwJnBZJN4TYey4+r2D5fv9rO +kcRVwfR704BbUBkjIzVzD7nXtBbr3ni8HSqde3g4aVL4WyV9XNvjUsYyrZ0u9Mt1 +IccAsa1xBquUNMxwO1H1mFLtzPKmFzKtlzqiiDsRQoRylwUa1k03sHKUflZRa8Sf +g4MpTRzK+vo1opMemlonty5YbvWXKlH68ioo49L8N457Y0hIUJOQgywg80NxT33t +x8y66lawd1Iv+Q7pptVxJtA4JmcdPvGwBLJZY4DacMyp/JqchAQfSQfmQ0tC+RfJ +z2By/s5wOEuVDksgp8RF1gn+VmvLyOoLK7tq+zpMO1mhfYTCMgSiz2GkNdiW6i25 +gjNWN/F62YL+9VJo4+olrcsYDFiiJq+deQk3H1tQJzu6qECfDqKDyw7IunvTwFil +5/d43LvLbRj75Kf/++xwTjfHudeTgw02/yPyELnURkUazvkOFsn7n8tU46Qm5TWh +fPFXSYxRf3m9rkKZB98YOJo595RuZyiYg9dEQX8Gybl1/7H7l4Cvw6yp71kgLrrI +JRYEt9pmWbQX97UFC3WTVMdKWakFziYVGPvFKkIzrHgcutbQVNsZ7GbO+rdWMIxr +SfUe6jCEclzGQjI9Ep4PTLjZvbusUMkoUjGasAluXFXDC4RKtpuXd4RmbOLdVuyN +OnZ5KZHFjrv4ch5PakRTViWFWSddV5CJ4fMkCG9qUHKrUWGjOvzu5rbcUzq3xJZG +9loIvlA4ekEAhQPHwx69uBmUwnCgyB9CosQGmUlwmC3KALA/EiXklTA6w0fGiiPk +uLA9oBGrVcD8Peug9Owfmj4fWbxJGP7x1UR/nZWpynIfzME0AD8MK5uqoWmQTG8I +cLSjVAB1CO//AZe4LpYQulMPq4dipmE+YnKLi0WPXuZVARDciAGGV2BfH6Iv8j9k +o9IoklcpGg22zXLoGn4tu+7Y5GcoV/mx68Gun1E/QFuY59damAqoc82EEsxr+UX0 +4vGX+KZn283xSYiilE3qpCZOER0ZUFInphUwJzzYfW3mW/AWR78tFQIQiuVKV2/a +-----END RSA PRIVATE KEY----- diff --git a/rule-engine/rule-engine-components/src/test/resources/pem/rsa_key.pem b/rule-engine/rule-engine-components/src/test/resources/pem/rsa_key.pem new file mode 100644 index 0000000000..8a92a68908 --- /dev/null +++ b/rule-engine/rule-engine-components/src/test/resources/pem/rsa_key.pem @@ -0,0 +1,52 @@ +-----BEGIN PRIVATE KEY----- +MIIJQgIBADANBgkqhkiG9w0BAQEFAASCCSwwggkoAgEAAoICAQCwefbtwf6lgUjR +4lh6vzDDb2D/GUqCv1pqtiWQgt5ecGE88cEJcb4V6B4ykdrwVQ8A0ipgmLAzXdqW +07qEws9rQnv6dCHAXk0JvHMB2L+RTyh+EjAkf4qA6wPcEp1HtRrsowNAWcZMVFH1 +nGy5hn/QAe7M8fDFItS+8xuJZu7k/YVgysTLIui5VWKFk+R4GFycjpIlHIJ0x0zL +bzadZD7juABQjdwVrt1fFRxe9FttOgw09MgNTLhWHEliEvhPoQPQOzu1lGwbvUtw +x/DZFBSCJLUW5iH47s3yVQy6QzLb+6ZCW4zT6oEJhZranVQJtXOWtbWqApCbVDwT +3VdJH0ov/N07yb3+414jWPIm7qLVyJtZHuCeHokKEvGi5CWsHO4vNLPs8byrUw5a +L6gdglZK+axyRtAOHASx+EWthWCd0l3GeaWTO9LU4/tEZJhct8wX5nELZgQmJTrl +AAIKXYgeSfI2IvwmDlqFeBkw2yHJ+86/lEHmOfPi/NGkaFRgJzIvM5FP7mBj1lht +f/nVw6iZBXWvJNNCz7MDyZ8RUuNtsuq9h0jzgsLdyEx1w6bxn1TXF1vYVf9zvbhc +PI+dA3LU8uCDOq84VnMt57LScFVRbJWtwLJ1tLk8C9WgC5w7ySo/pvu4HtCcN4Zo +KIBUX71BpfGPJAR0sS7fPkkwzu4fhQIDAQABAoICABm8z+yA/Hh60Hn7vte4Bo6a +MdVChQFokvE5O2VGENRJI4VV5MdR1V0wiybo6rteTF/cRt3rptb2+yhAHNW767BC +8/3k7f82QZoH5+X/DIFOwCMS1/6as0J2BAwWkuWgXhrg81pxPWBoc8OUWq78FKvr +fD5bkrfNiqWGox946aJv7wHc0LKnlrVg5IuCtDFnrCoRCPNsowIRBvwsbhSqSBnB +/hnBdrWa2SJC2+5lSOg3LQyUHpEB/Whhm7o39gr2+q1l1iF3UgUBqHz8S/381bjd +TaPXUGETwulyyfZoUoSOwQKwg2tsqgEPgTQc+eKomgEC40m2MgzVTiW/hDlf3NvA +aEaUUU1izN/t8tuXS/UBWSsVwPeVm2oPTWTVovoj9PFMSLrJ4oM9iMHl27lKP/Xt +aShnCIu0qwVSLqwCM0HxZNZLEvJIFJe3OV7dvFlbnMiEOlDsz4k2sylFdICOOqxC +Nb61hX8n6iYmAID9hahExOAFcJfpV/MrGnF1IfNDdOim5az1k0PUZlA+50NLjOzK +umfAQpsa7ZUpjfNq6HkX5mhJXelvv+pWuvbBogG10nio13I4J/YwydC/0qaijrhp +XTuV3Or2HhGr5Fe9lpzrnWB90q7iqAgGzevds8AagE0EdUIFupx6vr28Gb3mmlvD +yObUj/9cB+eYIae1jmzJAoIBAQC9pN8I0ltyR5IuuPBcEZcqdrRV04iwZylxEcYy +TIj1YBYvU6LP8AOg671Q4vGXOCo1uq/UsCzZMPn5yFa5fMg2AHu2B51nM/NILvD0 +QCgpyvNV64q+Mci9VWoctWZs93QiQyUKe1c/vUMYlWsYXbz/8osChX+r5doxBIQx +w60aXr9FLKfVfYfBfn1nakdjOVVvAFDPyoV6Dmfn/cAfPH50NIeOGYRpVTPHwHYr +ZCcIRW9MIzmS00GogAH1BM8JjRr0F9F+rRESeJKdLSqJbgLy2LtJnvU8YjlRUVWO +FLzqaUyT2PJS9Vqbohrlk52Znq5Gl+SbGhSEx+oTH3JM/n0jAoIBAQDuOZ8bqtRY +p4BuBOPOaiHRIor+ng48m+nhXec4TuKUlwKLFJHXu+lsEZfs7BWijbRqMH4I5GZl +10EmE4mpkp843kqbFi71s7l9xWnM7jgXWSauH0O4Cleq8/9l2ZOissYzakLhNz3C +9IT0JcnHFmPOPlH4McjoKM3zWDniKI2fRn9q4DAEvRxDuB6PYxbz2NY2OAVI6xSA +bNevnyYA0bwvWeigr6dNCAs1z9QwX2oDGfIEUk3ixdGIqIkpL3WcVPXva2hRPAm4 +1gaI39+q86rEPiZJWfpasUEBY2Ho1eyENqaPTGHCTfBq5fMVntOVhs79TbQ+s70c +1Wyfo6sjHh83AoIBAQCuqdLhhRzEPDbe4WY+5dScP4gIJDOYhOseQIiSevsJQ94q +6JTjfuNYqsZKYTqxVAFMSwz2juw/fWQ+Mc3uOIcNdZR7KrhF/QrsSI+T5iMXmtxT +HgVC9wczmh+JIWmcoqxLghvzc3YANog9dCCW6H7SHMj7IYldAO3ch5RZYSdlSi5P +v7k0X9FQ3PcS8Eefk4akHV5Qgu48ZFg+yu7P1h+BV4Ah2E6j1N1D9Hbhr/RjIdBI +B4lXOUsXrg4fZLZqzZMtjWJdkXhP0sz2BktPGAuPLx4PyF+FpdG0m3x4x5DXNPRa +l01YKrGw9bRgDXzxp7xLOEpMr9CGGrnzstrLHviRAoIBAFoyuwmQvuHqWfhOJasM +CE3VFGeflKhiKEXKdjedtrCoFLBwU2ApqBHg/3MXWIG5wavLPI1FXXgF7obqMt9f +wqWXlQvvdExXhk4Wpx6Ou/IrMTgQYmWWlOcHh5YasYmSwvTIsRXxApOEXarLfADD +e3qlogelYfp1KLWQnCoDTMwXtzrSM5w3tjH1zqxfylr9qO3SfD3FtHeDvo6iZZM9 +1lDfa/MbTu8dspDnZeIC3nLaKgZ020SXveROW9CaRZ+xk4TZWCAZ6VxwvPyqN1fU +9r1jAsAXL3GTV5ec939fMDRHNP1g4Erfk74F3uo6vsYIyuqhtzNefqYiMQSoxa2A +RDUCggEAFlN3ih1gpyvErW4Vy/wUd1ckSH/lojlNjbbyXocKE2eiUnJUwTPerVwX +dI8vqvlPohfDIZqfuBVV+8hiJQGeMiAts6roTQ0pu/w1+euQ4DsOpzUErqadVSOj +h8SpvfxDxrftZSMaN6F7g0Pxlix6qt79XH3Kpfzf9BGOfCG7lslXRAjfuk+HUptK +PijoVHwMwFuZVlN8GBh3uzg+wvME92c4Vr1tHpwqjTqDwZN4RmdnrfGdDb1HJUJW +kv+fD65qKnJz1fZ0RTAcWv4bVFi5GJhZarXD3Vr3C5SH8zNZxDeR29OrSuG7+23g +wOqb/axEbvcj5sV6/4p2zz6AzFPEmQ== +-----END PRIVATE KEY----- From 71dd96b08447b707015ff3cab5ae445a8b973be6 Mon Sep 17 00:00:00 2001 From: Andrii Shvaika Date: Tue, 17 Oct 2023 18:00:04 +0300 Subject: [PATCH 04/43] Fix the widgets_bundle_widget table after upgrade --- application/src/main/data/upgrade/3.5.1/schema_update.sql | 2 +- application/src/main/data/upgrade/3.6.0/schema_update.sql | 7 +++++++ 2 files changed, 8 insertions(+), 1 deletion(-) diff --git a/application/src/main/data/upgrade/3.5.1/schema_update.sql b/application/src/main/data/upgrade/3.5.1/schema_update.sql index f41e370ab5..fab91a4e67 100644 --- a/application/src/main/data/upgrade/3.5.1/schema_update.sql +++ b/application/src/main/data/upgrade/3.5.1/schema_update.sql @@ -189,7 +189,7 @@ DO $$ BEGIN IF EXISTS(SELECT 1 FROM information_schema.columns WHERE table_name = 'widget_type' and column_name='bundle_alias') THEN - INSERT INTO widgets_bundle_widget SELECT wb.id as widgets_bundle_id, wt.id as widget_type_id from widget_type wt left join widgets_bundle wb ON wt.bundle_alias = wb.alias ON CONFLICT (widgets_bundle_id, widget_type_id) DO NOTHING; + INSERT INTO widgets_bundle_widget SELECT wb.id as widgets_bundle_id, wt.id as widget_type_id from widget_type wt left join widgets_bundle wb ON wt.bundle_alias = wb.alias AND wt.tenant_id = wb.tenant_id ON CONFLICT (widgets_bundle_id, widget_type_id) DO NOTHING; ALTER TABLE widget_type DROP COLUMN IF EXISTS bundle_alias; END IF; END; diff --git a/application/src/main/data/upgrade/3.6.0/schema_update.sql b/application/src/main/data/upgrade/3.6.0/schema_update.sql index 0ad2d97b7a..ee1b311de2 100644 --- a/application/src/main/data/upgrade/3.6.0/schema_update.sql +++ b/application/src/main/data/upgrade/3.6.0/schema_update.sql @@ -24,3 +24,10 @@ ALTER TABLE notification DROP CONSTRAINT IF EXISTS fk_notification_request_id; ALTER TABLE notification DROP CONSTRAINT IF EXISTS fk_notification_recipient_id; CREATE INDEX IF NOT EXISTS idx_notification_notification_request_id ON notification(request_id); CREATE INDEX IF NOT EXISTS idx_notification_request_tenant_id ON notification_request(tenant_id); + +-- DELETE invalid records from M:N widgets_bundle_widget table caused by the bug in previous upgrade script; +DELETE +FROM widgets_bundle_widget wbw +WHERE (SELECT tenant_id FROM widgets_bundle wb WHERE wb.id = wbw.widgets_bundle_id) != + (SELECT tenant_id FROM widget_type WHERE id = wbw.widget_type_id); + From 3946b058cdda60fbdfb03d92d0c60fb3d1399605 Mon Sep 17 00:00:00 2001 From: Volodymyr Babak Date: Tue, 17 Oct 2023 18:09:38 +0300 Subject: [PATCH 05/43] Do not push ALARM update to edge automatically - only using push to edge rule node --- .../service/edge/EdgeEventSourcingListener.java | 10 +++++----- .../thingsboard/server/edge/AlarmEdgeTest.java | 15 --------------- ui-ngx/src/app/core/http/entity.service.ts | 10 +++++++--- 3 files changed, 12 insertions(+), 23 deletions(-) diff --git a/application/src/main/java/org/thingsboard/server/service/edge/EdgeEventSourcingListener.java b/application/src/main/java/org/thingsboard/server/service/edge/EdgeEventSourcingListener.java index 707dbec964..006af577c9 100644 --- a/application/src/main/java/org/thingsboard/server/service/edge/EdgeEventSourcingListener.java +++ b/application/src/main/java/org/thingsboard/server/service/edge/EdgeEventSourcingListener.java @@ -25,6 +25,7 @@ import org.thingsboard.common.util.JacksonUtil; import org.thingsboard.server.cluster.TbClusterService; import org.thingsboard.server.common.data.OtaPackageInfo; import org.thingsboard.server.common.data.User; +import org.thingsboard.server.common.data.alarm.Alarm; import org.thingsboard.server.common.data.alarm.AlarmApiCallResult; import org.thingsboard.server.common.data.edge.EdgeEventActionType; import org.thingsboard.server.common.data.edge.EdgeEventType; @@ -78,7 +79,7 @@ public class EdgeEventSourcingListener { return; } try { - if (!isValidEdgeEventEntity(event.getEntity(), event.getOldEntity())) { + if (!isValidSaveEntityEventForEdgeProcessing(event.getEntity(), event.getOldEntity())) { return; } log.trace("[{}] SaveEntityEvent called: {}", event.getTenantId(), event); @@ -141,7 +142,7 @@ public class EdgeEventSourcingListener { } } - private boolean isValidEdgeEventEntity(Object entity, Object oldEntity) { + private boolean isValidSaveEntityEventForEdgeProcessing(Object entity, Object oldEntity) { if (entity instanceof OtaPackageInfo) { OtaPackageInfo otaPackageInfo = (OtaPackageInfo) entity; return otaPackageInfo.hasUrl() || otaPackageInfo.isHasData(); @@ -159,9 +160,8 @@ public class EdgeEventSourcingListener { cleanUpUserAdditionalInfo(user); return !user.equals(oldUser); } - } else if (entity instanceof AlarmApiCallResult) { - AlarmApiCallResult alarmApiCallResult = (AlarmApiCallResult) entity; - return alarmApiCallResult.isModified(); + } else if (entity instanceof AlarmApiCallResult || entity instanceof Alarm) { + return false; } // Default: If the entity doesn't match any of the conditions, consider it as valid. return true; diff --git a/application/src/test/java/org/thingsboard/server/edge/AlarmEdgeTest.java b/application/src/test/java/org/thingsboard/server/edge/AlarmEdgeTest.java index afccc634ed..259572851c 100644 --- a/application/src/test/java/org/thingsboard/server/edge/AlarmEdgeTest.java +++ b/application/src/test/java/org/thingsboard/server/edge/AlarmEdgeTest.java @@ -19,7 +19,6 @@ import com.fasterxml.jackson.core.type.TypeReference; import com.google.protobuf.AbstractMessage; import org.junit.Assert; import org.junit.Test; -import org.thingsboard.common.util.JacksonUtil; import org.thingsboard.server.common.data.Device; import org.thingsboard.server.common.data.EntityType; import org.thingsboard.server.common.data.alarm.Alarm; @@ -102,20 +101,6 @@ public class AlarmEdgeTest extends AbstractEdgeTest { Assert.assertEquals(savedAlarm.getStatus().name(), alarmUpdateMsg.getStatus()); Assert.assertEquals(savedAlarm.getSeverity().name(), alarmUpdateMsg.getSeverity()); - // update alarm - String updatedDetails = "{\"testKey\":\"testValue\"}"; - savedAlarm.setDetails(JacksonUtil.OBJECT_MAPPER.readTree(updatedDetails)); - edgeImitator.expectMessageAmount(1); - savedAlarm = doPost("/api/alarm", savedAlarm, Alarm.class); - Assert.assertTrue(edgeImitator.waitForMessages()); - latestMessage = edgeImitator.getLatestMessage(); - Assert.assertTrue(latestMessage instanceof AlarmUpdateMsg); - alarmUpdateMsg = (AlarmUpdateMsg) latestMessage; - Assert.assertEquals(UpdateMsgType.ENTITY_UPDATED_RPC_MESSAGE, alarmUpdateMsg.getMsgType()); - Assert.assertEquals(savedAlarm.getUuidId().getMostSignificantBits(), alarmUpdateMsg.getIdMSB()); - Assert.assertEquals(savedAlarm.getUuidId().getLeastSignificantBits(), alarmUpdateMsg.getIdLSB()); - Assert.assertEquals(updatedDetails, alarmUpdateMsg.getDetails()); - // ack alarm edgeImitator.expectMessageAmount(1); doPost("/api/alarm/" + savedAlarm.getUuidId() + "/ack"); diff --git a/ui-ngx/src/app/core/http/entity.service.ts b/ui-ngx/src/app/core/http/entity.service.ts index 12f6300b93..cc1dd13345 100644 --- a/ui-ngx/src/app/core/http/entity.service.ts +++ b/ui-ngx/src/app/core/http/entity.service.ts @@ -92,6 +92,7 @@ import { NotificationService } from '@core/http/notification.service'; import { TenantProfileService } from '@core/http/tenant-profile.service'; import { NotificationType } from '@shared/models/notification.models'; import { UserId } from '@shared/models/id/user-id'; +import { AlarmService } from '@core/http/alarm.service'; @Injectable({ providedIn: 'root' @@ -119,7 +120,8 @@ export class EntityService { private assetProfileService: AssetProfileService, private utils: UtilsService, private queueService: QueueService, - private notificationService: NotificationService + private notificationService: NotificationService, + private alarmService: AlarmService ) { } private getEntityObservable(entityType: EntityType, entityId: string, @@ -155,7 +157,7 @@ export class EntityService { observable = this.ruleChainService.getRuleChain(entityId, config); break; case EntityType.ALARM: - console.error('Get Alarm Entity is not implemented!'); + observable = this.alarmService.getAlarm(entityId, config); break; case EntityType.OTA_PACKAGE: observable = this.otaPackageService.getOtaPackageInfo(entityId, config); @@ -238,7 +240,9 @@ export class EntityService { entityIds); break; case EntityType.ALARM: - console.error('Get Alarm Entity is not implemented!'); + observable = this.getEntitiesByIdsObservable( + (id) => this.alarmService.getAlarm(id, config), + entityIds); break; case EntityType.DEVICE_PROFILE: observable = this.getEntitiesByIdsObservable( From 7ccad683abae4fb6cbe2454e397369b5573006ed Mon Sep 17 00:00:00 2001 From: Andrii Shvaika Date: Tue, 17 Oct 2023 18:41:22 +0300 Subject: [PATCH 06/43] prettify script --- application/src/main/data/upgrade/3.6.0/schema_update.sql | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/application/src/main/data/upgrade/3.6.0/schema_update.sql b/application/src/main/data/upgrade/3.6.0/schema_update.sql index ee1b311de2..0361a5db65 100644 --- a/application/src/main/data/upgrade/3.6.0/schema_update.sql +++ b/application/src/main/data/upgrade/3.6.0/schema_update.sql @@ -29,5 +29,5 @@ CREATE INDEX IF NOT EXISTS idx_notification_request_tenant_id ON notification_re DELETE FROM widgets_bundle_widget wbw WHERE (SELECT tenant_id FROM widgets_bundle wb WHERE wb.id = wbw.widgets_bundle_id) != - (SELECT tenant_id FROM widget_type WHERE id = wbw.widget_type_id); + (SELECT tenant_id FROM widget_type wt WHERE wt.id = wbw.widget_type_id); From 04cfa2021dcc989d6130a43334a435dfaeb2f0d9 Mon Sep 17 00:00:00 2001 From: Volodymyr Babak Date: Tue, 17 Oct 2023 18:50:42 +0300 Subject: [PATCH 07/43] Fixed edge controller tests --- .../edge/rpc/processor/BaseEdgeProcessor.java | 3 ++- .../server/controller/EdgeControllerTest.java | 11 +++++++++-- .../server/controller/EdgeEventControllerTest.java | 13 ++++++++++--- 3 files changed, 21 insertions(+), 6 deletions(-) diff --git a/application/src/main/java/org/thingsboard/server/service/edge/rpc/processor/BaseEdgeProcessor.java b/application/src/main/java/org/thingsboard/server/service/edge/rpc/processor/BaseEdgeProcessor.java index 2d86c1e184..a888ddc27b 100644 --- a/application/src/main/java/org/thingsboard/server/service/edge/rpc/processor/BaseEdgeProcessor.java +++ b/application/src/main/java/org/thingsboard/server/service/edge/rpc/processor/BaseEdgeProcessor.java @@ -309,7 +309,8 @@ public abstract class BaseEdgeProcessor { EdgeEventActionType action, EntityId entityId, JsonNode body) { - ListenableFuture> future = attributesService.find(tenantId, edgeId, DataConstants.SERVER_SCOPE, DefaultDeviceStateService.ACTIVITY_STATE); + ListenableFuture> future = + attributesService.find(tenantId, edgeId, DataConstants.SERVER_SCOPE, DefaultDeviceStateService.ACTIVITY_STATE); return Futures.transformAsync(future, activeOpt -> { if (activeOpt.isEmpty()) { log.trace("Edge is not activated. Skipping event. tenantId [{}], edgeId [{}], type[{}], " + diff --git a/application/src/test/java/org/thingsboard/server/controller/EdgeControllerTest.java b/application/src/test/java/org/thingsboard/server/controller/EdgeControllerTest.java index 1afeaff0cb..b9e0b8cd6c 100644 --- a/application/src/test/java/org/thingsboard/server/controller/EdgeControllerTest.java +++ b/application/src/test/java/org/thingsboard/server/controller/EdgeControllerTest.java @@ -17,6 +17,7 @@ package org.thingsboard.server.controller; import com.datastax.oss.driver.api.core.uuid.Uuids; import com.fasterxml.jackson.core.type.TypeReference; +import com.fasterxml.jackson.databind.node.ObjectNode; import com.google.common.util.concurrent.Futures; import com.google.common.util.concurrent.ListenableFuture; import com.google.common.util.concurrent.ListeningExecutorService; @@ -34,8 +35,10 @@ import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Primary; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.TestPropertySource; +import org.thingsboard.common.util.JacksonUtil; import org.thingsboard.common.util.ThingsBoardExecutors; import org.thingsboard.server.common.data.Customer; +import org.thingsboard.server.common.data.DataConstants; import org.thingsboard.server.common.data.Device; import org.thingsboard.server.common.data.EntitySubtype; import org.thingsboard.server.common.data.StringUtils; @@ -852,6 +855,11 @@ public class EdgeControllerTest extends AbstractControllerTest { Edge edge = doPost("/api/edge", constructEdge("Test Sync Edge", "test"), Edge.class); + // simulate edge activation + ObjectNode attributes = JacksonUtil.newObjectNode(); + attributes.put("active", true); + doPost("/api/plugins/telemetry/EDGE/" + edge.getId() + "/attributes/" + DataConstants.SERVER_SCOPE, attributes); + doPost("/api/edge/" + edge.getId().getId().toString() + "/device/" + savedDevice.getId().getId().toString(), Device.class); doPost("/api/edge/" + edge.getId().getId().toString() @@ -860,13 +868,12 @@ public class EdgeControllerTest extends AbstractControllerTest { EdgeImitator edgeImitator = new EdgeImitator(EDGE_HOST, EDGE_PORT, edge.getRoutingKey(), edge.getSecret()); edgeImitator.ignoreType(UserCredentialsUpdateMsg.class); - edgeImitator.expectMessageAmount(25); + edgeImitator.expectMessageAmount(24); edgeImitator.connect(); assertThat(edgeImitator.waitForMessages()).as("await for messages on first connect").isTrue(); verifyFetchersMsgs(edgeImitator); // verify queue msgs - Assert.assertTrue(popRuleChainMsg(edgeImitator.getDownlinkMsgs(), UpdateMsgType.ENTITY_UPDATED_RPC_MESSAGE, "Edge Root Rule Chain")); Assert.assertTrue(popDeviceProfileMsg(edgeImitator.getDownlinkMsgs(), UpdateMsgType.ENTITY_CREATED_RPC_MESSAGE, "default")); Assert.assertTrue(popDeviceMsg(edgeImitator.getDownlinkMsgs(), UpdateMsgType.ENTITY_CREATED_RPC_MESSAGE, "Test Sync Edge Device 1")); Assert.assertTrue(popAssetProfileMsg(edgeImitator.getDownlinkMsgs(), UpdateMsgType.ENTITY_CREATED_RPC_MESSAGE, "test")); diff --git a/application/src/test/java/org/thingsboard/server/controller/EdgeEventControllerTest.java b/application/src/test/java/org/thingsboard/server/controller/EdgeEventControllerTest.java index 04842df6a0..3303c64c27 100644 --- a/application/src/test/java/org/thingsboard/server/controller/EdgeEventControllerTest.java +++ b/application/src/test/java/org/thingsboard/server/controller/EdgeEventControllerTest.java @@ -16,6 +16,7 @@ package org.thingsboard.server.controller; import com.fasterxml.jackson.core.type.TypeReference; +import com.fasterxml.jackson.databind.node.ObjectNode; import lombok.extern.slf4j.Slf4j; import org.awaitility.Awaitility; import org.junit.After; @@ -26,6 +27,8 @@ import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Value; import org.springframework.boot.test.mock.mockito.SpyBean; import org.springframework.test.context.TestPropertySource; +import org.thingsboard.common.util.JacksonUtil; +import org.thingsboard.server.common.data.DataConstants; import org.thingsboard.server.common.data.Device; import org.thingsboard.server.common.data.asset.Asset; import org.thingsboard.server.common.data.edge.Edge; @@ -86,6 +89,11 @@ public class EdgeEventControllerTest extends AbstractControllerTest { Edge edge = constructEdge("TestEdge", "default"); edge = doPost("/api/edge", edge, Edge.class); + // simulate edge activation + ObjectNode attributes = JacksonUtil.newObjectNode(); + attributes.put("active", true); + doPost("/api/plugins/telemetry/EDGE/" + edge.getId() + "/attributes/" + DataConstants.SERVER_SCOPE, attributes); + Device device = constructDevice("TestDevice", "default"); Device savedDevice = doPost("/api/device", device, Device.class); @@ -99,14 +107,13 @@ public class EdgeEventControllerTest extends AbstractControllerTest { EntityRelation relation = new EntityRelation(savedAsset.getId(), savedDevice.getId(), EntityRelation.CONTAINS_TYPE); - awaitForNumberOfEdgeEvents(edgeId, 3); + awaitForNumberOfEdgeEvents(edgeId, 2); doPost("/api/relation", relation); - awaitForNumberOfEdgeEvents(edgeId, 4); + awaitForNumberOfEdgeEvents(edgeId, 3); List edgeEvents = findEdgeEvents(edgeId); - Assert.assertTrue(popEdgeEvent(edgeEvents, EdgeEventType.RULE_CHAIN)); // root rule chain Assert.assertTrue(popEdgeEvent(edgeEvents, EdgeEventType.DEVICE)); // TestDevice Assert.assertTrue(popEdgeEvent(edgeEvents, EdgeEventType.ASSET)); // TestAsset Assert.assertTrue(popEdgeEvent(edgeEvents, EdgeEventType.RELATION)); From cf32544e71f7dd3bd43059fd2b4328c1a3747dc2 Mon Sep 17 00:00:00 2001 From: YevhenBondarenko Date: Tue, 17 Oct 2023 23:20:00 +0200 Subject: [PATCH 08/43] added SslUtil and tests --- common/util/pom.xml | 8 ++ .../org/thingsboard/common/util/SslUtil.java | 105 ++++++++++++++++++ .../credentials/CertPemCredentials.java | 82 ++------------ .../credentials/CertPemCredentialsTest.java | 51 ++++++--- .../src/test/resources/pem/ec_cert.pem | 13 +++ .../src/test/resources/pem/rsa_cert.pem | 32 ++++++ .../test/resources/pem/rsa_encrypted_cert.pem | 22 ++++ .../pem/rsa_encrypted_traditional_cert.pem | 22 ++++ 8 files changed, 245 insertions(+), 90 deletions(-) create mode 100644 common/util/src/main/java/org/thingsboard/common/util/SslUtil.java create mode 100644 rule-engine/rule-engine-components/src/test/resources/pem/ec_cert.pem create mode 100644 rule-engine/rule-engine-components/src/test/resources/pem/rsa_cert.pem create mode 100644 rule-engine/rule-engine-components/src/test/resources/pem/rsa_encrypted_cert.pem create mode 100644 rule-engine/rule-engine-components/src/test/resources/pem/rsa_encrypted_traditional_cert.pem diff --git a/common/util/pom.xml b/common/util/pom.xml index 14ae1748b2..bce6a6fc80 100644 --- a/common/util/pom.xml +++ b/common/util/pom.xml @@ -36,6 +36,14 @@ + + org.bouncycastle + bcprov-jdk15on + + + org.bouncycastle + bcpkix-jdk15on + org.springframework spring-core diff --git a/common/util/src/main/java/org/thingsboard/common/util/SslUtil.java b/common/util/src/main/java/org/thingsboard/common/util/SslUtil.java new file mode 100644 index 0000000000..889436671a --- /dev/null +++ b/common/util/src/main/java/org/thingsboard/common/util/SslUtil.java @@ -0,0 +1,105 @@ +/** + * Copyright © 2016-2023 The Thingsboard Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.thingsboard.common.util; + +import lombok.SneakyThrows; +import lombok.extern.slf4j.Slf4j; +import org.bouncycastle.asn1.pkcs.PrivateKeyInfo; +import org.bouncycastle.cert.X509CertificateHolder; +import org.bouncycastle.cert.jcajce.JcaX509CertificateConverter; +import org.bouncycastle.jce.provider.BouncyCastleProvider; +import org.bouncycastle.openssl.PEMDecryptorProvider; +import org.bouncycastle.openssl.PEMEncryptedKeyPair; +import org.bouncycastle.openssl.PEMKeyPair; +import org.bouncycastle.openssl.PEMParser; +import org.bouncycastle.openssl.jcajce.JcaPEMKeyConverter; +import org.bouncycastle.openssl.jcajce.JcePEMDecryptorProviderBuilder; +import org.bouncycastle.operator.InputDecryptorProvider; +import org.bouncycastle.pkcs.PKCS8EncryptedPrivateKeyInfo; +import org.bouncycastle.pkcs.jcajce.JcePKCSPBEInputDecryptorProviderBuilder; +import org.thingsboard.server.common.data.StringUtils; + +import java.io.StringReader; +import java.security.PrivateKey; +import java.security.Security; +import java.security.cert.X509Certificate; +import java.util.ArrayList; +import java.util.List; + +@Slf4j +public class SslUtil { + + public static final char[] EMPTY_PASS = {}; + + public static final BouncyCastleProvider DEFAULT_PROVIDER = new BouncyCastleProvider(); + + static { + if (Security.getProvider(BouncyCastleProvider.PROVIDER_NAME) == null) { + Security.addProvider(DEFAULT_PROVIDER); + } + } + + private SslUtil() { + } + + @SneakyThrows + public static List readCertFile(String fileContent) { + List certificates = new ArrayList<>(); + JcaX509CertificateConverter certConverter = new JcaX509CertificateConverter(); + try (PEMParser pemParser = new PEMParser(new StringReader(fileContent))) { + Object object; + while ((object = pemParser.readObject()) != null) { + if (object instanceof X509CertificateHolder) { + X509Certificate x509Cert = certConverter.getCertificate((X509CertificateHolder) object); + certificates.add(x509Cert); + } + } + } + return certificates; + } + + @SneakyThrows + public static PrivateKey readPrivateKey(String fileContent, String passStr) { + char[] password = StringUtils.isEmpty(passStr) ? EMPTY_PASS : passStr.toCharArray(); + + PrivateKey privateKey = null; + JcaPEMKeyConverter keyConverter = new JcaPEMKeyConverter(); + if (StringUtils.isNotEmpty(fileContent)) { + try (PEMParser pemParser = new PEMParser(new StringReader(fileContent))) { + Object object; + while ((object = pemParser.readObject()) != null) { + if (object instanceof PEMEncryptedKeyPair) { + PEMDecryptorProvider decProv = new JcePEMDecryptorProviderBuilder().build(password); + privateKey = keyConverter.getKeyPair(((PEMEncryptedKeyPair) object).decryptKeyPair(decProv)).getPrivate(); + break; + } else if (object instanceof PKCS8EncryptedPrivateKeyInfo) { + InputDecryptorProvider decProv = + new JcePKCSPBEInputDecryptorProviderBuilder().setProvider(DEFAULT_PROVIDER).build(password); + privateKey = keyConverter.getPrivateKey(((PKCS8EncryptedPrivateKeyInfo) object).decryptPrivateKeyInfo(decProv)); + break; + } else if (object instanceof PEMKeyPair) { + privateKey = keyConverter.getKeyPair((PEMKeyPair) object).getPrivate(); + break; + } else if (object instanceof PrivateKeyInfo) { + privateKey = keyConverter.getPrivateKey((PrivateKeyInfo) object); + } + } + } + } + return privateKey; + } + +} diff --git a/rule-engine/rule-engine-components/src/main/java/org/thingsboard/rule/engine/credentials/CertPemCredentials.java b/rule-engine/rule-engine-components/src/main/java/org/thingsboard/rule/engine/credentials/CertPemCredentials.java index c17f71bc33..3824e71459 100644 --- a/rule-engine/rule-engine-components/src/main/java/org/thingsboard/rule/engine/credentials/CertPemCredentials.java +++ b/rule-engine/rule-engine-components/src/main/java/org/thingsboard/rule/engine/credentials/CertPemCredentials.java @@ -20,35 +20,17 @@ import io.netty.handler.ssl.SslContext; import io.netty.handler.ssl.SslContextBuilder; import lombok.Data; import lombok.extern.slf4j.Slf4j; -import org.bouncycastle.asn1.pkcs.PrivateKeyInfo; -import org.bouncycastle.cert.X509CertificateHolder; -import org.bouncycastle.cert.jcajce.JcaX509CertificateConverter; -import org.bouncycastle.jce.provider.BouncyCastleProvider; -import org.bouncycastle.openssl.PEMDecryptorProvider; -import org.bouncycastle.openssl.PEMEncryptedKeyPair; -import org.bouncycastle.openssl.PEMKeyPair; -import org.bouncycastle.openssl.PEMParser; -import org.bouncycastle.openssl.jcajce.JcaPEMKeyConverter; -import org.bouncycastle.openssl.jcajce.JcePEMDecryptorProviderBuilder; -import org.bouncycastle.operator.InputDecryptorProvider; -import org.bouncycastle.pkcs.PKCS8EncryptedPrivateKeyInfo; -import org.bouncycastle.pkcs.PKCSException; -import org.bouncycastle.pkcs.jcajce.JcePKCSPBEInputDecryptorProviderBuilder; +import org.thingsboard.common.util.SslUtil; import org.thingsboard.server.common.data.StringUtils; import javax.net.ssl.KeyManagerFactory; import javax.net.ssl.TrustManagerFactory; -import java.io.IOException; -import java.io.StringReader; -import java.security.GeneralSecurityException; import java.security.KeyStore; import java.security.PrivateKey; -import java.security.Security; import java.security.cert.CertPath; import java.security.cert.Certificate; import java.security.cert.CertificateFactory; import java.security.cert.X509Certificate; -import java.util.ArrayList; import java.util.List; import java.util.stream.Collectors; @@ -61,16 +43,11 @@ public class CertPemCredentials implements ClientCredentials { public static final String X_509 = "X.509"; public static final String CERT_ALIAS_PREFIX = "cert-"; public static final String CA_CERT_CERT_ALIAS_PREFIX = "caCert-cert-"; + protected String caCert; private String cert; private String privateKey; - private String password; - - public CertPemCredentials() { - if (Security.getProvider(BouncyCastleProvider.PROVIDER_NAME) == null) { - Security.addProvider(new BouncyCastleProvider()); - } - } + private String password = ""; @Override public CredentialsType getType() { @@ -95,7 +72,7 @@ public class CertPemCredentials implements ClientCredentials { } protected TrustManagerFactory createAndInitTrustManagerFactory() throws Exception { - List caCerts = readCertFile(caCert); + List caCerts = SslUtil.readCertFile(caCert); KeyStore caKeyStore = KeyStore.getInstance(KeyStore.getDefaultType()); caKeyStore.load(null, null); @@ -108,15 +85,15 @@ public class CertPemCredentials implements ClientCredentials { return trustManagerFactory; } - protected KeyManagerFactory createAndInitKeyManagerFactory() throws Exception { + private KeyManagerFactory createAndInitKeyManagerFactory() throws Exception { KeyManagerFactory kmf = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm()); kmf.init(loadKeyStore(), password.toCharArray()); return kmf; } - private KeyStore loadKeyStore() throws Exception { - List certificates = readCertFile(this.cert); - PrivateKey privateKey = readPrivateKey(this.privateKey, this.password); + protected KeyStore loadKeyStore() throws Exception { + List certificates = SslUtil.readCertFile(this.cert); + PrivateKey privateKey = SslUtil.readPrivateKey(this.privateKey, password); KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType()); keyStore.load(null); @@ -135,47 +112,4 @@ public class CertPemCredentials implements ClientCredentials { return keyStore; } - protected List readCertFile(String fileContent) throws IOException, GeneralSecurityException { - List certificates = new ArrayList<>(); - JcaX509CertificateConverter certConverter = new JcaX509CertificateConverter(); - try (PEMParser pemParser = new PEMParser(new StringReader(fileContent))) { - Object object; - while ((object = pemParser.readObject()) != null) { - if (object instanceof X509CertificateHolder) { - X509Certificate x509Cert = certConverter.getCertificate((X509CertificateHolder) object); - certificates.add(x509Cert); - } - } - } - return certificates; - } - - protected PrivateKey readPrivateKey(String fileContent, String password) throws IOException, PKCSException { - PrivateKey privateKey = null; - JcaPEMKeyConverter keyConverter = new JcaPEMKeyConverter(); - - if (StringUtils.isNotEmpty(fileContent)) { - try (PEMParser pemParser = new PEMParser(new StringReader(fileContent))) { - Object object; - while ((object = pemParser.readObject()) != null) { - if (object instanceof PEMEncryptedKeyPair) { - PEMDecryptorProvider decProv = new JcePEMDecryptorProviderBuilder().build(password.toCharArray()); - privateKey = keyConverter.getKeyPair(((PEMEncryptedKeyPair) object).decryptKeyPair(decProv)).getPrivate(); - break; - } else if (object instanceof PKCS8EncryptedPrivateKeyInfo) { - InputDecryptorProvider decProv = - new JcePKCSPBEInputDecryptorProviderBuilder().setProvider(new BouncyCastleProvider()).build(password.toCharArray()); - privateKey = keyConverter.getPrivateKey(((PKCS8EncryptedPrivateKeyInfo) object).decryptPrivateKeyInfo(decProv)); - break; - } else if (object instanceof PEMKeyPair) { - privateKey = keyConverter.getKeyPair((PEMKeyPair) object).getPrivate(); - break; - } else if (object instanceof PrivateKeyInfo) { - privateKey = keyConverter.getPrivateKey((PrivateKeyInfo) object); - } - } - } - } - return privateKey; - } } diff --git a/rule-engine/rule-engine-components/src/test/java/org/thingsboard/rule/engine/credentials/CertPemCredentialsTest.java b/rule-engine/rule-engine-components/src/test/java/org/thingsboard/rule/engine/credentials/CertPemCredentialsTest.java index fd7f0d3378..2cecd1490d 100644 --- a/rule-engine/rule-engine-components/src/test/java/org/thingsboard/rule/engine/credentials/CertPemCredentialsTest.java +++ b/rule-engine/rule-engine-components/src/test/java/org/thingsboard/rule/engine/credentials/CertPemCredentialsTest.java @@ -22,28 +22,32 @@ import org.junit.jupiter.api.Assertions; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.Arguments; import org.junit.jupiter.params.provider.MethodSource; +import org.thingsboard.common.util.SslUtil; import java.io.File; import java.io.IOException; -import java.security.PrivateKey; +import java.security.Key; +import java.security.KeyStore; +import java.security.cert.Certificate; import java.security.cert.X509Certificate; import java.util.List; import java.util.stream.Stream; -public class CertPemCredentialsTest { +import static org.thingsboard.rule.engine.credentials.CertPemCredentials.CERT_ALIAS_PREFIX; +import static org.thingsboard.rule.engine.credentials.CertPemCredentials.PRIVATE_KEY_ALIAS; - private final CertPemCredentials credentials = new CertPemCredentials(); +public class CertPemCredentialsTest { private static final String PASS = "test"; private static final String EMPTY_PASS = ""; private static final String RSA = "RSA"; - private static final String ECDSA = "ECDSA"; + private static final String EC = "EC"; @Test public void testChainOfCertificates() throws Exception { String fileContent = fileContent("pem/tb-cloud-chain.pem"); - List x509Certificates = credentials.readCertFile(fileContent); + List x509Certificates = SslUtil.readCertFile(fileContent); Assert.assertEquals(4, x509Certificates.size()); Assert.assertEquals("CN=*.thingsboard.cloud, O=\"ThingsBoard, Inc.\", ST=New York, C=US", @@ -60,7 +64,7 @@ public class CertPemCredentialsTest { public void testSingleCertificate() throws Exception { String fileContent = fileContent("pem/tb-cloud.pem"); - List x509Certificates = credentials.readCertFile(fileContent); + List x509Certificates = SslUtil.readCertFile(fileContent); Assert.assertEquals(1, x509Certificates.size()); Assert.assertEquals("CN=*.thingsboard.cloud, O=\"ThingsBoard, Inc.\", ST=New York, C=US", @@ -71,26 +75,41 @@ public class CertPemCredentialsTest { public void testEmptyFileContent() throws Exception { String fileContent = fileContent("pem/empty.pem"); - List x509Certificates = credentials.readCertFile(fileContent); + List x509Certificates = SslUtil.readCertFile(fileContent); Assert.assertEquals(0, x509Certificates.size()); } - private static Stream testReadPrivateKey() { + private static Stream testLoadKeyStore() { return Stream.of( - Arguments.of("pem/rsa_key.pem", EMPTY_PASS, RSA), - Arguments.of("pem/rsa_encrypted_key.pem", PASS, RSA), - Arguments.of("pem/rsa_encrypted_traditional_key.pem", PASS, RSA), - Arguments.of("pem/ec_key.pem", EMPTY_PASS, ECDSA) + Arguments.of("pem/rsa_cert.pem", "pem/rsa_key.pem", EMPTY_PASS, RSA), + Arguments.of("pem/rsa_encrypted_cert.pem", "pem/rsa_encrypted_key.pem", PASS, RSA), + Arguments.of("pem/rsa_encrypted_traditional_cert.pem", "pem/rsa_encrypted_traditional_key.pem", PASS, RSA), + Arguments.of("pem/ec_cert.pem", "pem/ec_key.pem", EMPTY_PASS, EC) ); } @ParameterizedTest @MethodSource - public void testReadPrivateKey(String keyPath, String password, String algorithm) throws Exception { - PrivateKey privateKey = credentials.readPrivateKey(fileContent(keyPath), password); - Assertions.assertNotNull(privateKey); - Assertions.assertEquals(algorithm, privateKey.getAlgorithm()); + public void testLoadKeyStore(String certPath, String keyPath, String password, String algorithm) throws Exception { + CertPemCredentials certPemCredentials = new CertPemCredentials(); + String certContent = fileContent(certPath); + certPemCredentials.setCert(certContent); + certPemCredentials.setPrivateKey(fileContent(keyPath)); + certPemCredentials.setPassword(password); + KeyStore keyStore = certPemCredentials.loadKeyStore(); + Assertions.assertNotNull(keyStore); + Key key = keyStore.getKey(PRIVATE_KEY_ALIAS, password.toCharArray()); + Assertions.assertNotNull(key); + Assertions.assertEquals(algorithm, key.getAlgorithm()); + + List certs = SslUtil.readCertFile(certContent); + for (X509Certificate cert : certs) { + String alias = CERT_ALIAS_PREFIX + cert.getIssuerDN().getName(); + Certificate certificate = keyStore.getCertificate(alias); + Assertions.assertNotNull(certificate); + Assertions.assertEquals(new String(cert.getEncoded()), new String(certificate.getEncoded())); + } } private String fileContent(String fileName) throws IOException { diff --git a/rule-engine/rule-engine-components/src/test/resources/pem/ec_cert.pem b/rule-engine/rule-engine-components/src/test/resources/pem/ec_cert.pem new file mode 100644 index 0000000000..f22f61d3a1 --- /dev/null +++ b/rule-engine/rule-engine-components/src/test/resources/pem/ec_cert.pem @@ -0,0 +1,13 @@ +-----BEGIN CERTIFICATE----- +MIICCDCCAa2gAwIBAgIUGx/SZqIWza/i/gaKFUVIyTEu2oMwCgYIKoZIzj0EAwIw +WTELMAkGA1UEBhMCVUExDTALBgNVBAgMBEtZSVYxDTALBgNVBAcMBEtZSVYxCzAJ +BgNVBAoMAlRCMQswCQYDVQQLDAJUQjESMBAGA1UEAwwJbG9jYWxob3N0MB4XDTIz +MTAxNjEyMjMyMVoXDTI0MTAxNTEyMjMyMVowWTELMAkGA1UEBhMCVUExDTALBgNV +BAgMBEtZSVYxDTALBgNVBAcMBEtZSVYxCzAJBgNVBAoMAlRCMQswCQYDVQQLDAJU +QjESMBAGA1UEAwwJbG9jYWxob3N0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE +z4MgawieJfVc5zUOPiw5WFxfHGJf7dOMsHvudDxdOs27PXPbJfi09BVJ3+JjNxA2 +wQz9KUk877oWRYrN/e+MbKNTMFEwHQYDVR0OBBYEFDTV8VD3m+8IBQOBJ+V/bcbl +4preMB8GA1UdIwQYMBaAFDTV8VD3m+8IBQOBJ+V/bcbl4preMA8GA1UdEwEB/wQF +MAMBAf8wCgYIKoZIzj0EAwIDSQAwRgIhAOgIkl8j8m51W7pWlNUAuUnHnOVhVjGr +h8Rc6cbwTapKAiEA2CLrduTweXEF5fBRtWyOsG8c9af6+MWHKmwHL1IDw9Q= +-----END CERTIFICATE----- diff --git a/rule-engine/rule-engine-components/src/test/resources/pem/rsa_cert.pem b/rule-engine/rule-engine-components/src/test/resources/pem/rsa_cert.pem new file mode 100644 index 0000000000..f89fce7444 --- /dev/null +++ b/rule-engine/rule-engine-components/src/test/resources/pem/rsa_cert.pem @@ -0,0 +1,32 @@ +-----BEGIN CERTIFICATE----- +MIIFkzCCA3ugAwIBAgIUUQa3cWUVoF58dzg8ycb/y7SdCj8wDQYJKoZIhvcNAQEL +BQAwWTELMAkGA1UEBhMCVUExDTALBgNVBAgMBEtZSVYxDTALBgNVBAcMBEtZSVYx +CzAJBgNVBAoMAlRCMQswCQYDVQQLDAJUQjESMBAGA1UEAwwJbG9jYWxob3N0MB4X +DTIzMTAxMzEyMzcwMVoXDTI0MTAxMjEyMzcwMVowWTELMAkGA1UEBhMCVUExDTAL +BgNVBAgMBEtZSVYxDTALBgNVBAcMBEtZSVYxCzAJBgNVBAoMAlRCMQswCQYDVQQL +DAJUQjESMBAGA1UEAwwJbG9jYWxob3N0MIICIjANBgkqhkiG9w0BAQEFAAOCAg8A +MIICCgKCAgEAsHn27cH+pYFI0eJYer8ww29g/xlKgr9aarYlkILeXnBhPPHBCXG+ +FegeMpHa8FUPANIqYJiwM13altO6hMLPa0J7+nQhwF5NCbxzAdi/kU8ofhIwJH+K +gOsD3BKdR7Ua7KMDQFnGTFRR9ZxsuYZ/0AHuzPHwxSLUvvMbiWbu5P2FYMrEyyLo +uVVihZPkeBhcnI6SJRyCdMdMy282nWQ+47gAUI3cFa7dXxUcXvRbbToMNPTIDUy4 +VhxJYhL4T6ED0Ds7tZRsG71LcMfw2RQUgiS1FuYh+O7N8lUMukMy2/umQluM0+qB +CYWa2p1UCbVzlrW1qgKQm1Q8E91XSR9KL/zdO8m9/uNeI1jyJu6i1cibWR7gnh6J +ChLxouQlrBzuLzSz7PG8q1MOWi+oHYJWSvmsckbQDhwEsfhFrYVgndJdxnmlkzvS +1OP7RGSYXLfMF+ZxC2YEJiU65QACCl2IHknyNiL8Jg5ahXgZMNshyfvOv5RB5jnz +4vzRpGhUYCcyLzORT+5gY9ZYbX/51cOomQV1ryTTQs+zA8mfEVLjbbLqvYdI84LC +3chMdcOm8Z9U1xdb2FX/c724XDyPnQNy1PLggzqvOFZzLeey0nBVUWyVrcCydbS5 +PAvVoAucO8kqP6b7uB7QnDeGaCiAVF+9QaXxjyQEdLEu3z5JMM7uH4UCAwEAAaNT +MFEwHQYDVR0OBBYEFHXrT3L+O3kJ2xNZ4Lh1ThGG6M1vMB8GA1UdIwQYMBaAFHXr +T3L+O3kJ2xNZ4Lh1ThGG6M1vMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQEL +BQADggIBABFDqkTdxsJyu5L2x3WSpw4jw4vgJYlgUvTSeU8i54DaSzncLZdpWsqb +37LFHkvlquIfvOi9f9EBT2KuZwaajPQBNE4m7kLchoAv8Mc8a2EXhN2caXamnN3F +vWAb4QW/VHKKz2vWprfARwqQO58TEPgzU4FcW1lPpX2ULBeoS5kZDDEgyfaFZETF +FnsSb9E3/YuH6sJCu880kbW8BIyQmbUytrbn+16J/iaZBwc+iD49t2VBLDOsr1x4 +5qzxknG3h9wiz9ob9v6hWFfMpdiK12S0P5FVsUkCpxoae8jc8rPS7W3HaYowFjVR +OHOjtWy5/SV2rypKShjg9manf6iwGdTGkD0qoqsRs9JQFabjNR23IQv+1OUbrEVC +DbS65IjwLJlIZBX8JuJaU3I8zqj/9q7TtRDp1NCiG5W0NgipERRCciWaLJ+Fz6Lu +QzhI2ZOJrl49hmr6e0bsyNUv9l89WcbKm3/IC+V7o80uADYCOaz2jDGfKbvcPHzN +mTma8qVsjpcedttsvNMyZOsM/Rpk+dbChgReRVvcmzQV0izEvJJBWFr4HrfcM6Ev +sZrnUiT8ENUZqiK40d+T3Q6JheHwm+ENI1aUDkYCpoWZ/PzKe+Bj8lR8dPvmeVrc +eiwS37nMFO/5X7aIkszTouScNO99cN0UqPldfJo+8ZTbai5VFxGD +-----END CERTIFICATE----- diff --git a/rule-engine/rule-engine-components/src/test/resources/pem/rsa_encrypted_cert.pem b/rule-engine/rule-engine-components/src/test/resources/pem/rsa_encrypted_cert.pem new file mode 100644 index 0000000000..2f4e55a612 --- /dev/null +++ b/rule-engine/rule-engine-components/src/test/resources/pem/rsa_encrypted_cert.pem @@ -0,0 +1,22 @@ +-----BEGIN CERTIFICATE----- +MIIDkzCCAnugAwIBAgIUKAylzm/K5OfbXSjm1zY9bX1a8HQwDQYJKoZIhvcNAQEL +BQAwWTELMAkGA1UEBhMCVUExDTALBgNVBAgMBEtZSVYxDTALBgNVBAcMBEtZSVYx +CzAJBgNVBAoMAlRCMQswCQYDVQQLDAJUQjESMBAGA1UEAwwJbG9jYWxob3N0MB4X +DTIzMTAxNjIxMDQwNVoXDTI0MTAxNTIxMDQwNVowWTELMAkGA1UEBhMCVUExDTAL +BgNVBAgMBEtZSVYxDTALBgNVBAcMBEtZSVYxCzAJBgNVBAoMAlRCMQswCQYDVQQL +DAJUQjESMBAGA1UEAwwJbG9jYWxob3N0MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A +MIIBCgKCAQEA87nLliszEWml8QvyAC+H80NZCxf4TcG826NBOp0AUPJ8xQBHCzc1 +t1ohVm2/fn2VJZAYXG2xSVcHyXjjjv3iGLE2AIDbXh06/yFg4TVjlbrWrAHFehyN +FwrK8ez36oGLa3ZVq+mx1fLfBQw5mStbh09NXmKTzqP6m9ggKtt63cUwoWdUTemT +qrjryJd69LiJi+MVqtbKO2j30/lgAZmaHtbojl9EcvWfeXLb20TnXRIctaIS1VGo +SluzjbNQErdN/VRW4RAOP6UFsK0xID2EuLODBmAWnI49fXO/OS+u3Kd3suABE0o9 +slfDXqNTp0r5N0OoSAFcc4EsV3+9Gf+mqwIDAQABo1MwUTAdBgNVHQ4EFgQUhS5K +XQDxGvaBCpKY1de+JZl8zjYwHwYDVR0jBBgwFoAUhS5KXQDxGvaBCpKY1de+JZl8 +zjYwDwYDVR0TAQH/BAUwAwEB/zANBgkqhkiG9w0BAQsFAAOCAQEAxez4vLtBCBNM +l6AQghViNAR9iiwYMxUwKwlU+uZftRGnT+6dXgfTR3PV6LCfMMmtuNs0JTGy0ff8 +erbzfZxExvHfIFXCwepwTWawQhvRRn9GHOJXIzESDRRhsXoJDzd0JVOx0wWxp1cz +EUts+ZbKLoC+kIhsOGY+0a+sopeV2rMO5bUMpA8P0mKZlGynEGMLzKxz65E/IA9h +EQKpJjpvYfN+7eUkF6ZRXNV2LI/8BCoG6mOVoOMEXnloPwwBtOevoCB43U3sT9Er +WQWgZdbeI4gEyEqgMTibNogZZF0KW+5as3iv7avDd8pCgONvD0iwKSlvi9RNjiw8 +p6bwNmBcuA== +-----END CERTIFICATE----- diff --git a/rule-engine/rule-engine-components/src/test/resources/pem/rsa_encrypted_traditional_cert.pem b/rule-engine/rule-engine-components/src/test/resources/pem/rsa_encrypted_traditional_cert.pem new file mode 100644 index 0000000000..38ab2e42fe --- /dev/null +++ b/rule-engine/rule-engine-components/src/test/resources/pem/rsa_encrypted_traditional_cert.pem @@ -0,0 +1,22 @@ +-----BEGIN CERTIFICATE----- +MIIDkzCCAnugAwIBAgIUIo+5l07ZrQR/LxEEmUbnn4yxCwIwDQYJKoZIhvcNAQEL +BQAwWTELMAkGA1UEBhMCVUExDTALBgNVBAgMBEtZSVYxDTALBgNVBAcMBEtZSVYx +CzAJBgNVBAoMAlRCMQswCQYDVQQLDAJUQjESMBAGA1UEAwwJbG9jYWxob3N0MB4X +DTIzMTAxNjIxMDMxNVoXDTI0MTAxNTIxMDMxNVowWTELMAkGA1UEBhMCVUExDTAL +BgNVBAgMBEtZSVYxDTALBgNVBAcMBEtZSVYxCzAJBgNVBAoMAlRCMQswCQYDVQQL +DAJUQjESMBAGA1UEAwwJbG9jYWxob3N0MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A +MIIBCgKCAQEA87nLliszEWml8QvyAC+H80NZCxf4TcG826NBOp0AUPJ8xQBHCzc1 +t1ohVm2/fn2VJZAYXG2xSVcHyXjjjv3iGLE2AIDbXh06/yFg4TVjlbrWrAHFehyN +FwrK8ez36oGLa3ZVq+mx1fLfBQw5mStbh09NXmKTzqP6m9ggKtt63cUwoWdUTemT +qrjryJd69LiJi+MVqtbKO2j30/lgAZmaHtbojl9EcvWfeXLb20TnXRIctaIS1VGo +SluzjbNQErdN/VRW4RAOP6UFsK0xID2EuLODBmAWnI49fXO/OS+u3Kd3suABE0o9 +slfDXqNTp0r5N0OoSAFcc4EsV3+9Gf+mqwIDAQABo1MwUTAdBgNVHQ4EFgQUhS5K +XQDxGvaBCpKY1de+JZl8zjYwHwYDVR0jBBgwFoAUhS5KXQDxGvaBCpKY1de+JZl8 +zjYwDwYDVR0TAQH/BAUwAwEB/zANBgkqhkiG9w0BAQsFAAOCAQEAiUTgjnsVIg90 +Dm+XSlscIPbZEj/mJanoFFfAfbVJz1DadygG9viVUMf3jVQBcsJGeBDckR2b3OHY +82cQVpdu3Heqld+gnfsyi8QBi7EdK4i0q8NVqFgpw83KxNm9xt7xrgHtxhE0kWfW +dpTgeIu0hFf0qLUObw/g8+0awBuxNY2crLtLXQM/dRgtv5Zt/DilW3jMLAE5wke+ +/HM4/emOJO6DSI9BC8iUsmNpIpq45267jcjpczNBo3ap7Bad+jM/paRDng9Uavvr +VCsaJFaL5HG6TtNXN60npBouOWnivPzUeuTI4PnjGRgdp3lgb0IuXbuwxIW6FVG/ +73RHc0gGOA== +-----END CERTIFICATE----- From c5c037b874a32519c79490e7d1f75ad8e832dd52 Mon Sep 17 00:00:00 2001 From: Volodymyr Babak Date: Wed, 18 Oct 2023 08:47:03 +0300 Subject: [PATCH 09/43] Update AlarmControllerTest with latest business logic - no edge notification during alarm udpate --- .../thingsboard/server/controller/AlarmControllerTest.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/application/src/test/java/org/thingsboard/server/controller/AlarmControllerTest.java b/application/src/test/java/org/thingsboard/server/controller/AlarmControllerTest.java index 0e6eb16713..2f859055bd 100644 --- a/application/src/test/java/org/thingsboard/server/controller/AlarmControllerTest.java +++ b/application/src/test/java/org/thingsboard/server/controller/AlarmControllerTest.java @@ -136,7 +136,7 @@ public class AlarmControllerTest extends AbstractControllerTest { Assert.assertEquals(AlarmSeverity.MAJOR, updatedAlarm.getSeverity()); AlarmInfo foundAlarm = doGet("/api/alarm/info/" + updatedAlarm.getId(), AlarmInfo.class); - testNotifyEntityAllOneTime(foundAlarm, updatedAlarm.getId(), updatedAlarm.getOriginator(), + testNotifyEntityOneTimeMsgToEdgeServiceNever(foundAlarm, updatedAlarm.getId(), updatedAlarm.getOriginator(), tenantId, customerId, customerUserId, CUSTOMER_USER_EMAIL, ActionType.UPDATED); } @@ -153,7 +153,7 @@ public class AlarmControllerTest extends AbstractControllerTest { Assert.assertEquals(AlarmSeverity.MAJOR, updatedAlarm.getSeverity()); AlarmInfo foundAlarm = doGet("/api/alarm/info/" + updatedAlarm.getId(), AlarmInfo.class); - testNotifyEntityAllOneTime(foundAlarm, foundAlarm.getId(), foundAlarm.getOriginator(), + testNotifyEntityOneTimeMsgToEdgeServiceNever(foundAlarm, foundAlarm.getId(), foundAlarm.getOriginator(), tenantId, customerId, tenantAdminUserId, TENANT_ADMIN_EMAIL, ActionType.UPDATED); alarm = updatedAlarm; From 9b6b161d37e79506f9895c53f4abd58d5dfdeda5 Mon Sep 17 00:00:00 2001 From: Volodymyr Babak Date: Wed, 18 Oct 2023 10:15:51 +0300 Subject: [PATCH 10/43] Revert changes for getting alarms by ids --- ui-ngx/src/app/core/http/entity.service.ts | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/ui-ngx/src/app/core/http/entity.service.ts b/ui-ngx/src/app/core/http/entity.service.ts index cc1dd13345..b4eab83b08 100644 --- a/ui-ngx/src/app/core/http/entity.service.ts +++ b/ui-ngx/src/app/core/http/entity.service.ts @@ -240,9 +240,7 @@ export class EntityService { entityIds); break; case EntityType.ALARM: - observable = this.getEntitiesByIdsObservable( - (id) => this.alarmService.getAlarm(id, config), - entityIds); + console.error('Get Alarm Entity is not implemented!'); break; case EntityType.DEVICE_PROFILE: observable = this.getEntitiesByIdsObservable( From ef292c5cbb026328cfe7ed503f6a9805503cb216 Mon Sep 17 00:00:00 2001 From: ViacheslavKlimov Date: Wed, 18 Oct 2023 12:56:01 +0300 Subject: [PATCH 11/43] Fix delete queries in repositories --- .../server/dao/sql/alarm/EntityAlarmRepository.java | 4 +++- .../dao/sql/notification/NotificationRepository.java | 12 +++++++++--- .../notification/NotificationRequestRepository.java | 8 ++++++-- .../sql/notification/NotificationRuleRepository.java | 5 ++++- .../notification/NotificationTargetRepository.java | 5 ++++- .../notification/NotificationTemplateRepository.java | 5 ++++- 6 files changed, 30 insertions(+), 9 deletions(-) diff --git a/dao/src/main/java/org/thingsboard/server/dao/sql/alarm/EntityAlarmRepository.java b/dao/src/main/java/org/thingsboard/server/dao/sql/alarm/EntityAlarmRepository.java index f6250e98f0..2ed2364621 100644 --- a/dao/src/main/java/org/thingsboard/server/dao/sql/alarm/EntityAlarmRepository.java +++ b/dao/src/main/java/org/thingsboard/server/dao/sql/alarm/EntityAlarmRepository.java @@ -36,6 +36,8 @@ public interface EntityAlarmRepository extends JpaRepository findByRequestId(UUID requestId, Pageable pageable); @Transactional - int deleteByIdAndRecipientId(UUID id, UUID recipientId); + @Modifying + @Query("DELETE FROM NotificationEntity n WHERE n.id = :id AND n.recipientId = :recipientId") + int deleteByIdAndRecipientId(@Param("id") UUID id, @Param("recipientId") UUID recipientId); @Transactional - void deleteByRequestId(UUID requestId); + @Modifying + @Query("DELETE FROM NotificationEntity n WHERE n.requestId = :requestId") + void deleteByRequestId(@Param("requestId") UUID requestId); @Transactional - void deleteByRecipientId(UUID recipientId); + @Modifying + @Query("DELETE FROM NotificationEntity n WHERE n.recipientId = :recipientId") + void deleteByRecipientId(@Param("recipientId") UUID recipientId); @Modifying @Transactional diff --git a/dao/src/main/java/org/thingsboard/server/dao/sql/notification/NotificationRequestRepository.java b/dao/src/main/java/org/thingsboard/server/dao/sql/notification/NotificationRequestRepository.java index 126295616f..e7f3ac529b 100644 --- a/dao/src/main/java/org/thingsboard/server/dao/sql/notification/NotificationRequestRepository.java +++ b/dao/src/main/java/org/thingsboard/server/dao/sql/notification/NotificationRequestRepository.java @@ -70,9 +70,13 @@ public interface NotificationRequestRepository extends JpaRepository findByTenantIdAndIdIn(UUID tenantId, List ids); @Transactional - void deleteByTenantId(UUID tenantId); + @Modifying + @Query("DELETE FROM NotificationTargetEntity t WHERE t.tenantId = :tenantId") + void deleteByTenantId(@Param("tenantId") UUID tenantId); long countByTenantId(UUID tenantId); diff --git a/dao/src/main/java/org/thingsboard/server/dao/sql/notification/NotificationTemplateRepository.java b/dao/src/main/java/org/thingsboard/server/dao/sql/notification/NotificationTemplateRepository.java index 73a25b98c3..3e68819b26 100644 --- a/dao/src/main/java/org/thingsboard/server/dao/sql/notification/NotificationTemplateRepository.java +++ b/dao/src/main/java/org/thingsboard/server/dao/sql/notification/NotificationTemplateRepository.java @@ -18,6 +18,7 @@ package org.thingsboard.server.dao.sql.notification; import org.springframework.data.domain.Page; import org.springframework.data.domain.Pageable; import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.data.jpa.repository.Modifying; import org.springframework.data.jpa.repository.Query; import org.springframework.data.repository.query.Param; import org.springframework.stereotype.Repository; @@ -42,7 +43,9 @@ public interface NotificationTemplateRepository extends JpaRepository Date: Tue, 17 Oct 2023 12:03:24 +0200 Subject: [PATCH 12/43] ComponentLifecycleMsgProto implemented as replacement of raw byte encoding --- .../queue/DefaultTbClusterService.java | 6 +- .../queue/DefaultTbCoreConsumerService.java | 4 + .../DefaultTbRuleEngineConsumerService.java | 6 +- .../server/service/queue/ProtoUtils.java | 47 ++++++++++ .../service/queue/TbCoreConsumerStats.java | 2 + .../processing/AbstractConsumerService.java | 86 ++++++++++--------- .../server/service/queue/ProtoUtilsTest.java | 71 +++++++++++++++ common/cluster-api/src/main/proto/queue.proto | 58 ++++++++++++- .../server/common/data/EntityType.java | 1 + .../common/data/id/EntityIdFactory.java | 4 + .../data/plugin/ComponentLifecycleEvent.java | 1 + .../msg/plugin/ComponentLifecycleMsg.java | 14 +-- .../common/msg/plugin/RuleNodeUpdatedMsg.java | 6 +- 13 files changed, 245 insertions(+), 61 deletions(-) create mode 100644 application/src/main/java/org/thingsboard/server/service/queue/ProtoUtils.java create mode 100644 application/src/test/java/org/thingsboard/server/service/queue/ProtoUtilsTest.java diff --git a/application/src/main/java/org/thingsboard/server/service/queue/DefaultTbClusterService.java b/application/src/main/java/org/thingsboard/server/service/queue/DefaultTbClusterService.java index 53ef38d96a..937ee12fab 100644 --- a/application/src/main/java/org/thingsboard/server/service/queue/DefaultTbClusterService.java +++ b/application/src/main/java/org/thingsboard/server/service/queue/DefaultTbClusterService.java @@ -395,7 +395,7 @@ public class DefaultTbClusterService implements TbClusterService { } private void broadcast(ComponentLifecycleMsg msg) { - byte[] msgBytes = encodingService.encode(msg); + TransportProtos.ComponentLifecycleMsgProto componentLifecycleMsgProto = ProtoUtils.toProto(msg); TbQueueProducer> toRuleEngineProducer = producerProvider.getRuleEngineNotificationsMsgProducer(); Set tbRuleEngineServices = partitionService.getAllServiceIds(ServiceType.TB_RULE_ENGINE); EntityType entityType = msg.getEntityId().getEntityType(); @@ -413,7 +413,7 @@ public class DefaultTbClusterService implements TbClusterService { Set tbCoreServices = partitionService.getAllServiceIds(ServiceType.TB_CORE); for (String serviceId : tbCoreServices) { TopicPartitionInfo tpi = notificationsTopicService.getNotificationsTopic(ServiceType.TB_CORE, serviceId); - ToCoreNotificationMsg toCoreMsg = ToCoreNotificationMsg.newBuilder().setComponentLifecycleMsg(ByteString.copyFrom(msgBytes)).build(); + ToCoreNotificationMsg toCoreMsg = ToCoreNotificationMsg.newBuilder().setComponentLifecycle(componentLifecycleMsgProto).build(); toCoreNfProducer.send(tpi, new TbProtoQueueMsg<>(msg.getEntityId().getId(), toCoreMsg), null); toCoreNfs.incrementAndGet(); } @@ -422,7 +422,7 @@ public class DefaultTbClusterService implements TbClusterService { } for (String serviceId : tbRuleEngineServices) { TopicPartitionInfo tpi = notificationsTopicService.getNotificationsTopic(ServiceType.TB_RULE_ENGINE, serviceId); - ToRuleEngineNotificationMsg toRuleEngineMsg = ToRuleEngineNotificationMsg.newBuilder().setComponentLifecycleMsg(ByteString.copyFrom(msgBytes)).build(); + ToRuleEngineNotificationMsg toRuleEngineMsg = ToRuleEngineNotificationMsg.newBuilder().setComponentLifecycle(componentLifecycleMsgProto).build(); toRuleEngineProducer.send(tpi, new TbProtoQueueMsg<>(msg.getEntityId().getId(), toRuleEngineMsg), null); toRuleEngineNfs.incrementAndGet(); } diff --git a/application/src/main/java/org/thingsboard/server/service/queue/DefaultTbCoreConsumerService.java b/application/src/main/java/org/thingsboard/server/service/queue/DefaultTbCoreConsumerService.java index fd5a252cc5..bae1ea35a6 100644 --- a/application/src/main/java/org/thingsboard/server/service/queue/DefaultTbCoreConsumerService.java +++ b/application/src/main/java/org/thingsboard/server/service/queue/DefaultTbCoreConsumerService.java @@ -346,7 +346,11 @@ public class DefaultTbCoreConsumerService extends AbstractConsumerService msg, TbCallback callback) throws Exception { ToRuleEngineNotificationMsg nfMsg = msg.getValue(); - if (nfMsg.getComponentLifecycleMsg() != null && !nfMsg.getComponentLifecycleMsg().isEmpty()) { + if (nfMsg.hasComponentLifecycle()) { + handleComponentLifecycleMsg(id, ProtoUtils.fromProto(nfMsg.getComponentLifecycle())); + callback.onSuccess(); + } else if (nfMsg.getComponentLifecycleMsg() != null && !nfMsg.getComponentLifecycleMsg().isEmpty()) { + //will be removed in 3.6.1 in favour of hasComponentLifecycle() handleComponentLifecycleMsg(id, nfMsg.getComponentLifecycleMsg()); callback.onSuccess(); } else if (nfMsg.hasFromDeviceRpcResponse()) { diff --git a/application/src/main/java/org/thingsboard/server/service/queue/ProtoUtils.java b/application/src/main/java/org/thingsboard/server/service/queue/ProtoUtils.java new file mode 100644 index 0000000000..3406265747 --- /dev/null +++ b/application/src/main/java/org/thingsboard/server/service/queue/ProtoUtils.java @@ -0,0 +1,47 @@ +/** + * Copyright © 2016-2023 The Thingsboard Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.thingsboard.server.service.queue; + +import org.thingsboard.server.common.data.id.EntityIdFactory; +import org.thingsboard.server.common.data.id.TenantId; +import org.thingsboard.server.common.data.plugin.ComponentLifecycleEvent; +import org.thingsboard.server.common.msg.plugin.ComponentLifecycleMsg; +import org.thingsboard.server.gen.transport.TransportProtos; + +import java.util.UUID; + +public class ProtoUtils { + + public static TransportProtos.ComponentLifecycleMsgProto toProto(ComponentLifecycleMsg msg) { + return TransportProtos.ComponentLifecycleMsgProto.newBuilder() + .setTenantIdMSB(msg.getTenantId().getId().getMostSignificantBits()) + .setTenantIdLSB(msg.getTenantId().getId().getLeastSignificantBits()) + .setEntityType(TransportProtos.EntityType.forNumber(msg.getEntityId().getEntityType().ordinal())) + .setEntityIdMSB(msg.getEntityId().getId().getMostSignificantBits()) + .setEntityIdLSB(msg.getEntityId().getId().getLeastSignificantBits()) + .setEvent(TransportProtos.ComponentLifecycleEvent.forNumber(msg.getEvent().ordinal())) + .build(); + } + + public static ComponentLifecycleMsg fromProto(TransportProtos.ComponentLifecycleMsgProto proto) { + return new ComponentLifecycleMsg( + TenantId.fromUUID(new UUID(proto.getTenantIdMSB(), proto.getTenantIdLSB())), + EntityIdFactory.getByTypeAndUuid(proto.getEntityTypeValue(), new UUID(proto.getEntityIdMSB(), proto.getEntityIdLSB())), + ComponentLifecycleEvent.values()[proto.getEventValue()] + ); + } + +} diff --git a/application/src/main/java/org/thingsboard/server/service/queue/TbCoreConsumerStats.java b/application/src/main/java/org/thingsboard/server/service/queue/TbCoreConsumerStats.java index 4d195a0dec..9107159615 100644 --- a/application/src/main/java/org/thingsboard/server/service/queue/TbCoreConsumerStats.java +++ b/application/src/main/java/org/thingsboard/server/service/queue/TbCoreConsumerStats.java @@ -168,6 +168,8 @@ public class TbCoreConsumerStats { toCoreNfSubscriptionServiceCounter.increment(); } else if (msg.hasFromDeviceRpcResponse()) { toCoreNfDeviceRpcResponseCounter.increment(); + } else if (msg.hasComponentLifecycle()) { + toCoreNfComponentLifecycleCounter.increment(); } else if (!msg.getComponentLifecycleMsg().isEmpty()) { toCoreNfComponentLifecycleCounter.increment(); } else if (!msg.getEdgeEventUpdateMsg().isEmpty()) { diff --git a/application/src/main/java/org/thingsboard/server/service/queue/processing/AbstractConsumerService.java b/application/src/main/java/org/thingsboard/server/service/queue/processing/AbstractConsumerService.java index b59086a350..591bc058c1 100644 --- a/application/src/main/java/org/thingsboard/server/service/queue/processing/AbstractConsumerService.java +++ b/application/src/main/java/org/thingsboard/server/service/queue/processing/AbstractConsumerService.java @@ -166,55 +166,57 @@ public abstract class AbstractConsumerService actorMsgOpt = encodingService.decode(nfMsg.toByteArray()); - if (actorMsgOpt.isPresent()) { - TbActorMsg actorMsg = actorMsgOpt.get(); - if (actorMsg instanceof ComponentLifecycleMsg) { - ComponentLifecycleMsg componentLifecycleMsg = (ComponentLifecycleMsg) actorMsg; - log.debug("[{}][{}][{}] Received Lifecycle event: {}", componentLifecycleMsg.getTenantId(), componentLifecycleMsg.getEntityId().getEntityType(), - componentLifecycleMsg.getEntityId(), componentLifecycleMsg.getEvent()); - if (EntityType.TENANT_PROFILE.equals(componentLifecycleMsg.getEntityId().getEntityType())) { - TenantProfileId tenantProfileId = new TenantProfileId(componentLifecycleMsg.getEntityId().getId()); - tenantProfileCache.evict(tenantProfileId); + actorMsgOpt.ifPresent(tbActorMsg -> handleComponentLifecycleMsg(id, tbActorMsg)); + } + + protected void handleComponentLifecycleMsg(UUID id, TbActorMsg actorMsg) { + if (actorMsg instanceof ComponentLifecycleMsg) { + ComponentLifecycleMsg componentLifecycleMsg = (ComponentLifecycleMsg) actorMsg; + log.debug("[{}][{}][{}] Received Lifecycle event: {}", componentLifecycleMsg.getTenantId(), componentLifecycleMsg.getEntityId().getEntityType(), + componentLifecycleMsg.getEntityId(), componentLifecycleMsg.getEvent()); + if (EntityType.TENANT_PROFILE.equals(componentLifecycleMsg.getEntityId().getEntityType())) { + TenantProfileId tenantProfileId = new TenantProfileId(componentLifecycleMsg.getEntityId().getId()); + tenantProfileCache.evict(tenantProfileId); + if (componentLifecycleMsg.getEvent().equals(ComponentLifecycleEvent.UPDATED)) { + apiUsageStateService.onTenantProfileUpdate(tenantProfileId); + } + } else if (EntityType.TENANT.equals(componentLifecycleMsg.getEntityId().getEntityType())) { + if (TenantId.SYS_TENANT_ID.equals(componentLifecycleMsg.getTenantId())) { + jwtSettingsService.ifPresent(JwtSettingsService::reloadJwtSettings); + return; + } else { + tenantProfileCache.evict(componentLifecycleMsg.getTenantId()); + partitionService.removeTenant(componentLifecycleMsg.getTenantId()); if (componentLifecycleMsg.getEvent().equals(ComponentLifecycleEvent.UPDATED)) { - apiUsageStateService.onTenantProfileUpdate(tenantProfileId); - } - } else if (EntityType.TENANT.equals(componentLifecycleMsg.getEntityId().getEntityType())) { - if (TenantId.SYS_TENANT_ID.equals(componentLifecycleMsg.getTenantId())) { - jwtSettingsService.ifPresent(JwtSettingsService::reloadJwtSettings); - return; - } else { - tenantProfileCache.evict(componentLifecycleMsg.getTenantId()); - partitionService.removeTenant(componentLifecycleMsg.getTenantId()); - if (componentLifecycleMsg.getEvent().equals(ComponentLifecycleEvent.UPDATED)) { - apiUsageStateService.onTenantUpdate(componentLifecycleMsg.getTenantId()); - } else if (componentLifecycleMsg.getEvent().equals(ComponentLifecycleEvent.DELETED)) { - apiUsageStateService.onTenantDelete((TenantId) componentLifecycleMsg.getEntityId()); - } - } - } else if (EntityType.DEVICE_PROFILE.equals(componentLifecycleMsg.getEntityId().getEntityType())) { - deviceProfileCache.evict(componentLifecycleMsg.getTenantId(), new DeviceProfileId(componentLifecycleMsg.getEntityId().getId())); - } else if (EntityType.DEVICE.equals(componentLifecycleMsg.getEntityId().getEntityType())) { - deviceProfileCache.evict(componentLifecycleMsg.getTenantId(), new DeviceId(componentLifecycleMsg.getEntityId().getId())); - } else if (EntityType.ASSET_PROFILE.equals(componentLifecycleMsg.getEntityId().getEntityType())) { - assetProfileCache.evict(componentLifecycleMsg.getTenantId(), new AssetProfileId(componentLifecycleMsg.getEntityId().getId())); - } else if (EntityType.ASSET.equals(componentLifecycleMsg.getEntityId().getEntityType())) { - assetProfileCache.evict(componentLifecycleMsg.getTenantId(), new AssetId(componentLifecycleMsg.getEntityId().getId())); - } else if (EntityType.ENTITY_VIEW.equals(componentLifecycleMsg.getEntityId().getEntityType())) { - actorContext.getTbEntityViewService().onComponentLifecycleMsg(componentLifecycleMsg); - } else if (EntityType.API_USAGE_STATE.equals(componentLifecycleMsg.getEntityId().getEntityType())) { - apiUsageStateService.onApiUsageStateUpdate(componentLifecycleMsg.getTenantId()); - } else if (EntityType.CUSTOMER.equals(componentLifecycleMsg.getEntityId().getEntityType())) { - if (componentLifecycleMsg.getEvent() == ComponentLifecycleEvent.DELETED) { - apiUsageStateService.onCustomerDelete((CustomerId) componentLifecycleMsg.getEntityId()); + apiUsageStateService.onTenantUpdate(componentLifecycleMsg.getTenantId()); + } else if (componentLifecycleMsg.getEvent().equals(ComponentLifecycleEvent.DELETED)) { + apiUsageStateService.onTenantDelete((TenantId) componentLifecycleMsg.getEntityId()); } } - eventPublisher.publishEvent(componentLifecycleMsg); + } else if (EntityType.DEVICE_PROFILE.equals(componentLifecycleMsg.getEntityId().getEntityType())) { + deviceProfileCache.evict(componentLifecycleMsg.getTenantId(), new DeviceProfileId(componentLifecycleMsg.getEntityId().getId())); + } else if (EntityType.DEVICE.equals(componentLifecycleMsg.getEntityId().getEntityType())) { + deviceProfileCache.evict(componentLifecycleMsg.getTenantId(), new DeviceId(componentLifecycleMsg.getEntityId().getId())); + } else if (EntityType.ASSET_PROFILE.equals(componentLifecycleMsg.getEntityId().getEntityType())) { + assetProfileCache.evict(componentLifecycleMsg.getTenantId(), new AssetProfileId(componentLifecycleMsg.getEntityId().getId())); + } else if (EntityType.ASSET.equals(componentLifecycleMsg.getEntityId().getEntityType())) { + assetProfileCache.evict(componentLifecycleMsg.getTenantId(), new AssetId(componentLifecycleMsg.getEntityId().getId())); + } else if (EntityType.ENTITY_VIEW.equals(componentLifecycleMsg.getEntityId().getEntityType())) { + actorContext.getTbEntityViewService().onComponentLifecycleMsg(componentLifecycleMsg); + } else if (EntityType.API_USAGE_STATE.equals(componentLifecycleMsg.getEntityId().getEntityType())) { + apiUsageStateService.onApiUsageStateUpdate(componentLifecycleMsg.getTenantId()); + } else if (EntityType.CUSTOMER.equals(componentLifecycleMsg.getEntityId().getEntityType())) { + if (componentLifecycleMsg.getEvent() == ComponentLifecycleEvent.DELETED) { + apiUsageStateService.onCustomerDelete((CustomerId) componentLifecycleMsg.getEntityId()); + } } - log.trace("[{}] Forwarding message to App Actor {}", id, actorMsg); - actorContext.tellWithHighPriority(actorMsg); + eventPublisher.publishEvent(componentLifecycleMsg); } + log.trace("[{}] Forwarding component lifecycle message to App Actor {}", id, actorMsg); + actorContext.tellWithHighPriority(actorMsg); } protected abstract void handleNotification(UUID id, TbProtoQueueMsg msg, TbCallback callback) throws Exception; diff --git a/application/src/test/java/org/thingsboard/server/service/queue/ProtoUtilsTest.java b/application/src/test/java/org/thingsboard/server/service/queue/ProtoUtilsTest.java new file mode 100644 index 0000000000..c63055a6f1 --- /dev/null +++ b/application/src/test/java/org/thingsboard/server/service/queue/ProtoUtilsTest.java @@ -0,0 +1,71 @@ +/** + * Copyright © 2016-2023 The Thingsboard Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.thingsboard.server.service.queue; + +import org.junit.jupiter.api.Test; +import org.thingsboard.server.common.data.id.EntityId; +import org.thingsboard.server.common.data.id.RuleChainId; +import org.thingsboard.server.common.data.id.TenantId; +import org.thingsboard.server.common.data.plugin.ComponentLifecycleEvent; +import org.thingsboard.server.common.msg.plugin.ComponentLifecycleMsg; +import org.thingsboard.server.gen.transport.TransportProtos; +import java.util.UUID; + +import static org.assertj.core.api.Assertions.assertThat; + +class ProtoUtilsTest { + + TenantId tenantId = TenantId.fromUUID(UUID.fromString("35e10f77-16e7-424d-ae46-ee780f87ac4f")); + EntityId entityId = new RuleChainId(UUID.fromString("c640b635-4f0f-41e6-b10b-25a86003094e")); + @Test + void toProtoComponentLifecycleMsg() { + ComponentLifecycleMsg msg = new ComponentLifecycleMsg(tenantId, entityId, ComponentLifecycleEvent.UPDATED); + + TransportProtos.ComponentLifecycleMsgProto proto = ProtoUtils.toProto(msg); + + assertThat(proto).as("to proto").isEqualTo(TransportProtos.ComponentLifecycleMsgProto.newBuilder() + .setTenantIdMSB(tenantId.getId().getMostSignificantBits()) + .setTenantIdLSB(tenantId.getId().getLeastSignificantBits()) + .setEntityType(TransportProtos.EntityType.forNumber(entityId.getEntityType().ordinal())) + .setEntityIdMSB(entityId.getId().getMostSignificantBits()) + .setEntityIdLSB(entityId.getId().getLeastSignificantBits()) + .setEvent(TransportProtos.ComponentLifecycleEvent.forNumber(ComponentLifecycleEvent.UPDATED.ordinal())) + .build() + ); + + assertThat(ProtoUtils.fromProto(proto)).as("from proto").isEqualTo(msg); + } + + @Test + void fromProtoComponentLifecycleMsg() { + TransportProtos.ComponentLifecycleMsgProto proto = TransportProtos.ComponentLifecycleMsgProto.newBuilder() + .setTenantIdMSB(tenantId.getId().getMostSignificantBits()) + .setTenantIdLSB(tenantId.getId().getLeastSignificantBits()) + .setEntityType(TransportProtos.EntityType.forNumber(entityId.getEntityType().ordinal())) + .setEntityIdMSB(entityId.getId().getMostSignificantBits()) + .setEntityIdLSB(entityId.getId().getLeastSignificantBits()) + .setEvent(TransportProtos.ComponentLifecycleEvent.forNumber(ComponentLifecycleEvent.STARTED.ordinal())) + .build(); + + ComponentLifecycleMsg msg = ProtoUtils.fromProto(proto); + + assertThat(msg).as("from proto").isEqualTo( + new ComponentLifecycleMsg(tenantId, entityId, ComponentLifecycleEvent.STARTED)); + + assertThat(ProtoUtils.toProto(msg)).as("to proto").isEqualTo(proto); + } + +} \ No newline at end of file diff --git a/common/cluster-api/src/main/proto/queue.proto b/common/cluster-api/src/main/proto/queue.proto index 60dfcae1de..d8439d0cd0 100644 --- a/common/cluster-api/src/main/proto/queue.proto +++ b/common/cluster-api/src/main/proto/queue.proto @@ -20,6 +20,38 @@ package transport; option java_package = "org.thingsboard.server.gen.transport"; option java_outer_classname = "TransportProtos"; +/** + * Common data structures + */ +enum EntityType { + TENANT = 0; + CUSTOMER = 1; + USER = 2; + DASHBOARD = 3; + ASSET = 4; + DEVICE = 5; + ALARM = 6; + RULE_CHAIN = 7; + RULE_NODE = 8; + ENTITY_VIEW = 9; + WIDGETS_BUNDLE = 10; + WIDGET_TYPE = 11; + TENANT_PROFILE = 12; + DEVICE_PROFILE = 13; + ASSET_PROFILE = 14; + API_USAGE_STATE = 15; + TB_RESOURCE = 16; + OTA_PACKAGE = 17; + EDGE = 18; + RPC = 19; + QUEUE = 20; + NOTIFICATION_TARGET = 21; + NOTIFICATION_TEMPLATE = 22; + NOTIFICATION_REQUEST = 23; + NOTIFICATION = 24; + NOTIFICATION_RULE = 25; +} + /** * Service Discovery Data Structures; */ @@ -731,6 +763,25 @@ message FromDeviceRPCResponseProto { int32 error = 4; } +enum ComponentLifecycleEvent { + CREATED = 0; + STARTED = 1; + ACTIVATED = 2; + SUSPENDED = 3; + UPDATED = 4; + STOPPED = 5; + DELETED = 6; +} + +message ComponentLifecycleMsgProto { + int64 tenantIdMSB = 1; + int64 tenantIdLSB = 2; + EntityType entityType = 3; + int64 entityIdMSB = 4; + int64 entityIdLSB = 5; + ComponentLifecycleEvent event = 6; +} + message EdgeNotificationMsgProto { int64 tenantIdMSB = 1; int64 tenantIdLSB = 2; @@ -980,10 +1031,11 @@ message ToCoreMsg { } /* High priority messages with low latency are handled by ThingsBoard Core Service separately */ +/* Please, adjust the TbCoreConsumerStats when modifying the ToCoreNotificationMsg */ message ToCoreNotificationMsg { LocalSubscriptionServiceMsgProto toLocalSubscriptionServiceMsg = 1; FromDeviceRPCResponseProto fromDeviceRpcResponse = 2; - bytes componentLifecycleMsg = 3; + bytes componentLifecycleMsg = 3; //will be removed in 3.6.1 in favour of ComponentLifecycleMsgProto bytes edgeEventUpdateMsg = 4; QueueUpdateMsg queueUpdateMsg = 5; QueueDeleteMsg queueDeleteMsg = 6; @@ -992,6 +1044,7 @@ message ToCoreNotificationMsg { bytes fromEdgeSyncResponseMsg = 9; SubscriptionMgrMsgProto toSubscriptionMgrMsg = 10; NotificationRuleProcessorMsg notificationRuleProcessorMsg = 11; + ComponentLifecycleMsgProto componentLifecycle = 12; } /* Messages that are handled by ThingsBoard RuleEngine Service */ @@ -1004,10 +1057,11 @@ message ToRuleEngineMsg { } message ToRuleEngineNotificationMsg { - bytes componentLifecycleMsg = 1; + bytes componentLifecycleMsg = 1; // will be removed in 3.6.1 in favour of ComponentLifecycleMsgProto FromDeviceRPCResponseProto fromDeviceRpcResponse = 2; QueueUpdateMsg queueUpdateMsg = 3; QueueDeleteMsg queueDeleteMsg = 4; + ComponentLifecycleMsgProto componentLifecycle = 5; } /* Messages that are handled by ThingsBoard Transport Service */ diff --git a/common/data/src/main/java/org/thingsboard/server/common/data/EntityType.java b/common/data/src/main/java/org/thingsboard/server/common/data/EntityType.java index 8ca6585718..c4344e8789 100644 --- a/common/data/src/main/java/org/thingsboard/server/common/data/EntityType.java +++ b/common/data/src/main/java/org/thingsboard/server/common/data/EntityType.java @@ -26,6 +26,7 @@ import java.util.stream.Collectors; * @author Andrew Shvayka */ public enum EntityType { + // In sync with EntityType proto TENANT, CUSTOMER, USER, diff --git a/common/data/src/main/java/org/thingsboard/server/common/data/id/EntityIdFactory.java b/common/data/src/main/java/org/thingsboard/server/common/data/id/EntityIdFactory.java index 0cdf3ad1eb..da92eb65d6 100644 --- a/common/data/src/main/java/org/thingsboard/server/common/data/id/EntityIdFactory.java +++ b/common/data/src/main/java/org/thingsboard/server/common/data/id/EntityIdFactory.java @@ -29,6 +29,10 @@ public class EntityIdFactory { return getByTypeAndUuid(EntityType.values()[type], UUID.fromString(uuid)); } + public static EntityId getByTypeAndUuid(int type, UUID uuid) { + return getByTypeAndUuid(EntityType.values()[type], uuid); + } + public static EntityId getByTypeAndUuid(String type, String uuid) { return getByTypeAndUuid(EntityType.valueOf(type), UUID.fromString(uuid)); } diff --git a/common/data/src/main/java/org/thingsboard/server/common/data/plugin/ComponentLifecycleEvent.java b/common/data/src/main/java/org/thingsboard/server/common/data/plugin/ComponentLifecycleEvent.java index a7ae9599ea..969baee088 100644 --- a/common/data/src/main/java/org/thingsboard/server/common/data/plugin/ComponentLifecycleEvent.java +++ b/common/data/src/main/java/org/thingsboard/server/common/data/plugin/ComponentLifecycleEvent.java @@ -21,5 +21,6 @@ import java.io.Serializable; * @author Andrew Shvayka */ public enum ComponentLifecycleEvent implements Serializable { + // In sync with ComponentLifecycleEvent proto CREATED, STARTED, ACTIVATED, SUSPENDED, UPDATED, STOPPED, DELETED } \ No newline at end of file diff --git a/common/message/src/main/java/org/thingsboard/server/common/msg/plugin/ComponentLifecycleMsg.java b/common/message/src/main/java/org/thingsboard/server/common/msg/plugin/ComponentLifecycleMsg.java index b25a8cd3ea..f110a6f209 100644 --- a/common/message/src/main/java/org/thingsboard/server/common/msg/plugin/ComponentLifecycleMsg.java +++ b/common/message/src/main/java/org/thingsboard/server/common/msg/plugin/ComponentLifecycleMsg.java @@ -15,8 +15,7 @@ */ package org.thingsboard.server.common.msg.plugin; -import lombok.Getter; -import lombok.ToString; +import lombok.Data; import org.thingsboard.server.common.data.EntityType; import org.thingsboard.server.common.data.id.EntityId; import org.thingsboard.server.common.data.id.RuleChainId; @@ -31,21 +30,12 @@ import java.util.Optional; /** * @author Andrew Shvayka */ -@ToString +@Data public class ComponentLifecycleMsg implements TenantAwareMsg, ToAllNodesMsg { - @Getter private final TenantId tenantId; - @Getter private final EntityId entityId; - @Getter private final ComponentLifecycleEvent event; - public ComponentLifecycleMsg(TenantId tenantId, EntityId entityId, ComponentLifecycleEvent event) { - this.tenantId = tenantId; - this.entityId = entityId; - this.event = event; - } - public Optional getRuleChainId() { return entityId.getEntityType() == EntityType.RULE_CHAIN ? Optional.of((RuleChainId) entityId) : Optional.empty(); } diff --git a/common/message/src/main/java/org/thingsboard/server/common/msg/plugin/RuleNodeUpdatedMsg.java b/common/message/src/main/java/org/thingsboard/server/common/msg/plugin/RuleNodeUpdatedMsg.java index 0a5dfa484f..d912aaa29c 100644 --- a/common/message/src/main/java/org/thingsboard/server/common/msg/plugin/RuleNodeUpdatedMsg.java +++ b/common/message/src/main/java/org/thingsboard/server/common/msg/plugin/RuleNodeUpdatedMsg.java @@ -15,6 +15,7 @@ */ package org.thingsboard.server.common.msg.plugin; +import lombok.EqualsAndHashCode; import lombok.ToString; import org.thingsboard.server.common.data.id.EntityId; import org.thingsboard.server.common.data.id.TenantId; @@ -23,8 +24,11 @@ import org.thingsboard.server.common.msg.MsgType; /** * @author Andrew Shvayka + * This class used only to tell local rule-node actor like 'existing.getSelfActor().tellWithHighPriority(new RuleNodeUpdatedMs( ...' + * Never serialized to/from proto, otherwise you need to change proto mappers in ProtoUtils class */ -@ToString +@ToString(callSuper = true) +@EqualsAndHashCode(callSuper = true) public class RuleNodeUpdatedMsg extends ComponentLifecycleMsg { public RuleNodeUpdatedMsg(TenantId tenantId, EntityId entityId) { From 45fd970898930b91a839fcf4fd7f847f00163454 Mon Sep 17 00:00:00 2001 From: Andrii Shvaika Date: Mon, 18 Sep 2023 12:49:19 +0300 Subject: [PATCH 13/43] Refactoring in progress --- .../DefaultTbRuleEngineConsumerService.java | 201 ++++++++--------- .../queue/TbQueueConsumerLauncher.java | 37 ++++ .../queue/TbQueueConsumerManagerTask.java | 17 ++ .../queue/TbRuleEngineConsumerStats.java | 5 +- .../TbRuleEngineQueueConsumerManager.java | 205 ++++++++++++++++++ .../provider/TbRuleEngineQueueFactory.java | 1 - 6 files changed, 356 insertions(+), 110 deletions(-) create mode 100644 application/src/main/java/org/thingsboard/server/service/queue/TbQueueConsumerLauncher.java create mode 100644 application/src/main/java/org/thingsboard/server/service/queue/TbQueueConsumerManagerTask.java create mode 100644 application/src/main/java/org/thingsboard/server/service/queue/TbRuleEngineQueueConsumerManager.java diff --git a/application/src/main/java/org/thingsboard/server/service/queue/DefaultTbRuleEngineConsumerService.java b/application/src/main/java/org/thingsboard/server/service/queue/DefaultTbRuleEngineConsumerService.java index c715b7b03c..ae04de456b 100644 --- a/application/src/main/java/org/thingsboard/server/service/queue/DefaultTbRuleEngineConsumerService.java +++ b/application/src/main/java/org/thingsboard/server/service/queue/DefaultTbRuleEngineConsumerService.java @@ -5,7 +5,7 @@ * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * - * http://www.apache.org/licenses/LICENSE-2.0 + * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, @@ -68,6 +68,7 @@ import org.thingsboard.server.service.queue.processing.TbRuleEngineSubmitStrateg import org.thingsboard.server.service.queue.processing.TbRuleEngineSubmitStrategyFactory; import org.thingsboard.server.service.rpc.TbRuleEngineDeviceRpcService; import org.thingsboard.server.service.stats.RuleEngineStatisticsService; +import org.threadly.concurrent.wrapper.KeyDistributedExecutor; import javax.annotation.PostConstruct; import javax.annotation.PreDestroy; @@ -116,12 +117,12 @@ public class DefaultTbRuleEngineConsumerService extends AbstractConsumerService< private final QueueService queueService; private final TbQueueProducerProvider producerProvider; private final TbQueueAdmin queueAdmin; - private final ConcurrentMap>> consumers = new ConcurrentHashMap<>(); - private final ConcurrentMap consumerConfigurations = new ConcurrentHashMap<>(); - private final ConcurrentMap consumerStats = new ConcurrentHashMap<>(); - private final ConcurrentMap topicsConsumerPerPartition = new ConcurrentHashMap<>(); - final ExecutorService submitExecutor = Executors.newSingleThreadExecutor(ThingsBoardThreadFactory.forName("tb-rule-engine-consumer-submit")); - final ScheduledExecutorService repartitionExecutor = Executors.newScheduledThreadPool(1, ThingsBoardThreadFactory.forName("tb-rule-engine-consumer-repartition")); + + private final ConcurrentMap consumerMap = new ConcurrentHashMap<>(); + private final ExecutorService consumersExecutor = Executors.newCachedThreadPool(ThingsBoardThreadFactory.forName("tb-rule-engine-consumer")); + private final ExecutorService submitExecutor = Executors.newSingleThreadExecutor(ThingsBoardThreadFactory.forName("tb-rule-engine-consumer-submit")); + private final ScheduledExecutorService repartitionExecutor = Executors.newSingleThreadScheduledExecutor(ThingsBoardThreadFactory.forName("tb-rule-engine-consumer-repartition")); + public DefaultTbRuleEngineConsumerService(TbRuleEngineProcessingStrategyFactory processingStrategyFactory, TbRuleEngineSubmitStrategyFactory submitStrategyFactory, @@ -153,7 +154,7 @@ public class DefaultTbRuleEngineConsumerService extends AbstractConsumerService< @PostConstruct public void init() { - super.init("tb-rule-engine-consumer", "tb-rule-engine-notifications-consumer"); + super.init("tb-rule-engine-notifications-consumer"); // TODO: restore init of the main consumer? List queues = queueService.findAllQueues(); for (Queue configuration : queues) { if (partitionService.isManagedByCurrentService(configuration.getTenantId())) { @@ -163,19 +164,14 @@ public class DefaultTbRuleEngineConsumerService extends AbstractConsumerService< } private void initConsumer(Queue configuration) { - QueueKey queueKey = new QueueKey(ServiceType.TB_RULE_ENGINE, configuration); - consumerConfigurations.putIfAbsent(queueKey, configuration); - consumerStats.putIfAbsent(queueKey, new TbRuleEngineConsumerStats(configuration, statsFactory)); - if (!configuration.isConsumerPerPartition()) { - consumers.computeIfAbsent(queueKey, queueName -> tbRuleEngineQueueFactory.createToRuleEngineMsgConsumer(configuration)); - } else { - topicsConsumerPerPartition.computeIfAbsent(queueKey, k -> new TbTopicWithConsumerPerPartition(k.getQueueName())); - } + consumerMap.computeIfAbsent(new QueueKey(ServiceType.TB_RULE_ENGINE, configuration), + key -> new TbRuleEngineQueueConsumerManager(repartitionExecutor, consumersExecutor, statsFactory, tbRuleEngineQueueFactory, key)).init(configuration); } @PreDestroy public void stop() { super.destroy(); + consumersExecutor.shutdownNow(); // TODO: shutdown or shutdownNow? submitExecutor.shutdownNow(); repartitionExecutor.shutdownNow(); } @@ -183,119 +179,107 @@ public class DefaultTbRuleEngineConsumerService extends AbstractConsumerService< @Override protected void onTbApplicationEvent(PartitionChangeEvent event) { if (event.getServiceType().equals(getServiceType())) { - event.getPartitionsMap().forEach((queueKey, partitions) -> { - String serviceQueue = queueKey.getQueueName(); - log.info("[{}] Subscribing to partitions: {}", serviceQueue, partitions); - Queue configuration = consumerConfigurations.get(queueKey); - if (configuration == null) { - return; - } - if (!configuration.isConsumerPerPartition()) { - consumers.get(queueKey).subscribe(partitions); - } else { - log.info("[{}] Subscribing consumer per partition: {}", serviceQueue, partitions); - subscribeConsumerPerPartition(queueKey, partitions); - } - }); - } - } - - void subscribeConsumerPerPartition(QueueKey queue, Set partitions) { - topicsConsumerPerPartition.get(queue).getSubscribeQueue().add(partitions); - scheduleTopicRepartition(queue); - } - - private void scheduleTopicRepartition(QueueKey queue) { - repartitionExecutor.schedule(() -> repartitionTopicWithConsumerPerPartition(queue), 1, TimeUnit.SECONDS); - } - - void repartitionTopicWithConsumerPerPartition(final QueueKey queueKey) { - if (stopped) { - return; - } - TbTopicWithConsumerPerPartition tbTopicWithConsumerPerPartition = topicsConsumerPerPartition.get(queueKey); - java.util.Queue> subscribeQueue = tbTopicWithConsumerPerPartition.getSubscribeQueue(); - if (subscribeQueue.isEmpty()) { - return; - } - if (tbTopicWithConsumerPerPartition.getLock().tryLock()) { - try { - Set partitions = null; - while (!subscribeQueue.isEmpty()) { - partitions = subscribeQueue.poll(); - } - if (partitions == null) { - return; - } - - Set addedPartitions = new HashSet<>(partitions); - ConcurrentMap>> consumers = tbTopicWithConsumerPerPartition.getConsumers(); - addedPartitions.removeAll(consumers.keySet()); - log.info("calculated addedPartitions {}", addedPartitions); - - Set removedPartitions = new HashSet<>(consumers.keySet()); - removedPartitions.removeAll(partitions); - log.info("calculated removedPartitions {}", removedPartitions); - - removedPartitions.forEach((tpi) -> { - removeConsumerForTopicByTpi(queueKey.getQueueName(), consumers, tpi); - }); - - addedPartitions.forEach((tpi) -> { - log.info("[{}] Adding consumer for topic: {}", queueKey, tpi); - Queue configuration = consumerConfigurations.get(queueKey); - TbQueueConsumer> consumer = tbRuleEngineQueueFactory.createToRuleEngineMsgConsumer(configuration); - consumers.put(tpi, consumer); - launchConsumer(consumer, consumerConfigurations.get(queueKey), consumerStats.get(queueKey), "" + queueKey + "-" + tpi.getPartition().orElse(-999999)); - consumer.subscribe(Collections.singleton(tpi)); - }); - } finally { - tbTopicWithConsumerPerPartition.getLock().unlock(); + var consumer = consumerMap.get(event.getQueueKey()); + if (consumer != null) { + consumer.subscribe(event); + } else { + log.warn("Received invalid partition change event for {} that is not managed by this service", event.getQueueKey()); } - } else { - scheduleTopicRepartition(queueKey); //reschedule later } - } +// void subscribeConsumerPerPartition(QueueKey queue, Set partitions) { +// topicsConsumerPerPartition.get(queue).getSubscribeQueue().add(partitions); +// scheduleTopicRepartition(queue); +// } +// +// private void scheduleTopicRepartition(QueueKey queue) { +// repartitionExecutor.schedule(() -> repartitionTopicWithConsumerPerPartition(queue), 1, TimeUnit.SECONDS); +// } +// +// void repartitionTopicWithConsumerPerPartition(final QueueKey queueKey) { +// if (stopped) { +// return; +// } +// TbTopicWithConsumerPerPartition tbTopicWithConsumerPerPartition = topicsConsumerPerPartition.get(queueKey); +// java.util.Queue> subscribeQueue = tbTopicWithConsumerPerPartition.getSubscribeQueue(); +// if (subscribeQueue.isEmpty()) { +// return; +// } +// if (tbTopicWithConsumerPerPartition.getLock().tryLock()) { +// try { +// Set partitions = null; +// while (!subscribeQueue.isEmpty()) { +// partitions = subscribeQueue.poll(); +// } +// if (partitions == null) { +// return; +// } +// +// Set addedPartitions = new HashSet<>(partitions); +// ConcurrentMap>> consumers = tbTopicWithConsumerPerPartition.getConsumers(); +// addedPartitions.removeAll(consumers.keySet()); +// log.info("calculated addedPartitions {}", addedPartitions); +// +// Set removedPartitions = new HashSet<>(consumers.keySet()); +// removedPartitions.removeAll(partitions); +// log.info("calculated removedPartitions {}", removedPartitions); +// +// removedPartitions.forEach((tpi) -> { +// removeConsumerForTopicByTpi(queueKey.getQueueName(), consumers, tpi); +// }); +// +// addedPartitions.forEach((tpi) -> { +// log.info("[{}] Adding consumer for topic: {}", queueKey, tpi); +// Queue configuration = consumerConfigurations.get(queueKey); +// TbQueueConsumer> consumer = tbRuleEngineQueueFactory.createToRuleEngineMsgConsumer(configuration); +// consumers.put(tpi, consumer); +// launchConsumer(consumer, queueKey, tpi.getFullTopicName(), queueKey + "-" + tpi.getPartition().orElse(-999999)); +// consumer.subscribe(Collections.singleton(tpi)); +// }); +// } finally { +// tbTopicWithConsumerPerPartition.getLock().unlock(); +// } +// } else { +// scheduleTopicRepartition(queueKey); //reschedule later +// } +// } + void removeConsumerForTopicByTpi(String queue, ConcurrentMap>> consumers, TopicPartitionInfo tpi) { log.info("[{}] Removing consumer for topic: {}", queue, tpi); - consumers.get(tpi).unsubscribe(); - consumers.remove(tpi); + consumers.remove(tpi).stop(); } @Override protected void launchMainConsumers() { - consumers.forEach((queue, consumer) -> launchConsumer(consumer, consumerConfigurations.get(queue), consumerStats.get(queue), queue.getQueueName())); + consumers.forEach((queue, consumer) -> launchConsumer(consumer, queue, queue, queue.getQueueName())); } @Override protected void stopMainConsumers() { - consumers.values().forEach(TbQueueConsumer::unsubscribe); - topicsConsumerPerPartition.values().forEach(tbTopicWithConsumerPerPartition -> tbTopicWithConsumerPerPartition.getConsumers().keySet() - .forEach((tpi) -> removeConsumerForTopicByTpi(tbTopicWithConsumerPerPartition.getTopic(), tbTopicWithConsumerPerPartition.getConsumers(), tpi))); + consumerMap.values().forEach(TbRuleEngineQueueConsumerManager::stop); } - void launchConsumer(TbQueueConsumer> consumer, Queue configuration, TbRuleEngineConsumerStats stats, String threadSuffix) { + void launchConsumer(TbQueueConsumer> consumer, QueueKey queueKey, Object consumerKey, String threadSuffix) { if (isReady) { - consumersExecutor.execute(() -> consumerLoop(consumer, configuration, stats, threadSuffix)); + log.info("[{}] Launching consumer", consumerKey); + consumersExecutor.execute(consumerKey, () -> consumerLoop(consumer, queueKey, threadSuffix)); } else { - scheduleLaunchConsumer(consumer, configuration, stats, threadSuffix); + scheduleLaunchConsumer(consumer, queueKey, consumerKey, threadSuffix); } } - private void scheduleLaunchConsumer(TbQueueConsumer> consumer, Queue configuration, TbRuleEngineConsumerStats stats, String threadSuffix) { + private void scheduleLaunchConsumer(TbQueueConsumer> consumer, QueueKey queueKey, Object consumerKey, String threadSuffix) { repartitionExecutor.schedule(() -> { - if (isReady) { - consumersExecutor.execute(() -> consumerLoop(consumer, configuration, stats, threadSuffix)); - } else { - scheduleLaunchConsumer(consumer, configuration, stats, threadSuffix); - } + launchConsumer(consumer, queueKey, consumerKey, threadSuffix); }, 10, TimeUnit.SECONDS); } - void consumerLoop(TbQueueConsumer> consumer, org.thingsboard.server.common.data.queue.Queue configuration, TbRuleEngineConsumerStats stats, String threadSuffix) { + void consumerLoop(TbQueueConsumer> consumer, QueueKey queueKey, String threadSuffix) { + Queue configuration = consumerConfigurations.get(queueKey); + TbRuleEngineConsumerStats stats = consumerStats.get(queueKey); updateCurrentThreadName(threadSuffix); + while (!stopped && !consumer.isStopped() && !consumer.isQueueDeleted()) { try { List> msgs = consumer.poll(configuration.getPollInterval()); @@ -347,7 +331,9 @@ public class DefaultTbRuleEngineConsumerService extends AbstractConsumerService< } } - if (consumer.isQueueDeleted()) { + if (consumer.isStopped()) { + consumer.unsubscribe(); + } else if (consumer.isQueueDeleted()) { processQueueDeletion(configuration, consumer); } log.info("TB Rule Engine Consumer stopped."); @@ -460,20 +446,20 @@ public class DefaultTbRuleEngineConsumerService extends AbstractConsumerService< ReentrantLock lock = consumerPerPartition.getLock(); try { lock.lock(); - consumerPerPartition.getConsumers().values().forEach(TbQueueConsumer::unsubscribe); + consumerPerPartition.getConsumers().values().forEach(TbQueueConsumer::stop); } finally { lock.unlock(); } } else { TbQueueConsumer> consumer = consumers.remove(queueKey); - consumer.unsubscribe(); + consumer.stop(); } } initConsumer(queue); if (!queue.isConsumerPerPartition()) { - launchConsumer(consumers.get(queueKey), consumerConfigurations.get(queueKey), consumerStats.get(queueKey), queueName); + launchConsumer(consumers.get(queueKey), queueKey, queueKey, queueName); } } @@ -502,6 +488,7 @@ public class DefaultTbRuleEngineConsumerService extends AbstractConsumerService< } } } + partitionService.recalculatePartitions(serviceInfoProvider.getServiceInfo(), new ArrayList<>(partitionService.getOtherServices(ServiceType.TB_RULE_ENGINE))); } private void forwardToRuleEngineActor(String queueName, TenantId tenantId, ToRuleEngineMsg toRuleEngineMsg, TbMsgCallback callback) { diff --git a/application/src/main/java/org/thingsboard/server/service/queue/TbQueueConsumerLauncher.java b/application/src/main/java/org/thingsboard/server/service/queue/TbQueueConsumerLauncher.java new file mode 100644 index 0000000000..f5688eb207 --- /dev/null +++ b/application/src/main/java/org/thingsboard/server/service/queue/TbQueueConsumerLauncher.java @@ -0,0 +1,37 @@ +package org.thingsboard.server.service.queue; + +import lombok.Data; +import org.thingsboard.server.common.data.plugin.ComponentLifecycleEvent; +import org.thingsboard.server.common.data.queue.Queue; +import org.thingsboard.server.common.msg.queue.TopicPartitionInfo; +import org.thingsboard.server.gen.transport.TransportProtos; +import org.thingsboard.server.queue.TbQueueConsumer; +import org.thingsboard.server.queue.common.TbProtoQueueMsg; +import org.thingsboard.server.queue.discovery.QueueKey; + +import java.util.Set; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.Future; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; + +@Data +public class TbQueueConsumerLauncher { + + private final TbQueueConsumer> consumer; + private volatile Future task; + + public void stop() { + this.consumer.stop(); + } + + public void awaitStopped() throws ExecutionException, InterruptedException, TimeoutException { + if (task != null) { + this.task.get(3, TimeUnit.MINUTES); + } + } + + public void subscribe(Set partitions) { + this.consumer.subscribe(partitions); + } +} diff --git a/application/src/main/java/org/thingsboard/server/service/queue/TbQueueConsumerManagerTask.java b/application/src/main/java/org/thingsboard/server/service/queue/TbQueueConsumerManagerTask.java new file mode 100644 index 0000000000..11316a9e05 --- /dev/null +++ b/application/src/main/java/org/thingsboard/server/service/queue/TbQueueConsumerManagerTask.java @@ -0,0 +1,17 @@ +package org.thingsboard.server.service.queue; + +import lombok.Data; +import org.thingsboard.server.common.data.plugin.ComponentLifecycleEvent; +import org.thingsboard.server.common.data.queue.Queue; +import org.thingsboard.server.common.msg.queue.TopicPartitionInfo; + +import java.util.Set; + +@Data +public class TbQueueConsumerManagerTask { + + private final ComponentLifecycleEvent event; + private final Queue queue; + private final Set partitions; + +} diff --git a/application/src/main/java/org/thingsboard/server/service/queue/TbRuleEngineConsumerStats.java b/application/src/main/java/org/thingsboard/server/service/queue/TbRuleEngineConsumerStats.java index 2904c299ce..45ccbcf32a 100644 --- a/application/src/main/java/org/thingsboard/server/service/queue/TbRuleEngineConsumerStats.java +++ b/application/src/main/java/org/thingsboard/server/service/queue/TbRuleEngineConsumerStats.java @@ -25,6 +25,7 @@ import org.thingsboard.server.common.stats.StatsFactory; import org.thingsboard.server.common.stats.StatsType; import org.thingsboard.server.gen.transport.TransportProtos.ToRuleEngineMsg; import org.thingsboard.server.queue.common.TbProtoQueueMsg; +import org.thingsboard.server.queue.discovery.QueueKey; import org.thingsboard.server.service.queue.processing.TbRuleEngineProcessingResult; import java.util.ArrayList; @@ -66,8 +67,8 @@ public class TbRuleEngineConsumerStats { private final String queueName; private final TenantId tenantId; - public TbRuleEngineConsumerStats(Queue queue, StatsFactory statsFactory) { - this.queueName = queue.getName(); + public TbRuleEngineConsumerStats(QueueKey queue, StatsFactory statsFactory) { + this.queueName = queue.getQueueName(); this.tenantId = queue.getTenantId(); this.statsFactory = statsFactory; diff --git a/application/src/main/java/org/thingsboard/server/service/queue/TbRuleEngineQueueConsumerManager.java b/application/src/main/java/org/thingsboard/server/service/queue/TbRuleEngineQueueConsumerManager.java new file mode 100644 index 0000000000..2c6d191c0a --- /dev/null +++ b/application/src/main/java/org/thingsboard/server/service/queue/TbRuleEngineQueueConsumerManager.java @@ -0,0 +1,205 @@ +package org.thingsboard.server.service.queue; + +import lombok.Data; +import lombok.extern.slf4j.Slf4j; +import org.thingsboard.server.common.data.plugin.ComponentLifecycleEvent; +import org.thingsboard.server.common.data.queue.Queue; +import org.thingsboard.server.common.msg.queue.TopicPartitionInfo; +import org.thingsboard.server.common.stats.StatsFactory; +import org.thingsboard.server.gen.transport.TransportProtos; +import org.thingsboard.server.queue.TbQueueConsumer; +import org.thingsboard.server.queue.common.TbProtoQueueMsg; +import org.thingsboard.server.queue.discovery.QueueKey; +import org.thingsboard.server.queue.discovery.event.PartitionChangeEvent; +import org.thingsboard.server.queue.provider.TbRuleEngineQueueFactory; + +import java.util.Collections; +import java.util.HashSet; +import java.util.Set; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.ConcurrentLinkedQueue; +import java.util.concurrent.ConcurrentMap; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.ScheduledExecutorService; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.locks.ReentrantLock; + +@Data +@Slf4j +public class TbRuleEngineQueueConsumerManager { + + private final ScheduledExecutorService scheduler; + private final ExecutorService consumerExecutor; + private final StatsFactory statsFactory; + private final TbRuleEngineQueueFactory queueFactory; + private final QueueKey key; + private final ReentrantLock lock = new ReentrantLock(); //NonfairSync + private final ConcurrentMap consumers = new ConcurrentHashMap<>(); + private final TbRuleEngineConsumerStats stats; + + private volatile Set partitions = Collections.emptySet(); + private volatile Queue queue; + private volatile TbQueueConsumerLauncher mainConsumer; + + private final java.util.Queue tasks = new ConcurrentLinkedQueue<>(); + + public TbRuleEngineQueueConsumerManager(ScheduledExecutorService scheduler, ExecutorService consumerExecutor, StatsFactory statsFactory, TbRuleEngineQueueFactory queueFactory, QueueKey key) { + this.scheduler = scheduler; + this.consumerExecutor = consumerExecutor; + this.statsFactory = statsFactory; + this.queueFactory = queueFactory; + this.key = key; + this.stats = new TbRuleEngineConsumerStats(key, statsFactory); + } + + public void init(Queue queue) { + processTask(new TbQueueConsumerManagerTask(ComponentLifecycleEvent.CREATED, queue, null)); + } + + private void processTask(TbQueueConsumerManagerTask todo) { + tasks.add(todo); + log.info("[{}] Adding task: {}", key, todo); + tryProcessTasks(); + } + + private void tryProcessTasks() { + consumerExecutor.submit(() -> { + if (lock.tryLock()) { + try { + TbQueueConsumerManagerTask lastUpdateTask = null; + while (!tasks.isEmpty()) { + TbQueueConsumerManagerTask task = tasks.poll(); + switch (task.getEvent()) { + case CREATED: + doInit(task.getQueue()); + break; + case UPDATED: + lastUpdateTask = task; + break; + case DELETED: + lastUpdateTask = null; + doDelete(); + break; + } + } + if (lastUpdateTask != null) { + doUpdate(lastUpdateTask.getQueue(), lastUpdateTask.getPartitions()); + } + } finally { + lock.unlock(); + } + } else { + log.debug("[{}] Failed to acquire lock.", key); + scheduler.schedule(this::tryProcessTasks, 1, TimeUnit.SECONDS); + } + }); + } + + public void doInit(Queue queue) { + log.info("[{}] Init consumer with queue: {}", key, queue); + this.queue = queue; + if (!queue.isConsumerPerPartition()) { + mainConsumer = new TbQueueConsumerLauncher(queueFactory.createToRuleEngineMsgConsumer(queue)); + } + } + + private void doUpdate(Queue newQueue, Set partitions) { + if (newQueue.isConsumerPerPartition()) { + + } else { + for (var oldConsumer : consumers.values()) { + oldConsumer.stop(); + } + for (var oldConsumer : consumers.entrySet()) { + try { + oldConsumer.getValue().awaitStopped(); + } catch (Exception e) { + log.info("[{}][{}] Failed to stop the consumer during update", key, oldConsumer.getKey().getPartition().orElse(-1), e); + } + } + if (mainConsumer == null) { + mainConsumer = new TbQueueConsumerLauncher(queueFactory.createToRuleEngineMsgConsumer(queue)); + //TODO: launch + } + mainConsumer.subscribe(partitions); + + } + } + + private void doDelete() { + } + + public void subscribe(PartitionChangeEvent event) { + log.info("[{}] Subscribing to partitions: {}", key, event.getPartitions()); + if (!queue.isConsumerPerPartition()) { + mainConsumer.subscribe(event.getPartitions()); + } else { + log.info("[{}] Subscribing consumer per partition: {}", key, event.getPartitions()); + subscribeConsumerPerPartition(event.getQueueKey(), event.getPartitions()); + } + } + + void subscribeConsumerPerPartition(QueueKey queue, Set partitions) { + topicsConsumerPerPartition.get(queue).getSubscribeQueue().add(partitions); + scheduleTopicRepartition(queue); + } + + private void scheduleTopicRepartition(QueueKey queue) { + repartitionExecutor.schedule(() -> repartitionTopicWithConsumerPerPartition(queue), 1, TimeUnit.SECONDS); + } + + void repartitionTopicWithConsumerPerPartition(final QueueKey queueKey) { + if (stopped) { + return; + } + TbTopicWithConsumerPerPartition tbTopicWithConsumerPerPartition = topicsConsumerPerPartition.get(queueKey); + java.util.Queue> subscribeQueue = tbTopicWithConsumerPerPartition.getSubscribeQueue(); + if (subscribeQueue.isEmpty()) { + return; + } + if (tbTopicWithConsumerPerPartition.getLock().tryLock()) { + try { + Set partitions = null; + while (!subscribeQueue.isEmpty()) { + partitions = subscribeQueue.poll(); + } + if (partitions == null) { + return; + } + + Set addedPartitions = new HashSet<>(partitions); + ConcurrentMap>> consumers = tbTopicWithConsumerPerPartition.getConsumers(); + addedPartitions.removeAll(consumers.keySet()); + log.info("calculated addedPartitions {}", addedPartitions); + + Set removedPartitions = new HashSet<>(consumers.keySet()); + removedPartitions.removeAll(partitions); + log.info("calculated removedPartitions {}", removedPartitions); + + removedPartitions.forEach((tpi) -> { + removeConsumerForTopicByTpi(queueKey.getQueueName(), consumers, tpi); + }); + + addedPartitions.forEach((tpi) -> { + log.info("[{}] Adding consumer for topic: {}", queueKey, tpi); + Queue configuration = consumerConfigurations.get(queueKey); + TbQueueConsumer> consumer = tbRuleEngineQueueFactory.createToRuleEngineMsgConsumer(configuration); + consumers.put(tpi, consumer); + launchConsumer(consumer, queueKey, tpi.getFullTopicName(), queueKey + "-" + tpi.getPartition().orElse(-999999)); + consumer.subscribe(Collections.singleton(tpi)); + }); + } finally { + tbTopicWithConsumerPerPartition.getLock().unlock(); + } + } else { + scheduleTopicRepartition(queueKey); //reschedule later + } + } + + public void stop() { +// consumers.values().forEach(TbQueueConsumer::stop); +// topicsConsumerPerPartition.values().forEach(tbTopicWithConsumerPerPartition -> tbTopicWithConsumerPerPartition.getConsumers().keySet() +// .forEach((tpi) -> removeConsumerForTopicByTpi(tbTopicWithConsumerPerPartition.getTopic(), tbTopicWithConsumerPerPartition.getConsumers(), tpi))); + } + +} diff --git a/common/queue/src/main/java/org/thingsboard/server/queue/provider/TbRuleEngineQueueFactory.java b/common/queue/src/main/java/org/thingsboard/server/queue/provider/TbRuleEngineQueueFactory.java index 386447045d..bb1943a7d5 100644 --- a/common/queue/src/main/java/org/thingsboard/server/queue/provider/TbRuleEngineQueueFactory.java +++ b/common/queue/src/main/java/org/thingsboard/server/queue/provider/TbRuleEngineQueueFactory.java @@ -82,7 +82,6 @@ public interface TbRuleEngineQueueFactory extends TbUsageStatsClientQueueFactory * @return * @param configuration */ - //TODO 2.5 ybondarenko: make sure you use queueName to distinct consumers where necessary TbQueueConsumer> createToRuleEngineMsgConsumer(Queue configuration); /** From 3a0afd8a5ab9e5ed518da6bc1f63f909695875c7 Mon Sep 17 00:00:00 2001 From: Andrii Shvaika Date: Mon, 2 Oct 2023 18:51:03 +0300 Subject: [PATCH 14/43] Refactoring of the consumer service --- .../DefaultTbRuleEngineConsumerService.java | 426 ++--------------- .../queue/TbQueueConsumerLauncher.java | 37 -- .../queue/TbQueueConsumerManagerTask.java | 17 - .../TbRuleEngineQueueConsumerManager.java | 205 --------- .../service/queue/ruleengine/QueueEvent.java | 9 + .../TbQueueConsumerManagerTask.java | 32 ++ .../queue/ruleengine/TbQueueConsumerTask.java | 70 +++ .../TbRuleEngineConsumerContext.java | 75 +++ .../TbRuleEngineQueueConsumerManager.java | 431 ++++++++++++++++++ .../common/util/ThingsBoardThreadFactory.java | 12 + 10 files changed, 659 insertions(+), 655 deletions(-) delete mode 100644 application/src/main/java/org/thingsboard/server/service/queue/TbQueueConsumerLauncher.java delete mode 100644 application/src/main/java/org/thingsboard/server/service/queue/TbQueueConsumerManagerTask.java delete mode 100644 application/src/main/java/org/thingsboard/server/service/queue/TbRuleEngineQueueConsumerManager.java create mode 100644 application/src/main/java/org/thingsboard/server/service/queue/ruleengine/QueueEvent.java create mode 100644 application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbQueueConsumerManagerTask.java create mode 100644 application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbQueueConsumerTask.java create mode 100644 application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbRuleEngineConsumerContext.java create mode 100644 application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbRuleEngineQueueConsumerManager.java diff --git a/application/src/main/java/org/thingsboard/server/service/queue/DefaultTbRuleEngineConsumerService.java b/application/src/main/java/org/thingsboard/server/service/queue/DefaultTbRuleEngineConsumerService.java index ae04de456b..b37e5abff3 100644 --- a/application/src/main/java/org/thingsboard/server/service/queue/DefaultTbRuleEngineConsumerService.java +++ b/application/src/main/java/org/thingsboard/server/service/queue/DefaultTbRuleEngineConsumerService.java @@ -15,44 +15,25 @@ */ package org.thingsboard.server.service.queue; -import com.google.protobuf.ProtocolStringList; import lombok.extern.slf4j.Slf4j; -import org.springframework.beans.factory.annotation.Value; import org.springframework.context.ApplicationEventPublisher; import org.springframework.scheduling.annotation.Scheduled; import org.springframework.stereotype.Service; -import org.thingsboard.common.util.ThingsBoardThreadFactory; import org.thingsboard.server.actors.ActorSystemContext; -import org.thingsboard.server.common.data.id.EntityId; -import org.thingsboard.server.common.data.id.EntityIdFactory; import org.thingsboard.server.common.data.id.QueueId; import org.thingsboard.server.common.data.id.TenantId; import org.thingsboard.server.common.data.queue.Queue; import org.thingsboard.server.common.data.rpc.RpcError; -import org.thingsboard.server.common.msg.TbMsg; -import org.thingsboard.server.common.msg.gen.MsgProtos; -import org.thingsboard.server.common.msg.queue.QueueToRuleEngineMsg; -import org.thingsboard.server.common.msg.queue.RuleEngineException; -import org.thingsboard.server.common.msg.queue.RuleNodeInfo; import org.thingsboard.server.common.msg.queue.ServiceType; import org.thingsboard.server.common.msg.queue.TbCallback; -import org.thingsboard.server.common.msg.queue.TbMsgCallback; -import org.thingsboard.server.common.msg.queue.TopicPartitionInfo; import org.thingsboard.server.common.msg.rpc.FromDeviceRpcResponse; -import org.thingsboard.server.common.stats.StatsFactory; -import org.thingsboard.server.dao.queue.QueueService; import org.thingsboard.server.dao.tenant.TbTenantProfileCache; import org.thingsboard.server.gen.transport.TransportProtos; -import org.thingsboard.server.gen.transport.TransportProtos.ToRuleEngineMsg; import org.thingsboard.server.gen.transport.TransportProtos.ToRuleEngineNotificationMsg; -import org.thingsboard.server.queue.TbQueueAdmin; -import org.thingsboard.server.queue.TbQueueConsumer; import org.thingsboard.server.queue.common.TbProtoQueueMsg; import org.thingsboard.server.queue.discovery.PartitionService; import org.thingsboard.server.queue.discovery.QueueKey; -import org.thingsboard.server.queue.discovery.TbServiceInfoProvider; import org.thingsboard.server.queue.discovery.event.PartitionChangeEvent; -import org.thingsboard.server.queue.provider.TbQueueProducerProvider; import org.thingsboard.server.queue.provider.TbRuleEngineQueueFactory; import org.thingsboard.server.queue.util.DataDecodingEncodingService; import org.thingsboard.server.queue.util.TbRuleEngineComponent; @@ -60,102 +41,48 @@ import org.thingsboard.server.service.apiusage.TbApiUsageStateService; import org.thingsboard.server.service.profile.TbAssetProfileCache; import org.thingsboard.server.service.profile.TbDeviceProfileCache; import org.thingsboard.server.service.queue.processing.AbstractConsumerService; -import org.thingsboard.server.service.queue.processing.TbRuleEngineProcessingDecision; -import org.thingsboard.server.service.queue.processing.TbRuleEngineProcessingResult; -import org.thingsboard.server.service.queue.processing.TbRuleEngineProcessingStrategy; -import org.thingsboard.server.service.queue.processing.TbRuleEngineProcessingStrategyFactory; -import org.thingsboard.server.service.queue.processing.TbRuleEngineSubmitStrategy; -import org.thingsboard.server.service.queue.processing.TbRuleEngineSubmitStrategyFactory; +import org.thingsboard.server.service.queue.ruleengine.TbRuleEngineConsumerContext; +import org.thingsboard.server.service.queue.ruleengine.TbRuleEngineQueueConsumerManager; import org.thingsboard.server.service.rpc.TbRuleEngineDeviceRpcService; -import org.thingsboard.server.service.stats.RuleEngineStatisticsService; -import org.threadly.concurrent.wrapper.KeyDistributedExecutor; import javax.annotation.PostConstruct; -import javax.annotation.PreDestroy; import java.util.ArrayList; -import java.util.Collections; -import java.util.HashSet; import java.util.List; -import java.util.Map; import java.util.Optional; -import java.util.Set; import java.util.UUID; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentMap; -import java.util.concurrent.ExecutorService; -import java.util.concurrent.Executors; -import java.util.concurrent.ScheduledExecutorService; -import java.util.concurrent.TimeUnit; -import java.util.concurrent.locks.ReentrantLock; @Service @TbRuleEngineComponent @Slf4j public class DefaultTbRuleEngineConsumerService extends AbstractConsumerService implements TbRuleEngineConsumerService { - public static final String SUCCESSFUL_STATUS = "successful"; - public static final String FAILED_STATUS = "failed"; - public static final String THREAD_TOPIC_SEPARATOR = " | "; - @Value("${queue.rule-engine.poll-interval}") - private long pollDuration; - @Value("${queue.rule-engine.pack-processing-timeout}") - private long packProcessingTimeout; - @Value("${queue.rule-engine.stats.enabled:true}") - private boolean statsEnabled; - @Value("${queue.rule-engine.prometheus-stats.enabled:false}") - boolean prometheusStatsEnabled; - @Value("${queue.rule-engine.topic-deletion-delay:30}") - private int topicDeletionDelayInSec; - - private final StatsFactory statsFactory; - private final TbRuleEngineSubmitStrategyFactory submitStrategyFactory; - private final TbRuleEngineProcessingStrategyFactory processingStrategyFactory; - private final TbRuleEngineQueueFactory tbRuleEngineQueueFactory; - private final RuleEngineStatisticsService statisticsService; + private final TbRuleEngineConsumerContext ctx; private final TbRuleEngineDeviceRpcService tbDeviceRpcService; - private final TbServiceInfoProvider serviceInfoProvider; - private final QueueService queueService; - private final TbQueueProducerProvider producerProvider; - private final TbQueueAdmin queueAdmin; - - private final ConcurrentMap consumerMap = new ConcurrentHashMap<>(); - private final ExecutorService consumersExecutor = Executors.newCachedThreadPool(ThingsBoardThreadFactory.forName("tb-rule-engine-consumer")); - private final ExecutorService submitExecutor = Executors.newSingleThreadExecutor(ThingsBoardThreadFactory.forName("tb-rule-engine-consumer-submit")); - private final ScheduledExecutorService repartitionExecutor = Executors.newSingleThreadScheduledExecutor(ThingsBoardThreadFactory.forName("tb-rule-engine-consumer-repartition")); + private final ConcurrentMap consumers = new ConcurrentHashMap<>(); - public DefaultTbRuleEngineConsumerService(TbRuleEngineProcessingStrategyFactory processingStrategyFactory, - TbRuleEngineSubmitStrategyFactory submitStrategyFactory, + public DefaultTbRuleEngineConsumerService(TbRuleEngineConsumerContext ctx, TbRuleEngineQueueFactory tbRuleEngineQueueFactory, - RuleEngineStatisticsService statisticsService, ActorSystemContext actorContext, DataDecodingEncodingService encodingService, TbRuleEngineDeviceRpcService tbDeviceRpcService, - StatsFactory statsFactory, TbDeviceProfileCache deviceProfileCache, TbAssetProfileCache assetProfileCache, TbTenantProfileCache tenantProfileCache, TbApiUsageStateService apiUsageStateService, - PartitionService partitionService, ApplicationEventPublisher eventPublisher, - TbServiceInfoProvider serviceInfoProvider, QueueService queueService, - TbQueueProducerProvider producerProvider, TbQueueAdmin queueAdmin) { - super(actorContext, encodingService, tenantProfileCache, deviceProfileCache, assetProfileCache, apiUsageStateService, partitionService, eventPublisher, tbRuleEngineQueueFactory.createToRuleEngineNotificationsMsgConsumer(), Optional.empty()); - this.statisticsService = statisticsService; - this.tbRuleEngineQueueFactory = tbRuleEngineQueueFactory; - this.submitStrategyFactory = submitStrategyFactory; - this.processingStrategyFactory = processingStrategyFactory; + PartitionService partitionService, ApplicationEventPublisher eventPublisher) { + super(actorContext, encodingService, tenantProfileCache, deviceProfileCache, assetProfileCache, apiUsageStateService, partitionService, + eventPublisher, tbRuleEngineQueueFactory.createToRuleEngineNotificationsMsgConsumer(), Optional.empty()); + this.ctx = ctx; this.tbDeviceRpcService = tbDeviceRpcService; - this.statsFactory = statsFactory; - this.serviceInfoProvider = serviceInfoProvider; - this.queueService = queueService; - this.producerProvider = producerProvider; - this.queueAdmin = queueAdmin; } @PostConstruct public void init() { super.init("tb-rule-engine-notifications-consumer"); // TODO: restore init of the main consumer? - List queues = queueService.findAllQueues(); + List queues = ctx.findAllQueues(); for (Queue configuration : queues) { if (partitionService.isManagedByCurrentService(configuration.getTenantId())) { initConsumer(configuration); @@ -164,22 +91,14 @@ public class DefaultTbRuleEngineConsumerService extends AbstractConsumerService< } private void initConsumer(Queue configuration) { - consumerMap.computeIfAbsent(new QueueKey(ServiceType.TB_RULE_ENGINE, configuration), - key -> new TbRuleEngineQueueConsumerManager(repartitionExecutor, consumersExecutor, statsFactory, tbRuleEngineQueueFactory, key)).init(configuration); - } - - @PreDestroy - public void stop() { - super.destroy(); - consumersExecutor.shutdownNow(); // TODO: shutdown or shutdownNow? - submitExecutor.shutdownNow(); - repartitionExecutor.shutdownNow(); + consumers.computeIfAbsent(new QueueKey(ServiceType.TB_RULE_ENGINE, configuration), + key -> new TbRuleEngineQueueConsumerManager(ctx, key)).init(configuration); } @Override protected void onTbApplicationEvent(PartitionChangeEvent event) { if (event.getServiceType().equals(getServiceType())) { - var consumer = consumerMap.get(event.getQueueKey()); + var consumer = consumers.get(event.getQueueKey()); if (consumer != null) { consumer.subscribe(event); } else { @@ -188,207 +107,14 @@ public class DefaultTbRuleEngineConsumerService extends AbstractConsumerService< } } -// void subscribeConsumerPerPartition(QueueKey queue, Set partitions) { -// topicsConsumerPerPartition.get(queue).getSubscribeQueue().add(partitions); -// scheduleTopicRepartition(queue); -// } -// -// private void scheduleTopicRepartition(QueueKey queue) { -// repartitionExecutor.schedule(() -> repartitionTopicWithConsumerPerPartition(queue), 1, TimeUnit.SECONDS); -// } -// -// void repartitionTopicWithConsumerPerPartition(final QueueKey queueKey) { -// if (stopped) { -// return; -// } -// TbTopicWithConsumerPerPartition tbTopicWithConsumerPerPartition = topicsConsumerPerPartition.get(queueKey); -// java.util.Queue> subscribeQueue = tbTopicWithConsumerPerPartition.getSubscribeQueue(); -// if (subscribeQueue.isEmpty()) { -// return; -// } -// if (tbTopicWithConsumerPerPartition.getLock().tryLock()) { -// try { -// Set partitions = null; -// while (!subscribeQueue.isEmpty()) { -// partitions = subscribeQueue.poll(); -// } -// if (partitions == null) { -// return; -// } -// -// Set addedPartitions = new HashSet<>(partitions); -// ConcurrentMap>> consumers = tbTopicWithConsumerPerPartition.getConsumers(); -// addedPartitions.removeAll(consumers.keySet()); -// log.info("calculated addedPartitions {}", addedPartitions); -// -// Set removedPartitions = new HashSet<>(consumers.keySet()); -// removedPartitions.removeAll(partitions); -// log.info("calculated removedPartitions {}", removedPartitions); -// -// removedPartitions.forEach((tpi) -> { -// removeConsumerForTopicByTpi(queueKey.getQueueName(), consumers, tpi); -// }); -// -// addedPartitions.forEach((tpi) -> { -// log.info("[{}] Adding consumer for topic: {}", queueKey, tpi); -// Queue configuration = consumerConfigurations.get(queueKey); -// TbQueueConsumer> consumer = tbRuleEngineQueueFactory.createToRuleEngineMsgConsumer(configuration); -// consumers.put(tpi, consumer); -// launchConsumer(consumer, queueKey, tpi.getFullTopicName(), queueKey + "-" + tpi.getPartition().orElse(-999999)); -// consumer.subscribe(Collections.singleton(tpi)); -// }); -// } finally { -// tbTopicWithConsumerPerPartition.getLock().unlock(); -// } -// } else { -// scheduleTopicRepartition(queueKey); //reschedule later -// } -// } - - void removeConsumerForTopicByTpi(String queue, ConcurrentMap>> consumers, TopicPartitionInfo tpi) { - log.info("[{}] Removing consumer for topic: {}", queue, tpi); - consumers.remove(tpi).stop(); - } - @Override protected void launchMainConsumers() { - consumers.forEach((queue, consumer) -> launchConsumer(consumer, queue, queue, queue.getQueueName())); + consumers.values().forEach(TbRuleEngineQueueConsumerManager::launchMainConsumer); } @Override protected void stopMainConsumers() { - consumerMap.values().forEach(TbRuleEngineQueueConsumerManager::stop); - } - - void launchConsumer(TbQueueConsumer> consumer, QueueKey queueKey, Object consumerKey, String threadSuffix) { - if (isReady) { - log.info("[{}] Launching consumer", consumerKey); - consumersExecutor.execute(consumerKey, () -> consumerLoop(consumer, queueKey, threadSuffix)); - } else { - scheduleLaunchConsumer(consumer, queueKey, consumerKey, threadSuffix); - } - } - - private void scheduleLaunchConsumer(TbQueueConsumer> consumer, QueueKey queueKey, Object consumerKey, String threadSuffix) { - repartitionExecutor.schedule(() -> { - launchConsumer(consumer, queueKey, consumerKey, threadSuffix); - }, 10, TimeUnit.SECONDS); - } - - void consumerLoop(TbQueueConsumer> consumer, QueueKey queueKey, String threadSuffix) { - Queue configuration = consumerConfigurations.get(queueKey); - TbRuleEngineConsumerStats stats = consumerStats.get(queueKey); - updateCurrentThreadName(threadSuffix); - - while (!stopped && !consumer.isStopped() && !consumer.isQueueDeleted()) { - try { - List> msgs = consumer.poll(configuration.getPollInterval()); - if (msgs.isEmpty()) { - continue; - } - final TbRuleEngineSubmitStrategy submitStrategy = getSubmitStrategy(configuration); - final TbRuleEngineProcessingStrategy ackStrategy = getAckStrategy(configuration); - submitStrategy.init(msgs); - while (!stopped && !consumer.isStopped()) { - TbMsgPackProcessingContext ctx = new TbMsgPackProcessingContext(configuration.getName(), submitStrategy, ackStrategy.isSkipTimeoutMsgs()); - submitStrategy.submitAttempt((id, msg) -> submitExecutor.submit(() -> submitMessage(configuration, stats, ctx, id, msg))); - - final boolean timeout = !ctx.await(configuration.getPackProcessingTimeout(), TimeUnit.MILLISECONDS); - - TbRuleEngineProcessingResult result = new TbRuleEngineProcessingResult(configuration.getName(), timeout, ctx); - if (timeout) { - printFirstOrAll(configuration, ctx, ctx.getPendingMap(), "Timeout"); - } - if (!ctx.getFailedMap().isEmpty()) { - printFirstOrAll(configuration, ctx, ctx.getFailedMap(), "Failed"); - } - ctx.printProfilerStats(); - - TbRuleEngineProcessingDecision decision = ackStrategy.analyze(result); - if (statsEnabled) { - stats.log(result, decision.isCommit()); - } - - ctx.cleanup(); - - if (decision.isCommit()) { - submitStrategy.stop(); - break; - } else { - submitStrategy.update(decision.getReprocessMap()); - } - } - consumer.commit(); - } catch (Exception e) { - if (!stopped) { - log.warn("Failed to process messages from queue.", e); - try { - Thread.sleep(pollDuration); - } catch (InterruptedException e2) { - log.trace("Failed to wait until the server has capacity to handle new requests", e2); - } - } - } - } - - if (consumer.isStopped()) { - consumer.unsubscribe(); - } else if (consumer.isQueueDeleted()) { - processQueueDeletion(configuration, consumer); - } - log.info("TB Rule Engine Consumer stopped."); - } - - void updateCurrentThreadName(String threadSuffix) { - String name = Thread.currentThread().getName(); - int spliteratorIndex = name.indexOf(THREAD_TOPIC_SEPARATOR); - if (spliteratorIndex > 0) { - name = name.substring(0, spliteratorIndex); - } - name = name + THREAD_TOPIC_SEPARATOR + threadSuffix; - Thread.currentThread().setName(name); - } - - TbRuleEngineProcessingStrategy getAckStrategy(Queue configuration) { - return processingStrategyFactory.newInstance(configuration.getName(), configuration.getProcessingStrategy()); - } - - TbRuleEngineSubmitStrategy getSubmitStrategy(Queue configuration) { - return submitStrategyFactory.newInstance(configuration.getName(), configuration.getSubmitStrategy()); - } - - void submitMessage(Queue configuration, TbRuleEngineConsumerStats stats, TbMsgPackProcessingContext ctx, UUID id, TbProtoQueueMsg msg) { - log.trace("[{}] Creating callback for topic {} message: {}", id, configuration.getName(), msg.getValue()); - ToRuleEngineMsg toRuleEngineMsg = msg.getValue(); - TenantId tenantId = TenantId.fromUUID(new UUID(toRuleEngineMsg.getTenantIdMSB(), toRuleEngineMsg.getTenantIdLSB())); - TbMsgCallback callback = prometheusStatsEnabled ? - new TbMsgPackCallback(id, tenantId, ctx, stats.getTimer(tenantId, SUCCESSFUL_STATUS), stats.getTimer(tenantId, FAILED_STATUS)) : - new TbMsgPackCallback(id, tenantId, ctx); - try { - if (toRuleEngineMsg.getTbMsg() != null && !toRuleEngineMsg.getTbMsg().isEmpty()) { - forwardToRuleEngineActor(configuration.getName(), tenantId, toRuleEngineMsg, callback); - } else { - callback.onSuccess(); - } - } catch (Exception e) { - callback.onFailure(new RuleEngineException(e.getMessage(), e)); - } - } - - private void printFirstOrAll(Queue configuration, TbMsgPackProcessingContext ctx, Map> map, String prefix) { - boolean printAll = log.isTraceEnabled(); - log.info("{} to process [{}] messages", prefix, map.size()); - for (Map.Entry> pending : map.entrySet()) { - ToRuleEngineMsg tmp = pending.getValue().getValue(); - TbMsg tmpMsg = TbMsg.fromBytes(configuration.getName(), tmp.getTbMsg().toByteArray(), TbMsgCallback.EMPTY); - RuleNodeInfo ruleNodeInfo = ctx.getLastVisitedRuleNode(pending.getKey()); - if (printAll) { - log.trace("[{}] {} to process message: {}, Last Rule Node: {}", TenantId.fromUUID(new UUID(tmp.getTenantIdMSB(), tmp.getTenantIdLSB())), prefix, tmpMsg, ruleNodeInfo); - } else { - log.info("[{}] {} to process message: {}, Last Rule Node: {}", TenantId.fromUUID(new UUID(tmp.getTenantIdMSB(), tmp.getTenantIdLSB())), prefix, tmpMsg, ruleNodeInfo); - break; - } - } + consumers.values().forEach(TbRuleEngineQueueConsumerManager::stop); } @Override @@ -398,18 +124,18 @@ public class DefaultTbRuleEngineConsumerService extends AbstractConsumerService< @Override protected long getNotificationPollDuration() { - return pollDuration; + return ctx.getPollDuration(); } @Override protected long getNotificationPackProcessingTimeout() { - return packProcessingTimeout; + return ctx.getPackProcessingTimeout(); } @Override protected void handleNotification(UUID id, TbProtoQueueMsg msg, TbCallback callback) throws Exception { ToRuleEngineNotificationMsg nfMsg = msg.getValue(); - if (nfMsg.getComponentLifecycleMsg() != null && !nfMsg.getComponentLifecycleMsg().isEmpty()) { + if (!nfMsg.getComponentLifecycleMsg().isEmpty()) { handleComponentLifecycleMsg(id, nfMsg.getComponentLifecycleMsg()); callback.onSuccess(); } else if (nfMsg.hasFromDeviceRpcResponse()) { @@ -420,10 +146,10 @@ public class DefaultTbRuleEngineConsumerService extends AbstractConsumerService< tbDeviceRpcService.processRpcResponseFromDevice(response); callback.onSuccess(); } else if (nfMsg.hasQueueUpdateMsg()) { - repartitionExecutor.execute(() -> updateQueue(nfMsg.getQueueUpdateMsg())); + ctx.getScheduler().execute(() -> updateQueue(nfMsg.getQueueUpdateMsg())); callback.onSuccess(); } else if (nfMsg.hasQueueDeleteMsg()) { - repartitionExecutor.execute(() -> deleteQueue(nfMsg.getQueueDeleteMsg())); + ctx.getScheduler().execute(() -> deleteQueue(nfMsg.getQueueDeleteMsg())); callback.onSuccess(); } else { log.trace("Received notification with missing handler"); @@ -438,33 +164,13 @@ public class DefaultTbRuleEngineConsumerService extends AbstractConsumerService< QueueId queueId = new QueueId(new UUID(queueUpdateMsg.getQueueIdMSB(), queueUpdateMsg.getQueueIdLSB())); String queueName = queueUpdateMsg.getQueueName(); QueueKey queueKey = new QueueKey(ServiceType.TB_RULE_ENGINE, queueName, tenantId); - Queue queue = queueService.findQueueById(tenantId, queueId); - Queue oldQueue = consumerConfigurations.remove(queueKey); - if (oldQueue != null) { - if (oldQueue.isConsumerPerPartition()) { - TbTopicWithConsumerPerPartition consumerPerPartition = topicsConsumerPerPartition.remove(queueKey); - ReentrantLock lock = consumerPerPartition.getLock(); - try { - lock.lock(); - consumerPerPartition.getConsumers().values().forEach(TbQueueConsumer::stop); - } finally { - lock.unlock(); - } - } else { - TbQueueConsumer> consumer = consumers.remove(queueKey); - consumer.stop(); - } - } - - initConsumer(queue); - - if (!queue.isConsumerPerPartition()) { - launchConsumer(consumers.get(queueKey), queueKey, queueKey, queueName); - } + Queue queue = ctx.getQueueService().findQueueById(tenantId, queueId); + consumers.computeIfAbsent(queueKey, key -> new TbRuleEngineQueueConsumerManager(ctx, key)).update(queue); } partitionService.updateQueue(queueUpdateMsg); - partitionService.recalculatePartitions(serviceInfoProvider.getServiceInfo(), new ArrayList<>(partitionService.getOtherServices(ServiceType.TB_RULE_ENGINE))); + partitionService.recalculatePartitions(ctx.getServiceInfoProvider().getServiceInfo(), + new ArrayList<>(partitionService.getOtherServices(ServiceType.TB_RULE_ENGINE))); } private void deleteQueue(TransportProtos.QueueDeleteMsg queueDeleteMsg) { @@ -473,90 +179,18 @@ public class DefaultTbRuleEngineConsumerService extends AbstractConsumerService< QueueKey queueKey = new QueueKey(ServiceType.TB_RULE_ENGINE, queueDeleteMsg.getQueueName(), tenantId); partitionService.removeQueue(queueDeleteMsg); - Queue queue = consumerConfigurations.remove(queueKey); - if (queue != null) { - if (queue.isConsumerPerPartition()) { - TbTopicWithConsumerPerPartition tbTopicWithConsumerPerPartition = topicsConsumerPerPartition.remove(queueKey); - if (tbTopicWithConsumerPerPartition != null) { - tbTopicWithConsumerPerPartition.getConsumers().values().forEach(TbQueueConsumer::onQueueDelete); - tbTopicWithConsumerPerPartition.getConsumers().clear(); - } - } else { - TbQueueConsumer> consumer = consumers.remove(queueKey); - if (consumer != null) { - consumer.onQueueDelete(); - } - } - } - partitionService.recalculatePartitions(serviceInfoProvider.getServiceInfo(), new ArrayList<>(partitionService.getOtherServices(ServiceType.TB_RULE_ENGINE))); - } - - private void forwardToRuleEngineActor(String queueName, TenantId tenantId, ToRuleEngineMsg toRuleEngineMsg, TbMsgCallback callback) { - TbMsg tbMsg = TbMsg.fromBytes(queueName, toRuleEngineMsg.getTbMsg().toByteArray(), callback); - QueueToRuleEngineMsg msg; - ProtocolStringList relationTypesList = toRuleEngineMsg.getRelationTypesList(); - Set relationTypes = null; - if (relationTypesList != null) { - if (relationTypesList.size() == 1) { - relationTypes = Collections.singleton(relationTypesList.get(0)); - } else { - relationTypes = new HashSet<>(relationTypesList); - } - } - msg = new QueueToRuleEngineMsg(tenantId, tbMsg, relationTypes, toRuleEngineMsg.getFailureMessage()); - actorContext.tell(msg); - } - - private void processQueueDeletion(Queue queue, TbQueueConsumer> consumer) { - long finishTs = System.currentTimeMillis() + TimeUnit.SECONDS.toMillis(topicDeletionDelayInSec); - try { - int n = 0; - while (System.currentTimeMillis() <= finishTs) { - List> msgs = consumer.poll(queue.getPollInterval()); - if (msgs.isEmpty()) { - continue; - } - for (TbProtoQueueMsg msg : msgs) { - try { - MsgProtos.TbMsgProto tbMsgProto = MsgProtos.TbMsgProto.parseFrom(msg.getValue().getTbMsg().toByteArray()); - EntityId originator = EntityIdFactory.getByTypeAndUuid(tbMsgProto.getEntityType(), new UUID(tbMsgProto.getEntityIdMSB(), tbMsgProto.getEntityIdLSB())); - - TopicPartitionInfo tpi = partitionService.resolve(ServiceType.TB_RULE_ENGINE, queue.getName(), TenantId.SYS_TENANT_ID, originator); - producerProvider.getRuleEngineMsgProducer().send(tpi, msg, null); - n++; - } catch (Throwable e) { - log.debug("Failed to move message to system {}: {}", consumer.getTopic(), msg, e); - } - } - consumer.commit(); - } - if (n > 0) { - log.info("Moved {} messages from {} to system {}", n, consumer.getFullTopicNames(), consumer.getTopic()); - } - - consumer.unsubscribe(); - for (String topic : consumer.getFullTopicNames()) { - try { - queueAdmin.deleteTopic(topic); - log.info("Deleted topic {}", topic); - } catch (Exception e) { - log.error("Failed to delete topic {} after unsubscribing", topic, e); - } - } - } catch (Exception e) { - log.error("Failed to process deletion of {} ({})", consumer.getTopic(), queue.getTenantId(), e); + var manager = consumers.remove(queueKey); + if (manager != null) { + manager.delete(); } + partitionService.recalculatePartitions(ctx.getServiceInfoProvider().getServiceInfo(), new ArrayList<>(partitionService.getOtherServices(ServiceType.TB_RULE_ENGINE))); } @Scheduled(fixedDelayString = "${queue.rule-engine.stats.print-interval-ms}") public void printStats() { - if (statsEnabled) { + if (ctx.isStatsEnabled()) { long ts = System.currentTimeMillis(); - consumerStats.forEach((queue, stats) -> { - stats.printStats(); - statisticsService.reportQueueStats(ts, stats); - stats.reset(); - }); + consumers.values().forEach(manager -> manager.printStats(ts)); } } diff --git a/application/src/main/java/org/thingsboard/server/service/queue/TbQueueConsumerLauncher.java b/application/src/main/java/org/thingsboard/server/service/queue/TbQueueConsumerLauncher.java deleted file mode 100644 index f5688eb207..0000000000 --- a/application/src/main/java/org/thingsboard/server/service/queue/TbQueueConsumerLauncher.java +++ /dev/null @@ -1,37 +0,0 @@ -package org.thingsboard.server.service.queue; - -import lombok.Data; -import org.thingsboard.server.common.data.plugin.ComponentLifecycleEvent; -import org.thingsboard.server.common.data.queue.Queue; -import org.thingsboard.server.common.msg.queue.TopicPartitionInfo; -import org.thingsboard.server.gen.transport.TransportProtos; -import org.thingsboard.server.queue.TbQueueConsumer; -import org.thingsboard.server.queue.common.TbProtoQueueMsg; -import org.thingsboard.server.queue.discovery.QueueKey; - -import java.util.Set; -import java.util.concurrent.ExecutionException; -import java.util.concurrent.Future; -import java.util.concurrent.TimeUnit; -import java.util.concurrent.TimeoutException; - -@Data -public class TbQueueConsumerLauncher { - - private final TbQueueConsumer> consumer; - private volatile Future task; - - public void stop() { - this.consumer.stop(); - } - - public void awaitStopped() throws ExecutionException, InterruptedException, TimeoutException { - if (task != null) { - this.task.get(3, TimeUnit.MINUTES); - } - } - - public void subscribe(Set partitions) { - this.consumer.subscribe(partitions); - } -} diff --git a/application/src/main/java/org/thingsboard/server/service/queue/TbQueueConsumerManagerTask.java b/application/src/main/java/org/thingsboard/server/service/queue/TbQueueConsumerManagerTask.java deleted file mode 100644 index 11316a9e05..0000000000 --- a/application/src/main/java/org/thingsboard/server/service/queue/TbQueueConsumerManagerTask.java +++ /dev/null @@ -1,17 +0,0 @@ -package org.thingsboard.server.service.queue; - -import lombok.Data; -import org.thingsboard.server.common.data.plugin.ComponentLifecycleEvent; -import org.thingsboard.server.common.data.queue.Queue; -import org.thingsboard.server.common.msg.queue.TopicPartitionInfo; - -import java.util.Set; - -@Data -public class TbQueueConsumerManagerTask { - - private final ComponentLifecycleEvent event; - private final Queue queue; - private final Set partitions; - -} diff --git a/application/src/main/java/org/thingsboard/server/service/queue/TbRuleEngineQueueConsumerManager.java b/application/src/main/java/org/thingsboard/server/service/queue/TbRuleEngineQueueConsumerManager.java deleted file mode 100644 index 2c6d191c0a..0000000000 --- a/application/src/main/java/org/thingsboard/server/service/queue/TbRuleEngineQueueConsumerManager.java +++ /dev/null @@ -1,205 +0,0 @@ -package org.thingsboard.server.service.queue; - -import lombok.Data; -import lombok.extern.slf4j.Slf4j; -import org.thingsboard.server.common.data.plugin.ComponentLifecycleEvent; -import org.thingsboard.server.common.data.queue.Queue; -import org.thingsboard.server.common.msg.queue.TopicPartitionInfo; -import org.thingsboard.server.common.stats.StatsFactory; -import org.thingsboard.server.gen.transport.TransportProtos; -import org.thingsboard.server.queue.TbQueueConsumer; -import org.thingsboard.server.queue.common.TbProtoQueueMsg; -import org.thingsboard.server.queue.discovery.QueueKey; -import org.thingsboard.server.queue.discovery.event.PartitionChangeEvent; -import org.thingsboard.server.queue.provider.TbRuleEngineQueueFactory; - -import java.util.Collections; -import java.util.HashSet; -import java.util.Set; -import java.util.concurrent.ConcurrentHashMap; -import java.util.concurrent.ConcurrentLinkedQueue; -import java.util.concurrent.ConcurrentMap; -import java.util.concurrent.ExecutorService; -import java.util.concurrent.ScheduledExecutorService; -import java.util.concurrent.TimeUnit; -import java.util.concurrent.locks.ReentrantLock; - -@Data -@Slf4j -public class TbRuleEngineQueueConsumerManager { - - private final ScheduledExecutorService scheduler; - private final ExecutorService consumerExecutor; - private final StatsFactory statsFactory; - private final TbRuleEngineQueueFactory queueFactory; - private final QueueKey key; - private final ReentrantLock lock = new ReentrantLock(); //NonfairSync - private final ConcurrentMap consumers = new ConcurrentHashMap<>(); - private final TbRuleEngineConsumerStats stats; - - private volatile Set partitions = Collections.emptySet(); - private volatile Queue queue; - private volatile TbQueueConsumerLauncher mainConsumer; - - private final java.util.Queue tasks = new ConcurrentLinkedQueue<>(); - - public TbRuleEngineQueueConsumerManager(ScheduledExecutorService scheduler, ExecutorService consumerExecutor, StatsFactory statsFactory, TbRuleEngineQueueFactory queueFactory, QueueKey key) { - this.scheduler = scheduler; - this.consumerExecutor = consumerExecutor; - this.statsFactory = statsFactory; - this.queueFactory = queueFactory; - this.key = key; - this.stats = new TbRuleEngineConsumerStats(key, statsFactory); - } - - public void init(Queue queue) { - processTask(new TbQueueConsumerManagerTask(ComponentLifecycleEvent.CREATED, queue, null)); - } - - private void processTask(TbQueueConsumerManagerTask todo) { - tasks.add(todo); - log.info("[{}] Adding task: {}", key, todo); - tryProcessTasks(); - } - - private void tryProcessTasks() { - consumerExecutor.submit(() -> { - if (lock.tryLock()) { - try { - TbQueueConsumerManagerTask lastUpdateTask = null; - while (!tasks.isEmpty()) { - TbQueueConsumerManagerTask task = tasks.poll(); - switch (task.getEvent()) { - case CREATED: - doInit(task.getQueue()); - break; - case UPDATED: - lastUpdateTask = task; - break; - case DELETED: - lastUpdateTask = null; - doDelete(); - break; - } - } - if (lastUpdateTask != null) { - doUpdate(lastUpdateTask.getQueue(), lastUpdateTask.getPartitions()); - } - } finally { - lock.unlock(); - } - } else { - log.debug("[{}] Failed to acquire lock.", key); - scheduler.schedule(this::tryProcessTasks, 1, TimeUnit.SECONDS); - } - }); - } - - public void doInit(Queue queue) { - log.info("[{}] Init consumer with queue: {}", key, queue); - this.queue = queue; - if (!queue.isConsumerPerPartition()) { - mainConsumer = new TbQueueConsumerLauncher(queueFactory.createToRuleEngineMsgConsumer(queue)); - } - } - - private void doUpdate(Queue newQueue, Set partitions) { - if (newQueue.isConsumerPerPartition()) { - - } else { - for (var oldConsumer : consumers.values()) { - oldConsumer.stop(); - } - for (var oldConsumer : consumers.entrySet()) { - try { - oldConsumer.getValue().awaitStopped(); - } catch (Exception e) { - log.info("[{}][{}] Failed to stop the consumer during update", key, oldConsumer.getKey().getPartition().orElse(-1), e); - } - } - if (mainConsumer == null) { - mainConsumer = new TbQueueConsumerLauncher(queueFactory.createToRuleEngineMsgConsumer(queue)); - //TODO: launch - } - mainConsumer.subscribe(partitions); - - } - } - - private void doDelete() { - } - - public void subscribe(PartitionChangeEvent event) { - log.info("[{}] Subscribing to partitions: {}", key, event.getPartitions()); - if (!queue.isConsumerPerPartition()) { - mainConsumer.subscribe(event.getPartitions()); - } else { - log.info("[{}] Subscribing consumer per partition: {}", key, event.getPartitions()); - subscribeConsumerPerPartition(event.getQueueKey(), event.getPartitions()); - } - } - - void subscribeConsumerPerPartition(QueueKey queue, Set partitions) { - topicsConsumerPerPartition.get(queue).getSubscribeQueue().add(partitions); - scheduleTopicRepartition(queue); - } - - private void scheduleTopicRepartition(QueueKey queue) { - repartitionExecutor.schedule(() -> repartitionTopicWithConsumerPerPartition(queue), 1, TimeUnit.SECONDS); - } - - void repartitionTopicWithConsumerPerPartition(final QueueKey queueKey) { - if (stopped) { - return; - } - TbTopicWithConsumerPerPartition tbTopicWithConsumerPerPartition = topicsConsumerPerPartition.get(queueKey); - java.util.Queue> subscribeQueue = tbTopicWithConsumerPerPartition.getSubscribeQueue(); - if (subscribeQueue.isEmpty()) { - return; - } - if (tbTopicWithConsumerPerPartition.getLock().tryLock()) { - try { - Set partitions = null; - while (!subscribeQueue.isEmpty()) { - partitions = subscribeQueue.poll(); - } - if (partitions == null) { - return; - } - - Set addedPartitions = new HashSet<>(partitions); - ConcurrentMap>> consumers = tbTopicWithConsumerPerPartition.getConsumers(); - addedPartitions.removeAll(consumers.keySet()); - log.info("calculated addedPartitions {}", addedPartitions); - - Set removedPartitions = new HashSet<>(consumers.keySet()); - removedPartitions.removeAll(partitions); - log.info("calculated removedPartitions {}", removedPartitions); - - removedPartitions.forEach((tpi) -> { - removeConsumerForTopicByTpi(queueKey.getQueueName(), consumers, tpi); - }); - - addedPartitions.forEach((tpi) -> { - log.info("[{}] Adding consumer for topic: {}", queueKey, tpi); - Queue configuration = consumerConfigurations.get(queueKey); - TbQueueConsumer> consumer = tbRuleEngineQueueFactory.createToRuleEngineMsgConsumer(configuration); - consumers.put(tpi, consumer); - launchConsumer(consumer, queueKey, tpi.getFullTopicName(), queueKey + "-" + tpi.getPartition().orElse(-999999)); - consumer.subscribe(Collections.singleton(tpi)); - }); - } finally { - tbTopicWithConsumerPerPartition.getLock().unlock(); - } - } else { - scheduleTopicRepartition(queueKey); //reschedule later - } - } - - public void stop() { -// consumers.values().forEach(TbQueueConsumer::stop); -// topicsConsumerPerPartition.values().forEach(tbTopicWithConsumerPerPartition -> tbTopicWithConsumerPerPartition.getConsumers().keySet() -// .forEach((tpi) -> removeConsumerForTopicByTpi(tbTopicWithConsumerPerPartition.getTopic(), tbTopicWithConsumerPerPartition.getConsumers(), tpi))); - } - -} diff --git a/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/QueueEvent.java b/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/QueueEvent.java new file mode 100644 index 0000000000..4d01d15d9a --- /dev/null +++ b/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/QueueEvent.java @@ -0,0 +1,9 @@ +package org.thingsboard.server.service.queue.ruleengine; + +import java.io.Serializable; + +public enum QueueEvent implements Serializable { + + CREATED, LAUNCHED, UPDATED, PARTITION_CHANGE, STOP, DELETED + +} diff --git a/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbQueueConsumerManagerTask.java b/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbQueueConsumerManagerTask.java new file mode 100644 index 0000000000..5b4f164a10 --- /dev/null +++ b/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbQueueConsumerManagerTask.java @@ -0,0 +1,32 @@ +/** + * Copyright © 2016-2023 The Thingsboard Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.thingsboard.server.service.queue.ruleengine; + +import lombok.Data; +import org.thingsboard.server.common.data.plugin.ComponentLifecycleEvent; +import org.thingsboard.server.common.data.queue.Queue; +import org.thingsboard.server.common.msg.queue.TopicPartitionInfo; + +import java.util.Set; + +@Data +public class TbQueueConsumerManagerTask { + + private final QueueEvent event; + private final Queue queue; + private final Set partitions; + +} diff --git a/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbQueueConsumerTask.java b/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbQueueConsumerTask.java new file mode 100644 index 0000000000..3f549b273c --- /dev/null +++ b/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbQueueConsumerTask.java @@ -0,0 +1,70 @@ +/** + * Copyright © 2016-2023 The Thingsboard Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.thingsboard.server.service.queue.ruleengine; + +import lombok.Data; +import lombok.extern.slf4j.Slf4j; +import org.thingsboard.server.common.msg.queue.TopicPartitionInfo; +import org.thingsboard.server.gen.transport.TransportProtos; +import org.thingsboard.server.queue.TbQueueConsumer; +import org.thingsboard.server.queue.common.TbProtoQueueMsg; +import org.thingsboard.server.queue.discovery.QueueKey; + +import java.util.Set; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.Future; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; + +@Data +@Slf4j +public class TbQueueConsumerTask { + + private final QueueKey key; + private final Object id; + private final TbQueueConsumer> consumer; + private volatile Future task; + + public void stop() { + this.consumer.stop(); + } + + public boolean stopAndAwait() { + this.consumer.stop(); + return await(); + } + + public boolean await() { + if (task != null) { + try { + this.task.get(3, TimeUnit.MINUTES); + } catch (ExecutionException | InterruptedException | TimeoutException e) { + log.warn("[{}][{}] Failed to await for consumer to stop", key, id, e); + return false; + } + } + return true; + } + + public void subscribe(Set partitions) { + this.consumer.subscribe(partitions); + } + + + public void unsubscribe() { + this.consumer.unsubscribe(); + } +} diff --git a/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbRuleEngineConsumerContext.java b/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbRuleEngineConsumerContext.java new file mode 100644 index 0000000000..49f1ad1fab --- /dev/null +++ b/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbRuleEngineConsumerContext.java @@ -0,0 +1,75 @@ +package org.thingsboard.server.service.queue.ruleengine; + +import lombok.Data; +import lombok.extern.slf4j.Slf4j; +import org.springframework.beans.factory.annotation.Value; +import org.springframework.stereotype.Component; +import org.thingsboard.common.util.ThingsBoardThreadFactory; +import org.thingsboard.server.actors.ActorSystemContext; +import org.thingsboard.server.common.data.queue.Queue; +import org.thingsboard.server.common.stats.StatsFactory; +import org.thingsboard.server.dao.queue.QueueService; +import org.thingsboard.server.queue.TbQueueAdmin; +import org.thingsboard.server.queue.discovery.TbServiceInfoProvider; +import org.thingsboard.server.queue.provider.TbQueueProducerProvider; +import org.thingsboard.server.queue.provider.TbRuleEngineQueueFactory; +import org.thingsboard.server.queue.util.TbRuleEngineComponent; +import org.thingsboard.server.service.queue.processing.TbRuleEngineProcessingStrategyFactory; +import org.thingsboard.server.service.queue.processing.TbRuleEngineSubmitStrategyFactory; +import org.thingsboard.server.service.rpc.TbRuleEngineDeviceRpcService; +import org.thingsboard.server.service.stats.RuleEngineStatisticsService; + +import javax.annotation.PreDestroy; +import java.util.List; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.ScheduledExecutorService; + +@Component +@TbRuleEngineComponent +@Slf4j +@Data +public class TbRuleEngineConsumerContext { + + @Value("${queue.rule-engine.poll-interval}") + private long pollDuration; + @Value("${queue.rule-engine.pack-processing-timeout}") + private long packProcessingTimeout; + @Value("${queue.rule-engine.stats.enabled:true}") + private boolean statsEnabled; + @Value("${queue.rule-engine.prometheus-stats.enabled:false}") + boolean prometheusStatsEnabled; + @Value("${queue.rule-engine.topic-deletion-delay:30}") + private int topicDeletionDelayInSec; + + protected volatile boolean stopped = false; + protected volatile boolean isReady = false; + + private final ActorSystemContext actorContext; + private final StatsFactory statsFactory; + private final TbRuleEngineSubmitStrategyFactory submitStrategyFactory; + private final TbRuleEngineProcessingStrategyFactory processingStrategyFactory; + private final TbRuleEngineQueueFactory queueFactory; + private final RuleEngineStatisticsService statisticsService; + private final TbServiceInfoProvider serviceInfoProvider; + private final QueueService queueService; + private final TbQueueProducerProvider producerProvider; + private final TbQueueAdmin queueAdmin; + + //TODO: add reasonable limit for mgmt pool. + private final ExecutorService mgmtExecutor = Executors.newCachedThreadPool(ThingsBoardThreadFactory.forName("tb-rule-engine-mgmt")); + private final ExecutorService consumersExecutor = Executors.newCachedThreadPool(ThingsBoardThreadFactory.forName("tb-rule-engine-consumer")); + private final ExecutorService submitExecutor = Executors.newSingleThreadExecutor(ThingsBoardThreadFactory.forName("tb-rule-engine-consumer-submit")); + private final ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor(ThingsBoardThreadFactory.forName("tb-rule-engine-consumer-scheduler")); + + public List findAllQueues() { + return queueService.findAllQueues(); + } + + @PreDestroy + public void stop() { + consumersExecutor.shutdownNow(); // TODO: shutdown or shutdownNow? + submitExecutor.shutdownNow(); + scheduler.shutdownNow(); + } +} diff --git a/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbRuleEngineQueueConsumerManager.java b/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbRuleEngineQueueConsumerManager.java new file mode 100644 index 0000000000..2599a214f0 --- /dev/null +++ b/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbRuleEngineQueueConsumerManager.java @@ -0,0 +1,431 @@ +/** + * Copyright © 2016-2023 The Thingsboard Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.thingsboard.server.service.queue.ruleengine; + +import com.google.protobuf.ProtocolStringList; +import lombok.Data; +import lombok.SneakyThrows; +import lombok.extern.slf4j.Slf4j; +import org.thingsboard.common.util.ThingsBoardThreadFactory; +import org.thingsboard.server.common.data.id.EntityId; +import org.thingsboard.server.common.data.id.EntityIdFactory; +import org.thingsboard.server.common.data.id.TenantId; +import org.thingsboard.server.common.data.queue.Queue; +import org.thingsboard.server.common.msg.TbMsg; +import org.thingsboard.server.common.msg.gen.MsgProtos; +import org.thingsboard.server.common.msg.queue.QueueToRuleEngineMsg; +import org.thingsboard.server.common.msg.queue.RuleEngineException; +import org.thingsboard.server.common.msg.queue.RuleNodeInfo; +import org.thingsboard.server.common.msg.queue.ServiceType; +import org.thingsboard.server.common.msg.queue.TbMsgCallback; +import org.thingsboard.server.common.msg.queue.TopicPartitionInfo; +import org.thingsboard.server.gen.transport.TransportProtos; +import org.thingsboard.server.queue.TbQueueConsumer; +import org.thingsboard.server.queue.common.TbProtoQueueMsg; +import org.thingsboard.server.queue.discovery.QueueKey; +import org.thingsboard.server.queue.discovery.event.PartitionChangeEvent; +import org.thingsboard.server.service.queue.TbMsgPackCallback; +import org.thingsboard.server.service.queue.TbMsgPackProcessingContext; +import org.thingsboard.server.service.queue.TbRuleEngineConsumerStats; +import org.thingsboard.server.service.queue.processing.TbRuleEngineProcessingDecision; +import org.thingsboard.server.service.queue.processing.TbRuleEngineProcessingResult; +import org.thingsboard.server.service.queue.processing.TbRuleEngineProcessingStrategy; +import org.thingsboard.server.service.queue.processing.TbRuleEngineSubmitStrategy; + +import java.util.Collections; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.UUID; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.ConcurrentLinkedQueue; +import java.util.concurrent.ConcurrentMap; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.locks.ReentrantLock; + +@Data +@Slf4j +public class TbRuleEngineQueueConsumerManager { + + public static final String SUCCESSFUL_STATUS = "successful"; + public static final String FAILED_STATUS = "failed"; + + private final TbRuleEngineConsumerContext ctx; + private final QueueKey key; + + private final ReentrantLock lock = new ReentrantLock(); //NonfairSync + private final ConcurrentMap consumersPerPartition = new ConcurrentHashMap<>(); + private final TbRuleEngineConsumerStats stats; + + private volatile Set partitions = Collections.emptySet(); + private volatile Queue queue; + private volatile TbQueueConsumerTask mainConsumer; + + private final java.util.Queue tasks = new ConcurrentLinkedQueue<>(); + + public TbRuleEngineQueueConsumerManager(TbRuleEngineConsumerContext ctx, QueueKey key) { + this.ctx = ctx; + this.key = key; + this.stats = new TbRuleEngineConsumerStats(key, ctx.getStatsFactory()); + } + + public void init(Queue queue) { + processTask(new TbQueueConsumerManagerTask(QueueEvent.CREATED, queue, null)); + } + + public void update(Queue queue) { + processTask(new TbQueueConsumerManagerTask(QueueEvent.UPDATED, queue, null)); + } + + public void subscribe(PartitionChangeEvent event) { + processTask(new TbQueueConsumerManagerTask(QueueEvent.PARTITION_CHANGE, queue, event.getPartitions())); + } + + public void launchMainConsumer() { + processTask(new TbQueueConsumerManagerTask(QueueEvent.LAUNCHED, null, null)); + } + + public void stop() { + processTask(new TbQueueConsumerManagerTask(QueueEvent.STOP, null, null)); + } + + public void delete() { + processTask(new TbQueueConsumerManagerTask(QueueEvent.DELETED, null, null)); + } + + private void processTask(TbQueueConsumerManagerTask todo) { + tasks.add(todo); + log.info("[{}] Adding task: {}", key, todo); + tryProcessTasks(); + } + + private void tryProcessTasks() { + ctx.getMgmtExecutor().submit(() -> { + if (lock.tryLock()) { + try { + Queue newConfiguration = null; + Set newPartitions = null; + while (!tasks.isEmpty()) { + TbQueueConsumerManagerTask task = tasks.poll(); + switch (task.getEvent()) { + case CREATED: + doInit(task.getQueue()); + break; + case LAUNCHED: + if (!queue.isConsumerPerPartition()) { + doLaunchMainConsumer(); + } + break; + case UPDATED: + newConfiguration = task.getQueue(); + break; + case PARTITION_CHANGE: + newPartitions = task.getPartitions(); + break; + case STOP: + newConfiguration = null; + newPartitions = null; + doStop(); + break; + case DELETED: + newConfiguration = null; + newPartitions = null; + doDelete(); + break; + } + } + if (newConfiguration != null) { + doUpdate(newConfiguration); + } + if (newPartitions != null) { + doUpdate(newPartitions); + } + } finally { + lock.unlock(); + } + } else { + log.debug("[{}] Failed to acquire lock.", key); + ctx.getScheduler().schedule(this::tryProcessTasks, 1, TimeUnit.SECONDS); + } + }); + } + + public void doInit(Queue queue) { + log.info("[{}] Init consumer with queue: {}", key, queue); + this.queue = queue; + if (queue.isConsumerPerPartition()) { + log.debug("[{}] Ignore init event since isConsumerPerPartition is enabled.", key); + } else { + mainConsumer = new TbQueueConsumerTask(key, "main", ctx.getQueueFactory().createToRuleEngineMsgConsumer(queue)); + } + } + + private void doLaunchMainConsumer() { + if (mainConsumer != null) { + launchConsumer(mainConsumer, queue, mainConsumer.getId(), queue.getName()); + } else { + log.warn("[{}] Can't launch main consumer since it is empty!", key); + } + } + + private void doUpdate(Queue newQueue) { + log.info("[{}] Processing queue update: {}", key, newQueue); + var oldQueue = queue; + if (log.isTraceEnabled()) { + log.trace("[{}] Old queue configuration: {}", key, oldQueue); + log.trace("[{}] New queue configuration: {}", key, newQueue); + } + if (oldQueue != null) { + doStop(oldQueue); + } + doInit(newQueue); + if (!newQueue.isConsumerPerPartition()) { + doLaunchMainConsumer(); + } + } + + private void doUpdate(Set partitions) { + log.info("[{}] Subscribing to partitions: {}", key, partitions); + if (queue.isConsumerPerPartition()) { + log.debug("[{}] Subscribing consumers per partition separately: {}", key, partitions); + Set addedPartitions = new HashSet<>(partitions); + addedPartitions.removeAll(consumersPerPartition.keySet()); + log.info("calculated addedPartitions {}", addedPartitions); + + Set removedPartitions = new HashSet<>(consumersPerPartition.keySet()); + removedPartitions.removeAll(partitions); + log.info("calculated removedPartitions {}", removedPartitions); + + removedPartitions.forEach((tpi) -> { + log.info("[{}] Unsubscribing from topic: {}", queue, tpi); + consumersPerPartition.get(tpi).unsubscribe(); + }); + + removedPartitions.forEach((tpi) -> { + log.info("[{}] Removing consumer for topic: {}", queue, tpi); + consumersPerPartition.get(tpi).stopAndAwait(); + consumersPerPartition.remove(tpi); + }); + + addedPartitions.forEach((tpi) -> { + log.info("[{}] Adding consumer for topic: {}", key, tpi); + TbQueueConsumerTask consumerTask = new TbQueueConsumerTask(key, tpi, ctx.getQueueFactory().createToRuleEngineMsgConsumer(queue)); + consumersPerPartition.put(tpi, consumerTask); + //TODO: Is it ok to subscribe first? + consumerTask.subscribe(Collections.singleton(tpi)); + launchConsumer(consumerTask, queue, mainConsumer.getId(), key + "-" + tpi.getPartition().orElse(-999999)); + }); + } else { + mainConsumer.subscribe(partitions); + } + } + + private void doStop() { + doStop(queue); + } + + private void doStop(Queue queue) { + if (queue.isConsumerPerPartition()) { + consumersPerPartition.values().forEach(TbQueueConsumerTask::unsubscribe); + consumersPerPartition.values().forEach(TbQueueConsumerTask::stopAndAwait); + } else if (mainConsumer != null) { + mainConsumer.unsubscribe(); + mainConsumer.stopAndAwait(); + } + } + + private void doDelete() { + doStop(); + //TODO: repack messages + } + + @SneakyThrows + void launchConsumer(TbQueueConsumerTask consumerTask, Queue configuration, Object consumerKey, String threadSuffix) { + log.info("[{}] Launching consumer: [{}]", key, consumerKey); + while (!ctx.isReady) { + //TODO: Remember this task. Cancel previous task if needed. + log.debug("[{}][{}] Waiting for consumer to get ready..", key, consumerKey); + Thread.sleep(1000); + } + consumerTask.setTask(ctx.getConsumersExecutor().submit(() -> consumerLoop(consumerTask.getConsumer(), configuration, threadSuffix))); + } + + void consumerLoop(TbQueueConsumer> consumer, Queue configuration, String threadSuffix) { + ThingsBoardThreadFactory.updateCurrentThreadName(threadSuffix); + while (!ctx.stopped && !consumer.isStopped() + //TODO: remove this. + && !consumer.isQueueDeleted()) { + try { + List> msgs = consumer.poll(queue.getPollInterval()); + if (msgs.isEmpty()) { + continue; + } + final TbRuleEngineSubmitStrategy submitStrategy = getSubmitStrategy(queue); + final TbRuleEngineProcessingStrategy ackStrategy = getProcessingStrategy(queue); + submitStrategy.init(msgs); + while (!ctx.isStopped() && !consumer.isStopped()) { + TbMsgPackProcessingContext packCtx = new TbMsgPackProcessingContext(queue.getName(), submitStrategy, ackStrategy.isSkipTimeoutMsgs()); + submitStrategy.submitAttempt((id, msg) -> ctx.getSubmitExecutor().submit(() -> submitMessage(configuration, stats, packCtx, id, msg))); + + final boolean timeout = !packCtx.await(configuration.getPackProcessingTimeout(), TimeUnit.MILLISECONDS); + + TbRuleEngineProcessingResult result = new TbRuleEngineProcessingResult(configuration.getName(), timeout, packCtx); + if (timeout) { + printFirstOrAll(configuration, packCtx, packCtx.getPendingMap(), "Timeout"); + } + if (!packCtx.getFailedMap().isEmpty()) { + printFirstOrAll(configuration, packCtx, packCtx.getFailedMap(), "Failed"); + } + packCtx.printProfilerStats(); + + TbRuleEngineProcessingDecision decision = ackStrategy.analyze(result); + if (ctx.isStatsEnabled()) { + stats.log(result, decision.isCommit()); + } + + packCtx.cleanup(); + + if (decision.isCommit()) { + submitStrategy.stop(); + break; + } else { + submitStrategy.update(decision.getReprocessMap()); + } + } + consumer.commit(); + } catch (Exception e) { + if (!ctx.stopped) { + log.warn("Failed to process messages from queue.", e); + try { + Thread.sleep(ctx.getPollDuration()); + } catch (InterruptedException e2) { + log.trace("Failed to wait until the server has capacity to handle new requests", e2); + } + } + } + } + //TODO: refactor and move to the "doDelete" method. Use separate consumer if needed (it is still synchronous). + if (consumer.isQueueDeleted()) { + processQueueDeletion(configuration, consumer); + } + log.info("TB Rule Engine Consumer stopped."); + } + + private void processQueueDeletion(Queue queue, TbQueueConsumer> consumer) { +// long finishTs = System.currentTimeMillis() + TimeUnit.SECONDS.toMillis(topicDeletionDelayInSec); +// try { +// int n = 0; +// while (System.currentTimeMillis() <= finishTs) { +// List> msgs = consumer.poll(queue.getPollInterval()); +// if (msgs.isEmpty()) { +// continue; +// } +// for (TbProtoQueueMsg msg : msgs) { +// try { +// MsgProtos.TbMsgProto tbMsgProto = MsgProtos.TbMsgProto.parseFrom(msg.getValue().getTbMsg().toByteArray()); +// EntityId originator = EntityIdFactory.getByTypeAndUuid(tbMsgProto.getEntityType(), new UUID(tbMsgProto.getEntityIdMSB(), tbMsgProto.getEntityIdLSB())); +// +// TopicPartitionInfo tpi = partitionService.resolve(ServiceType.TB_RULE_ENGINE, queue.getName(), TenantId.SYS_TENANT_ID, originator); +// producerProvider.getRuleEngineMsgProducer().send(tpi, msg, null); +// n++; +// } catch (Throwable e) { +// log.debug("Failed to move message to system {}: {}", consumer.getTopic(), msg, e); +// } +// } +// consumer.commit(); +// } +// if (n > 0) { +// log.info("Moved {} messages from {} to system {}", n, consumer.getFullTopicNames(), consumer.getTopic()); +// } +// +// consumer.unsubscribe(); +// for (String topic : consumer.getFullTopicNames()) { +// try { +// queueAdmin.deleteTopic(topic); +// log.info("Deleted topic {}", topic); +// } catch (Exception e) { +// log.error("Failed to delete topic {} after unsubscribing", topic, e); +// } +// } +// } catch (Exception e) { +// log.error("Failed to process deletion of {} ({})", consumer.getTopic(), queue.getTenantId(), e); +// } + } + + TbRuleEngineSubmitStrategy getSubmitStrategy(Queue configuration) { + return ctx.getSubmitStrategyFactory().newInstance(configuration.getName(), configuration.getSubmitStrategy()); + } + + TbRuleEngineProcessingStrategy getProcessingStrategy(Queue configuration) { + return ctx.getProcessingStrategyFactory().newInstance(configuration.getName(), configuration.getProcessingStrategy()); + } + + void submitMessage(Queue configuration, TbRuleEngineConsumerStats stats, TbMsgPackProcessingContext packCtx, UUID id, TbProtoQueueMsg msg) { + log.trace("[{}] Creating callback for topic {} message: {}", id, configuration.getName(), msg.getValue()); + TransportProtos.ToRuleEngineMsg toRuleEngineMsg = msg.getValue(); + TenantId tenantId = TenantId.fromUUID(new UUID(toRuleEngineMsg.getTenantIdMSB(), toRuleEngineMsg.getTenantIdLSB())); + TbMsgCallback callback = ctx.prometheusStatsEnabled ? + new TbMsgPackCallback(id, tenantId, packCtx, stats.getTimer(tenantId, SUCCESSFUL_STATUS), stats.getTimer(tenantId, FAILED_STATUS)) : + new TbMsgPackCallback(id, tenantId, packCtx); + try { + if (!toRuleEngineMsg.getTbMsg().isEmpty()) { + forwardToRuleEngineActor(configuration.getName(), tenantId, toRuleEngineMsg, callback); + } else { + callback.onSuccess(); + } + } catch (Exception e) { + callback.onFailure(new RuleEngineException(e.getMessage(), e)); + } + } + + private void forwardToRuleEngineActor(String queueName, TenantId tenantId, TransportProtos.ToRuleEngineMsg toRuleEngineMsg, TbMsgCallback callback) { + TbMsg tbMsg = TbMsg.fromBytes(queueName, toRuleEngineMsg.getTbMsg().toByteArray(), callback); + QueueToRuleEngineMsg msg; + ProtocolStringList relationTypesList = toRuleEngineMsg.getRelationTypesList(); + Set relationTypes; + if (relationTypesList.size() == 1) { + relationTypes = Collections.singleton(relationTypesList.get(0)); + } else { + relationTypes = new HashSet<>(relationTypesList); + } + msg = new QueueToRuleEngineMsg(tenantId, tbMsg, relationTypes, toRuleEngineMsg.getFailureMessage()); + ctx.getActorContext().tell(msg); + } + + + private void printFirstOrAll(Queue configuration, TbMsgPackProcessingContext ctx, Map> map, String prefix) { + boolean printAll = log.isTraceEnabled(); + log.info("{} to process [{}] messages", prefix, map.size()); + for (Map.Entry> pending : map.entrySet()) { + TransportProtos.ToRuleEngineMsg tmp = pending.getValue().getValue(); + TbMsg tmpMsg = TbMsg.fromBytes(configuration.getName(), tmp.getTbMsg().toByteArray(), TbMsgCallback.EMPTY); + RuleNodeInfo ruleNodeInfo = ctx.getLastVisitedRuleNode(pending.getKey()); + if (printAll) { + log.trace("[{}] {} to process message: {}, Last Rule Node: {}", TenantId.fromUUID(new UUID(tmp.getTenantIdMSB(), tmp.getTenantIdLSB())), prefix, tmpMsg, ruleNodeInfo); + } else { + log.info("[{}] {} to process message: {}, Last Rule Node: {}", TenantId.fromUUID(new UUID(tmp.getTenantIdMSB(), tmp.getTenantIdLSB())), prefix, tmpMsg, ruleNodeInfo); + break; + } + } + } + + public void printStats(long ts) { + stats.printStats(); + ctx.getStatisticsService().reportQueueStats(ts, stats); + stats.reset(); + } +} diff --git a/common/util/src/main/java/org/thingsboard/common/util/ThingsBoardThreadFactory.java b/common/util/src/main/java/org/thingsboard/common/util/ThingsBoardThreadFactory.java index 1f41c48f43..9eaca3ca47 100644 --- a/common/util/src/main/java/org/thingsboard/common/util/ThingsBoardThreadFactory.java +++ b/common/util/src/main/java/org/thingsboard/common/util/ThingsBoardThreadFactory.java @@ -22,6 +22,7 @@ import java.util.concurrent.atomic.AtomicInteger; * Copy of Executors.DefaultThreadFactory but with ability to set name of the pool */ public class ThingsBoardThreadFactory implements ThreadFactory { + public static final String THREAD_TOPIC_SEPARATOR = " | "; private static final AtomicInteger poolNumber = new AtomicInteger(1); private final ThreadGroup group; private final AtomicInteger threadNumber = new AtomicInteger(1); @@ -40,6 +41,17 @@ public class ThingsBoardThreadFactory implements ThreadFactory { "-thread-"; } + public static void updateCurrentThreadName(String threadSuffix) { + String name = Thread.currentThread().getName(); + int spliteratorIndex = name.indexOf(THREAD_TOPIC_SEPARATOR); + if (spliteratorIndex > 0) { + name = name.substring(0, spliteratorIndex); + } + name = name + THREAD_TOPIC_SEPARATOR + threadSuffix; + Thread.currentThread().setName(name); + } + + @Override public Thread newThread(Runnable r) { Thread t = new Thread(group, r, From c56132d6e89d00043b0d644850891663ef0b9122 Mon Sep 17 00:00:00 2001 From: Andrii Shvaika Date: Tue, 3 Oct 2023 15:04:41 +0300 Subject: [PATCH 15/43] Minor todos --- .../server/service/queue/ruleengine/TbQueueConsumerTask.java | 1 + .../service/queue/ruleengine/TbRuleEngineConsumerContext.java | 3 +++ 2 files changed, 4 insertions(+) diff --git a/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbQueueConsumerTask.java b/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbQueueConsumerTask.java index 3f549b273c..ed1f36074f 100644 --- a/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbQueueConsumerTask.java +++ b/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbQueueConsumerTask.java @@ -49,6 +49,7 @@ public class TbQueueConsumerTask { public boolean await() { if (task != null) { + //TODO: maybe task.cancel() to interrupt the consumer? try { this.task.get(3, TimeUnit.MINUTES); } catch (ExecutionException | InterruptedException | TimeoutException e) { diff --git a/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbRuleEngineConsumerContext.java b/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbRuleEngineConsumerContext.java index 49f1ad1fab..07307a3f10 100644 --- a/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbRuleEngineConsumerContext.java +++ b/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbRuleEngineConsumerContext.java @@ -42,6 +42,7 @@ public class TbRuleEngineConsumerContext { @Value("${queue.rule-engine.topic-deletion-delay:30}") private int topicDeletionDelayInSec; + //TODO: check if they are set correctly. protected volatile boolean stopped = false; protected volatile boolean isReady = false; @@ -59,6 +60,7 @@ public class TbRuleEngineConsumerContext { //TODO: add reasonable limit for mgmt pool. private final ExecutorService mgmtExecutor = Executors.newCachedThreadPool(ThingsBoardThreadFactory.forName("tb-rule-engine-mgmt")); private final ExecutorService consumersExecutor = Executors.newCachedThreadPool(ThingsBoardThreadFactory.forName("tb-rule-engine-consumer")); + //TODO: do we actually need this? private final ExecutorService submitExecutor = Executors.newSingleThreadExecutor(ThingsBoardThreadFactory.forName("tb-rule-engine-consumer-submit")); private final ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor(ThingsBoardThreadFactory.forName("tb-rule-engine-consumer-scheduler")); @@ -68,6 +70,7 @@ public class TbRuleEngineConsumerContext { @PreDestroy public void stop() { + mgmtExecutor.shutdownNow(); consumersExecutor.shutdownNow(); // TODO: shutdown or shutdownNow? submitExecutor.shutdownNow(); scheduler.shutdownNow(); From 92e0c65a3740f179a9ec651a392fdcfbbfa6f175 Mon Sep 17 00:00:00 2001 From: ViacheslavKlimov Date: Sat, 14 Oct 2023 21:50:40 +0300 Subject: [PATCH 16/43] Minor refactoring --- .../queue/DefaultTbCoreConsumerService.java | 10 +++- .../DefaultTbRuleEngineConsumerService.java | 59 +++++++++++++------ .../queue/TbRuleEngineConsumerStats.java | 6 +- .../processing/AbstractConsumerService.java | 11 +--- .../TbRuleEngineConsumerContext.java | 45 +++++++------- .../src/main/resources/thingsboard.yml | 4 +- .../controller/BaseQueueControllerTest.java | 6 +- 7 files changed, 85 insertions(+), 56 deletions(-) diff --git a/application/src/main/java/org/thingsboard/server/service/queue/DefaultTbCoreConsumerService.java b/application/src/main/java/org/thingsboard/server/service/queue/DefaultTbCoreConsumerService.java index fd5a252cc5..b2d7700441 100644 --- a/application/src/main/java/org/thingsboard/server/service/queue/DefaultTbCoreConsumerService.java +++ b/application/src/main/java/org/thingsboard/server/service/queue/DefaultTbCoreConsumerService.java @@ -142,8 +142,8 @@ public class DefaultTbCoreConsumerService extends AbstractConsumerService> usageStatsConsumer; private final TbQueueConsumer> firmwareStatesConsumer; + protected volatile ExecutorService consumersExecutor; protected volatile ExecutorService usageStatsExecutor; - private volatile ExecutorService firmwareStatesExecutor; public DefaultTbCoreConsumerService(TbCoreQueueFactory tbCoreQueueFactory, @@ -186,7 +186,8 @@ public class DefaultTbCoreConsumerService extends AbstractConsumerService implements TbRuleEngineConsumerService { private final TbRuleEngineConsumerContext ctx; + private final QueueService queueService; private final TbRuleEngineDeviceRpcService tbDeviceRpcService; private final ConcurrentMap consumers = new ConcurrentHashMap<>(); @@ -68,6 +72,7 @@ public class DefaultTbRuleEngineConsumerService extends AbstractConsumerService< ActorSystemContext actorContext, DataDecodingEncodingService encodingService, TbRuleEngineDeviceRpcService tbDeviceRpcService, + QueueService queueService, TbDeviceProfileCache deviceProfileCache, TbAssetProfileCache assetProfileCache, TbTenantProfileCache tenantProfileCache, @@ -77,12 +82,13 @@ public class DefaultTbRuleEngineConsumerService extends AbstractConsumerService< eventPublisher, tbRuleEngineQueueFactory.createToRuleEngineNotificationsMsgConsumer(), Optional.empty()); this.ctx = ctx; this.tbDeviceRpcService = tbDeviceRpcService; + this.queueService = queueService; } @PostConstruct public void init() { - super.init("tb-rule-engine-notifications-consumer"); // TODO: restore init of the main consumer? - List queues = ctx.findAllQueues(); + super.init("tb-rule-engine-notifications-consumer"); + List queues = queueService.findAllQueues(); for (Queue configuration : queues) { if (partitionService.isManagedByCurrentService(configuration.getTenantId())) { initConsumer(configuration); @@ -91,30 +97,38 @@ public class DefaultTbRuleEngineConsumerService extends AbstractConsumerService< } private void initConsumer(Queue configuration) { - consumers.computeIfAbsent(new QueueKey(ServiceType.TB_RULE_ENGINE, configuration), - key -> new TbRuleEngineQueueConsumerManager(ctx, key)).init(configuration); + getOrCreateConsumer(new QueueKey(ServiceType.TB_RULE_ENGINE, configuration)).init(configuration); } @Override protected void onTbApplicationEvent(PartitionChangeEvent event) { if (event.getServiceType().equals(getServiceType())) { - var consumer = consumers.get(event.getQueueKey()); - if (consumer != null) { - consumer.subscribe(event); - } else { - log.warn("Received invalid partition change event for {} that is not managed by this service", event.getQueueKey()); - } + event.getPartitionsMap().forEach((queueKey, partitions) -> { + var consumer = consumers.get(queueKey); + if (consumer != null) { + consumer.update(partitions); + } else { + log.warn("Received invalid partition change event for {} that is not managed by this service", queueKey); + } + }); } } + @AfterStartUp(order = AfterStartUp.REGULAR_SERVICE) + public void onApplicationEvent(ApplicationReadyEvent event) { + super.onApplicationEvent(event); + ctx.setReady(true); + } + @Override protected void launchMainConsumers() { consumers.values().forEach(TbRuleEngineQueueConsumerManager::launchMainConsumer); } @Override - protected void stopMainConsumers() { + protected void stopConsumers() { consumers.values().forEach(TbRuleEngineQueueConsumerManager::stop); + ctx.stop(); } @Override @@ -164,8 +178,15 @@ public class DefaultTbRuleEngineConsumerService extends AbstractConsumerService< QueueId queueId = new QueueId(new UUID(queueUpdateMsg.getQueueIdMSB(), queueUpdateMsg.getQueueIdLSB())); String queueName = queueUpdateMsg.getQueueName(); QueueKey queueKey = new QueueKey(ServiceType.TB_RULE_ENGINE, queueName, tenantId); - Queue queue = ctx.getQueueService().findQueueById(tenantId, queueId); - consumers.computeIfAbsent(queueKey, key -> new TbRuleEngineQueueConsumerManager(ctx, key)).update(queue); + Queue queue = queueService.findQueueById(tenantId, queueId); + + TbRuleEngineQueueConsumerManager consumerManager = getOrCreateConsumer(queueKey); + Queue oldQueue = consumerManager.getQueue(); + consumerManager.update(queue); + + if (oldQueue != null && queue.getPartitions() == oldQueue.getPartitions()) { + return; + } } partitionService.updateQueue(queueUpdateMsg); @@ -177,15 +198,19 @@ public class DefaultTbRuleEngineConsumerService extends AbstractConsumerService< log.info("Received queue delete msg: [{}]", queueDeleteMsg); TenantId tenantId = new TenantId(new UUID(queueDeleteMsg.getTenantIdMSB(), queueDeleteMsg.getTenantIdLSB())); QueueKey queueKey = new QueueKey(ServiceType.TB_RULE_ENGINE, queueDeleteMsg.getQueueName(), tenantId); + var consumerManager = consumers.remove(queueKey); + if (consumerManager != null) { + consumerManager.delete(); + } partitionService.removeQueue(queueDeleteMsg); - var manager = consumers.remove(queueKey); - if (manager != null) { - manager.delete(); - } partitionService.recalculatePartitions(ctx.getServiceInfoProvider().getServiceInfo(), new ArrayList<>(partitionService.getOtherServices(ServiceType.TB_RULE_ENGINE))); } + private TbRuleEngineQueueConsumerManager getOrCreateConsumer(QueueKey queueKey) { + return consumers.computeIfAbsent(queueKey, key -> new TbRuleEngineQueueConsumerManager(ctx, key)); + } + @Scheduled(fixedDelayString = "${queue.rule-engine.stats.print-interval-ms}") public void printStats() { if (ctx.isStatsEnabled()) { diff --git a/application/src/main/java/org/thingsboard/server/service/queue/TbRuleEngineConsumerStats.java b/application/src/main/java/org/thingsboard/server/service/queue/TbRuleEngineConsumerStats.java index 45ccbcf32a..842b627c22 100644 --- a/application/src/main/java/org/thingsboard/server/service/queue/TbRuleEngineConsumerStats.java +++ b/application/src/main/java/org/thingsboard/server/service/queue/TbRuleEngineConsumerStats.java @@ -67,9 +67,9 @@ public class TbRuleEngineConsumerStats { private final String queueName; private final TenantId tenantId; - public TbRuleEngineConsumerStats(QueueKey queue, StatsFactory statsFactory) { - this.queueName = queue.getQueueName(); - this.tenantId = queue.getTenantId(); + public TbRuleEngineConsumerStats(QueueKey queueKey, StatsFactory statsFactory) { + this.queueName = queueKey.getQueueName(); + this.tenantId = queueKey.getTenantId(); this.statsFactory = statsFactory; String statsKey = StatsType.RULE_ENGINE.getName() + "." + queueName; diff --git a/application/src/main/java/org/thingsboard/server/service/queue/processing/AbstractConsumerService.java b/application/src/main/java/org/thingsboard/server/service/queue/processing/AbstractConsumerService.java index b59086a350..d5be1243b7 100644 --- a/application/src/main/java/org/thingsboard/server/service/queue/processing/AbstractConsumerService.java +++ b/application/src/main/java/org/thingsboard/server/service/queue/processing/AbstractConsumerService.java @@ -65,7 +65,6 @@ import java.util.stream.Collectors; @Slf4j public abstract class AbstractConsumerService extends TbApplicationEventListener { - protected volatile ExecutorService consumersExecutor; protected volatile ExecutorService notificationsConsumerExecutor; protected volatile boolean stopped = false; protected volatile boolean isReady = false; @@ -99,8 +98,7 @@ public abstract class AbstractConsumerService findAllQueues() { - return queueService.findAllQueues(); + @PostConstruct + public void init() { + this.consumersExecutor = Executors.newCachedThreadPool(ThingsBoardThreadFactory.forName("tb-rule-engine-consumer")); + this.mgmtExecutor = Executors.newFixedThreadPool(mgmtThreadPoolSize, ThingsBoardThreadFactory.forName("tb-rule-engine-mgmt")); + this.scheduler = Executors.newSingleThreadScheduledExecutor(ThingsBoardThreadFactory.forName("tb-rule-engine-consumer-scheduler")); } - @PreDestroy public void stop() { - mgmtExecutor.shutdownNow(); - consumersExecutor.shutdownNow(); // TODO: shutdown or shutdownNow? - submitExecutor.shutdownNow(); scheduler.shutdownNow(); + consumersExecutor.shutdown(); + mgmtExecutor.shutdown(); + try { + mgmtExecutor.awaitTermination(15, TimeUnit.SECONDS); + } catch (InterruptedException e) { + log.warn("Failed to await mgmtExecutor termination"); + } } } diff --git a/application/src/main/resources/thingsboard.yml b/application/src/main/resources/thingsboard.yml index 9fbfd2fc63..6f51413ccd 100644 --- a/application/src/main/resources/thingsboard.yml +++ b/application/src/main/resources/thingsboard.yml @@ -1303,7 +1303,9 @@ queue: pause-between-retries: "${TB_QUEUE_RE_SQ_PROCESSING_STRATEGY_RETRY_PAUSE:5}" # Time in seconds to wait in consumer thread before retries; max-pause-between-retries: "${TB_QUEUE_RE_SQ_PROCESSING_STRATEGY_MAX_RETRY_PAUSE:5}" # Max allowed time in seconds for pause between retries. # After a queue is deleted (or profile's isolation option was disabled), Rule Engine will continue reading related topics during this period, before deleting the actual topics - topic-deletion-delay: "${TB_QUEUE_RULE_ENGINE_TOPIC_DELETION_DELAY_SEC:30}" + topic-deletion-delay: "${TB_QUEUE_RULE_ENGINE_TOPIC_DELETION_DELAY_SEC:15}" + # Size of the thread pool that handles management operations such as subscribe, unsubscribe, queue delete, etc. + management-thread-pool-size: "${TB_QUEUE_RULE_ENGINE_MGMT_THREAD_POOL_SIZE:12}" transport: # For high priority notifications that require minimum latency and processing time notifications_topic: "${TB_QUEUE_TRANSPORT_NOTIFICATIONS_TOPIC:tb_transport.notifications}" diff --git a/application/src/test/java/org/thingsboard/server/controller/BaseQueueControllerTest.java b/application/src/test/java/org/thingsboard/server/controller/BaseQueueControllerTest.java index 845ac49f15..8418ba67d9 100644 --- a/application/src/test/java/org/thingsboard/server/controller/BaseQueueControllerTest.java +++ b/application/src/test/java/org/thingsboard/server/controller/BaseQueueControllerTest.java @@ -37,12 +37,14 @@ import org.thingsboard.server.common.data.queue.Queue; import org.thingsboard.server.common.data.queue.SubmitStrategy; import org.thingsboard.server.common.data.queue.SubmitStrategyType; import org.thingsboard.server.common.msg.queue.RuleEngineException; +import org.thingsboard.server.common.msg.queue.ServiceType; import org.thingsboard.server.common.stats.StatsFactory; import org.thingsboard.server.dao.asset.AssetService; import org.thingsboard.server.dao.service.DaoSqlTest; import org.thingsboard.server.dao.timeseries.TimeseriesDao; import org.thingsboard.server.gen.transport.TransportProtos; import org.thingsboard.server.queue.common.TbProtoQueueMsg; +import org.thingsboard.server.queue.discovery.QueueKey; import org.thingsboard.server.service.queue.TbRuleEngineConsumerStats; import org.thingsboard.server.service.queue.processing.TbRuleEngineProcessingResult; import org.thingsboard.server.service.stats.DefaultRuleEngineStatisticsService; @@ -163,7 +165,7 @@ public class BaseQueueControllerTest extends AbstractControllerTest { tenantId, ruleEngineException ))); - TbRuleEngineConsumerStats testStats = new TbRuleEngineConsumerStats(queue, statsFactory); + TbRuleEngineConsumerStats testStats = new TbRuleEngineConsumerStats(new QueueKey(ServiceType.TB_RULE_ENGINE, queue), statsFactory); testStats.log(testProcessingResult, true); int queueStatsTtlDays = 14; @@ -215,7 +217,7 @@ public class BaseQueueControllerTest extends AbstractControllerTest { tenantId, ruleEngineException ))); - TbRuleEngineConsumerStats testStats = new TbRuleEngineConsumerStats(queue, statsFactory); + TbRuleEngineConsumerStats testStats = new TbRuleEngineConsumerStats(new QueueKey(ServiceType.TB_RULE_ENGINE, queue), statsFactory); testStats.log(testProcessingResult, true); ruleEngineStatisticsService.reportQueueStats(System.currentTimeMillis(), testStats); From cf951ee2b22cde58b6fcd39a0f91d13213ce8b25 Mon Sep 17 00:00:00 2001 From: ViacheslavKlimov Date: Tue, 17 Oct 2023 11:23:58 +0300 Subject: [PATCH 17/43] Multiple improvements for Rule Engine consumer services --- .../DefaultTbRuleEngineConsumerService.java | 6 +- .../service/queue/ruleengine/QueueEvent.java | 17 +- .../TbQueueConsumerManagerTask.java | 25 +- .../queue/ruleengine/TbQueueConsumerTask.java | 43 +- .../TbRuleEngineConsumerContext.java | 19 +- .../TbRuleEngineQueueConsumerManager.java | 519 ++++++++++-------- .../server/queue/TbQueueConsumer.java | 6 +- .../AbstractTbQueueConsumerTemplate.java | 39 +- .../queue/kafka/TbKafkaConsumerTemplate.java | 1 - .../queue/memory/InMemoryTbQueueConsumer.java | 17 +- 10 files changed, 384 insertions(+), 308 deletions(-) diff --git a/application/src/main/java/org/thingsboard/server/service/queue/DefaultTbRuleEngineConsumerService.java b/application/src/main/java/org/thingsboard/server/service/queue/DefaultTbRuleEngineConsumerService.java index 164b48c25f..64139530b1 100644 --- a/application/src/main/java/org/thingsboard/server/service/queue/DefaultTbRuleEngineConsumerService.java +++ b/application/src/main/java/org/thingsboard/server/service/queue/DefaultTbRuleEngineConsumerService.java @@ -5,7 +5,7 @@ * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * - * http://www.apache.org/licenses/LICENSE-2.0 + * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, @@ -121,9 +121,7 @@ public class DefaultTbRuleEngineConsumerService extends AbstractConsumerService< } @Override - protected void launchMainConsumers() { - consumers.values().forEach(TbRuleEngineQueueConsumerManager::launchMainConsumer); - } + protected void launchMainConsumers() {} @Override protected void stopConsumers() { diff --git a/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/QueueEvent.java b/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/QueueEvent.java index 4d01d15d9a..a4a3bcc59a 100644 --- a/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/QueueEvent.java +++ b/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/QueueEvent.java @@ -1,9 +1,24 @@ +/** + * Copyright © 2016-2023 The Thingsboard Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ package org.thingsboard.server.service.queue.ruleengine; import java.io.Serializable; public enum QueueEvent implements Serializable { - CREATED, LAUNCHED, UPDATED, PARTITION_CHANGE, STOP, DELETED + PARTITION_CHANGE, CONFIG_UPDATE, STOP, DELETE } diff --git a/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbQueueConsumerManagerTask.java b/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbQueueConsumerManagerTask.java index 5b4f164a10..6f1adbdcf2 100644 --- a/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbQueueConsumerManagerTask.java +++ b/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbQueueConsumerManagerTask.java @@ -15,18 +15,33 @@ */ package org.thingsboard.server.service.queue.ruleengine; -import lombok.Data; -import org.thingsboard.server.common.data.plugin.ComponentLifecycleEvent; +import lombok.Getter; +import lombok.ToString; import org.thingsboard.server.common.data.queue.Queue; import org.thingsboard.server.common.msg.queue.TopicPartitionInfo; import java.util.Set; -@Data +@Getter +@ToString public class TbQueueConsumerManagerTask { private final QueueEvent event; - private final Queue queue; - private final Set partitions; + private Queue queue; + private Set partitions; + + public TbQueueConsumerManagerTask(QueueEvent event) { + this.event = event; + } + + public TbQueueConsumerManagerTask(QueueEvent event, Queue queue) { + this.event = event; + this.queue = queue; + } + + public TbQueueConsumerManagerTask(QueueEvent event, Set partitions) { + this.event = event; + this.partitions = partitions; + } } diff --git a/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbQueueConsumerTask.java b/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbQueueConsumerTask.java index ed1f36074f..a0a5579951 100644 --- a/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbQueueConsumerTask.java +++ b/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbQueueConsumerTask.java @@ -5,7 +5,7 @@ * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * - * http://www.apache.org/licenses/LICENSE-2.0 + * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, @@ -21,51 +21,44 @@ import org.thingsboard.server.common.msg.queue.TopicPartitionInfo; import org.thingsboard.server.gen.transport.TransportProtos; import org.thingsboard.server.queue.TbQueueConsumer; import org.thingsboard.server.queue.common.TbProtoQueueMsg; -import org.thingsboard.server.queue.discovery.QueueKey; import java.util.Set; -import java.util.concurrent.ExecutionException; import java.util.concurrent.Future; import java.util.concurrent.TimeUnit; -import java.util.concurrent.TimeoutException; @Data @Slf4j public class TbQueueConsumerTask { - private final QueueKey key; - private final Object id; + private final Object key; private final TbQueueConsumer> consumer; private volatile Future task; - public void stop() { - this.consumer.stop(); + public void subscribe(Set partitions) { + log.trace("[{}] Subscribing to partitions: {}", key, partitions); + consumer.subscribe(partitions); } - public boolean stopAndAwait() { - this.consumer.stop(); - return await(); + public void initiateStop() { + log.debug("[{}] Initiating stop", key); + consumer.stop(); } - public boolean await() { - if (task != null) { - //TODO: maybe task.cancel() to interrupt the consumer? + public void awaitFinish() { + log.trace("[{}] Awaiting finish", key); + if (isRunning()) { try { - this.task.get(3, TimeUnit.MINUTES); - } catch (ExecutionException | InterruptedException | TimeoutException e) { - log.warn("[{}][{}] Failed to await for consumer to stop", key, id, e); - return false; + task.get(60, TimeUnit.SECONDS); + task = null; + } catch (Exception e) { + log.warn("[{}] Failed to await for consumer to stop", key, e); } } - return true; + log.trace("[{}] Awaited finish", key); } - public void subscribe(Set partitions) { - this.consumer.subscribe(partitions); + public boolean isRunning() { + return task != null && !task.isDone(); } - - public void unsubscribe() { - this.consumer.unsubscribe(); - } } diff --git a/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbRuleEngineConsumerContext.java b/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbRuleEngineConsumerContext.java index c1d17746e1..325a685972 100644 --- a/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbRuleEngineConsumerContext.java +++ b/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbRuleEngineConsumerContext.java @@ -1,3 +1,18 @@ +/** + * Copyright © 2016-2023 The Thingsboard Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ package org.thingsboard.server.service.queue.ruleengine; import lombok.Data; @@ -36,8 +51,8 @@ public class TbRuleEngineConsumerContext { @Value("${queue.rule-engine.stats.enabled:true}") private boolean statsEnabled; @Value("${queue.rule-engine.prometheus-stats.enabled:false}") - boolean prometheusStatsEnabled; - @Value("${queue.rule-engine.topic-deletion-delay:30}") + private boolean prometheusStatsEnabled; + @Value("${queue.rule-engine.topic-deletion-delay:15}") private int topicDeletionDelayInSec; @Value("${queue.rule-engine.management-thread-pool-size:12}") private int mgmtThreadPoolSize; diff --git a/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbRuleEngineQueueConsumerManager.java b/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbRuleEngineQueueConsumerManager.java index 2599a214f0..dc3966d0d2 100644 --- a/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbRuleEngineQueueConsumerManager.java +++ b/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbRuleEngineQueueConsumerManager.java @@ -5,7 +5,7 @@ * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * - * http://www.apache.org/licenses/LICENSE-2.0 + * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, @@ -16,8 +16,7 @@ package org.thingsboard.server.service.queue.ruleengine; import com.google.protobuf.ProtocolStringList; -import lombok.Data; -import lombok.SneakyThrows; +import lombok.Getter; import lombok.extern.slf4j.Slf4j; import org.thingsboard.common.util.ThingsBoardThreadFactory; import org.thingsboard.server.common.data.id.EntityId; @@ -32,11 +31,10 @@ import org.thingsboard.server.common.msg.queue.RuleNodeInfo; import org.thingsboard.server.common.msg.queue.ServiceType; import org.thingsboard.server.common.msg.queue.TbMsgCallback; import org.thingsboard.server.common.msg.queue.TopicPartitionInfo; -import org.thingsboard.server.gen.transport.TransportProtos; +import org.thingsboard.server.gen.transport.TransportProtos.ToRuleEngineMsg; import org.thingsboard.server.queue.TbQueueConsumer; import org.thingsboard.server.queue.common.TbProtoQueueMsg; import org.thingsboard.server.queue.discovery.QueueKey; -import org.thingsboard.server.queue.discovery.event.PartitionChangeEvent; import org.thingsboard.server.service.queue.TbMsgPackCallback; import org.thingsboard.server.service.queue.TbMsgPackProcessingContext; import org.thingsboard.server.service.queue.TbRuleEngineConsumerStats; @@ -45,19 +43,20 @@ import org.thingsboard.server.service.queue.processing.TbRuleEngineProcessingRes import org.thingsboard.server.service.queue.processing.TbRuleEngineProcessingStrategy; import org.thingsboard.server.service.queue.processing.TbRuleEngineSubmitStrategy; +import java.util.Collection; import java.util.Collections; +import java.util.HashMap; import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Set; import java.util.UUID; -import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentLinkedQueue; -import java.util.concurrent.ConcurrentMap; +import java.util.concurrent.Future; import java.util.concurrent.TimeUnit; import java.util.concurrent.locks.ReentrantLock; +import java.util.stream.Collectors; -@Data @Slf4j public class TbRuleEngineQueueConsumerManager { @@ -65,87 +64,83 @@ public class TbRuleEngineQueueConsumerManager { public static final String FAILED_STATUS = "failed"; private final TbRuleEngineConsumerContext ctx; - private final QueueKey key; - - private final ReentrantLock lock = new ReentrantLock(); //NonfairSync - private final ConcurrentMap consumersPerPartition = new ConcurrentHashMap<>(); + private final QueueKey queueKey; private final TbRuleEngineConsumerStats stats; + private final ReentrantLock lock = new ReentrantLock(); //NonfairSync - private volatile Set partitions = Collections.emptySet(); + @Getter private volatile Queue queue; - private volatile TbQueueConsumerTask mainConsumer; + @Getter + private volatile Set partitions; + private volatile ConsumerWrapper consumerWrapper; + + private volatile boolean stopped; private final java.util.Queue tasks = new ConcurrentLinkedQueue<>(); - public TbRuleEngineQueueConsumerManager(TbRuleEngineConsumerContext ctx, QueueKey key) { + public TbRuleEngineQueueConsumerManager(TbRuleEngineConsumerContext ctx, QueueKey queueKey) { this.ctx = ctx; - this.key = key; - this.stats = new TbRuleEngineConsumerStats(key, ctx.getStatsFactory()); + this.queueKey = queueKey; + this.stats = new TbRuleEngineConsumerStats(queueKey, ctx.getStatsFactory()); } public void init(Queue queue) { - processTask(new TbQueueConsumerManagerTask(QueueEvent.CREATED, queue, null)); + doInit(queue); } public void update(Queue queue) { - processTask(new TbQueueConsumerManagerTask(QueueEvent.UPDATED, queue, null)); + addTask(new TbQueueConsumerManagerTask(QueueEvent.CONFIG_UPDATE, queue)); } - public void subscribe(PartitionChangeEvent event) { - processTask(new TbQueueConsumerManagerTask(QueueEvent.PARTITION_CHANGE, queue, event.getPartitions())); - } - - public void launchMainConsumer() { - processTask(new TbQueueConsumerManagerTask(QueueEvent.LAUNCHED, null, null)); + public void update(Set partitions) { + addTask(new TbQueueConsumerManagerTask(QueueEvent.PARTITION_CHANGE, partitions)); } public void stop() { - processTask(new TbQueueConsumerManagerTask(QueueEvent.STOP, null, null)); + addTask(new TbQueueConsumerManagerTask(QueueEvent.STOP)); } public void delete() { - processTask(new TbQueueConsumerManagerTask(QueueEvent.DELETED, null, null)); + addTask(new TbQueueConsumerManagerTask(QueueEvent.DELETE)); } - private void processTask(TbQueueConsumerManagerTask todo) { + private void addTask(TbQueueConsumerManagerTask todo) { + if (stopped) { + return; + } tasks.add(todo); - log.info("[{}] Adding task: {}", key, todo); + log.trace("[{}] Added task: {}", queueKey, todo); tryProcessTasks(); } private void tryProcessTasks() { + if (!ctx.isReady()) { + log.debug("[{}] TbRuleEngineConsumerContext is not ready yet, will process tasks later", queueKey); + ctx.getScheduler().schedule(this::tryProcessTasks, 1, TimeUnit.SECONDS); + return; + } ctx.getMgmtExecutor().submit(() -> { if (lock.tryLock()) { try { Queue newConfiguration = null; Set newPartitions = null; - while (!tasks.isEmpty()) { + while (!stopped) { TbQueueConsumerManagerTask task = tasks.poll(); - switch (task.getEvent()) { - case CREATED: - doInit(task.getQueue()); - break; - case LAUNCHED: - if (!queue.isConsumerPerPartition()) { - doLaunchMainConsumer(); - } - break; - case UPDATED: - newConfiguration = task.getQueue(); - break; - case PARTITION_CHANGE: - newPartitions = task.getPartitions(); - break; - case STOP: - newConfiguration = null; - newPartitions = null; - doStop(); - break; - case DELETED: - newConfiguration = null; - newPartitions = null; - doDelete(); - break; + if (task == null) { + break; + } + log.trace("[{}] Processing task: {}", queueKey, task); + + if (task.getEvent() == QueueEvent.PARTITION_CHANGE) { + newPartitions = task.getPartitions(); + } else if (task.getEvent() == QueueEvent.CONFIG_UPDATE) { + newConfiguration = task.getQueue(); + } else if (task.getEvent() == QueueEvent.STOP) { + doStop(); + return; + } else if (task.getEvent() == QueueEvent.DELETE) { + doDelete(); + return; } } if (newConfiguration != null) { @@ -158,158 +153,108 @@ public class TbRuleEngineQueueConsumerManager { lock.unlock(); } } else { - log.debug("[{}] Failed to acquire lock.", key); + log.trace("[{}] Failed to acquire lock", queueKey); ctx.getScheduler().schedule(this::tryProcessTasks, 1, TimeUnit.SECONDS); } }); } - public void doInit(Queue queue) { - log.info("[{}] Init consumer with queue: {}", key, queue); + private void doInit(Queue queue) { this.queue = queue; if (queue.isConsumerPerPartition()) { - log.debug("[{}] Ignore init event since isConsumerPerPartition is enabled.", key); + consumerWrapper = new ConsumerPerPartitionWrapper(); } else { - mainConsumer = new TbQueueConsumerTask(key, "main", ctx.getQueueFactory().createToRuleEngineMsgConsumer(queue)); - } - } - - private void doLaunchMainConsumer() { - if (mainConsumer != null) { - launchConsumer(mainConsumer, queue, mainConsumer.getId(), queue.getName()); - } else { - log.warn("[{}] Can't launch main consumer since it is empty!", key); + consumerWrapper = new SingleConsumerWrapper(); } + log.debug("[{}] Initialized consumer for queue: {}", queueKey, queue); } private void doUpdate(Queue newQueue) { - log.info("[{}] Processing queue update: {}", key, newQueue); - var oldQueue = queue; + log.info("[{}] Processing queue update: {}", queueKey, newQueue); + var oldQueue = this.queue; + this.queue = newQueue; if (log.isTraceEnabled()) { - log.trace("[{}] Old queue configuration: {}", key, oldQueue); - log.trace("[{}] New queue configuration: {}", key, newQueue); - } - if (oldQueue != null) { - doStop(oldQueue); - } - doInit(newQueue); - if (!newQueue.isConsumerPerPartition()) { - doLaunchMainConsumer(); + log.trace("[{}] Old queue configuration: {}", queueKey, oldQueue); + log.trace("[{}] New queue configuration: {}", queueKey, newQueue); } - } - - private void doUpdate(Set partitions) { - log.info("[{}] Subscribing to partitions: {}", key, partitions); - if (queue.isConsumerPerPartition()) { - log.debug("[{}] Subscribing consumers per partition separately: {}", key, partitions); - Set addedPartitions = new HashSet<>(partitions); - addedPartitions.removeAll(consumersPerPartition.keySet()); - log.info("calculated addedPartitions {}", addedPartitions); - - Set removedPartitions = new HashSet<>(consumersPerPartition.keySet()); - removedPartitions.removeAll(partitions); - log.info("calculated removedPartitions {}", removedPartitions); - removedPartitions.forEach((tpi) -> { - log.info("[{}] Unsubscribing from topic: {}", queue, tpi); - consumersPerPartition.get(tpi).unsubscribe(); - }); + if (oldQueue == null) { + doInit(queue); + } else if (newQueue.isConsumerPerPartition() != oldQueue.isConsumerPerPartition()) { + consumerWrapper.getConsumers().forEach(TbQueueConsumerTask::initiateStop); + consumerWrapper.getConsumers().forEach(TbQueueConsumerTask::awaitFinish); - removedPartitions.forEach((tpi) -> { - log.info("[{}] Removing consumer for topic: {}", queue, tpi); - consumersPerPartition.get(tpi).stopAndAwait(); - consumersPerPartition.remove(tpi); - }); - - addedPartitions.forEach((tpi) -> { - log.info("[{}] Adding consumer for topic: {}", key, tpi); - TbQueueConsumerTask consumerTask = new TbQueueConsumerTask(key, tpi, ctx.getQueueFactory().createToRuleEngineMsgConsumer(queue)); - consumersPerPartition.put(tpi, consumerTask); - //TODO: Is it ok to subscribe first? - consumerTask.subscribe(Collections.singleton(tpi)); - launchConsumer(consumerTask, queue, mainConsumer.getId(), key + "-" + tpi.getPartition().orElse(-999999)); - }); + doInit(queue); + if (partitions != null) { + doUpdate(partitions); // even if partitions number was changed, there can be no partition change event + } } else { - mainConsumer.subscribe(partitions); + // do nothing, because partitions change (if they changed) will be handled on PartitionChangeEvent, + // and changes to pollInterval/packProcessingTimeout/submitStrategy/processingStrategy will be picked up by consumer on the fly, + // and queue topic and name are immutable } } - private void doStop() { - doStop(queue); + private void doUpdate(Set partitions) { + this.partitions = partitions; + consumerWrapper.updatePartitions(partitions); } - private void doStop(Queue queue) { - if (queue.isConsumerPerPartition()) { - consumersPerPartition.values().forEach(TbQueueConsumerTask::unsubscribe); - consumersPerPartition.values().forEach(TbQueueConsumerTask::stopAndAwait); - } else if (mainConsumer != null) { - mainConsumer.unsubscribe(); - mainConsumer.stopAndAwait(); - } + private void doStop() { + consumerWrapper.getConsumers().forEach(TbQueueConsumerTask::initiateStop); + consumerWrapper.getConsumers().forEach(TbQueueConsumerTask::awaitFinish); + log.debug("[{}] Unsubscribed and stopped consumers", queueKey); + stopped = true; } private void doDelete() { - doStop(); - //TODO: repack messages + stopped = true; + log.info("[{}] Handling queue deletion", queueKey); + consumerWrapper.getConsumers().forEach(TbQueueConsumerTask::awaitFinish); + + List>> queueConsumers = consumerWrapper.getConsumers().stream() + .map(TbQueueConsumerTask::getConsumer).collect(Collectors.toList()); + ctx.getConsumersExecutor().submit(() -> { + drainQueue(queueConsumers); + + queueConsumers.forEach(consumer -> { + for (String topic : consumer.getFullTopicNames()) { + try { + ctx.getQueueAdmin().deleteTopic(topic); + log.info("Deleted topic {}", topic); + } catch (Exception e) { + log.error("Failed to delete topic {}", topic, e); + } + } + try { + consumer.unsubscribe(); + } catch (Exception e) { + log.error("[{}] Failed to unsubscribe consumer", queueKey, e); + } + }); + }); } - @SneakyThrows - void launchConsumer(TbQueueConsumerTask consumerTask, Queue configuration, Object consumerKey, String threadSuffix) { - log.info("[{}] Launching consumer: [{}]", key, consumerKey); - while (!ctx.isReady) { - //TODO: Remember this task. Cancel previous task if needed. - log.debug("[{}][{}] Waiting for consumer to get ready..", key, consumerKey); - Thread.sleep(1000); - } - consumerTask.setTask(ctx.getConsumersExecutor().submit(() -> consumerLoop(consumerTask.getConsumer(), configuration, threadSuffix))); + private void launchConsumer(TbQueueConsumerTask consumerTask) { + log.info("[{}] Launching consumer", consumerTask.getKey()); + Future consumerLoop = ctx.getConsumersExecutor().submit(() -> { + ThingsBoardThreadFactory.updateCurrentThreadName(consumerTask.getKey().toString()); + consumerLoop(consumerTask.getConsumer()); + }); + consumerTask.setTask(consumerLoop); } - void consumerLoop(TbQueueConsumer> consumer, Queue configuration, String threadSuffix) { - ThingsBoardThreadFactory.updateCurrentThreadName(threadSuffix); - while (!ctx.stopped && !consumer.isStopped() - //TODO: remove this. - && !consumer.isQueueDeleted()) { + private void consumerLoop(TbQueueConsumer> consumer) { + while (!stopped && !consumer.isStopped()) { try { - List> msgs = consumer.poll(queue.getPollInterval()); + List> msgs = consumer.poll(queue.getPollInterval()); if (msgs.isEmpty()) { continue; } - final TbRuleEngineSubmitStrategy submitStrategy = getSubmitStrategy(queue); - final TbRuleEngineProcessingStrategy ackStrategy = getProcessingStrategy(queue); - submitStrategy.init(msgs); - while (!ctx.isStopped() && !consumer.isStopped()) { - TbMsgPackProcessingContext packCtx = new TbMsgPackProcessingContext(queue.getName(), submitStrategy, ackStrategy.isSkipTimeoutMsgs()); - submitStrategy.submitAttempt((id, msg) -> ctx.getSubmitExecutor().submit(() -> submitMessage(configuration, stats, packCtx, id, msg))); - - final boolean timeout = !packCtx.await(configuration.getPackProcessingTimeout(), TimeUnit.MILLISECONDS); - - TbRuleEngineProcessingResult result = new TbRuleEngineProcessingResult(configuration.getName(), timeout, packCtx); - if (timeout) { - printFirstOrAll(configuration, packCtx, packCtx.getPendingMap(), "Timeout"); - } - if (!packCtx.getFailedMap().isEmpty()) { - printFirstOrAll(configuration, packCtx, packCtx.getFailedMap(), "Failed"); - } - packCtx.printProfilerStats(); - - TbRuleEngineProcessingDecision decision = ackStrategy.analyze(result); - if (ctx.isStatsEnabled()) { - stats.log(result, decision.isCommit()); - } - - packCtx.cleanup(); - - if (decision.isCommit()) { - submitStrategy.stop(); - break; - } else { - submitStrategy.update(decision.getReprocessMap()); - } - } - consumer.commit(); + processMsgs(msgs, consumer, queue); } catch (Exception e) { - if (!ctx.stopped) { - log.warn("Failed to process messages from queue.", e); + if (!stopped) { + log.warn("Failed to process messages from queue", e); try { Thread.sleep(ctx.getPollDuration()); } catch (InterruptedException e2) { @@ -318,72 +263,68 @@ public class TbRuleEngineQueueConsumerManager { } } } - //TODO: refactor and move to the "doDelete" method. Use separate consumer if needed (it is still synchronous). - if (consumer.isQueueDeleted()) { - processQueueDeletion(configuration, consumer); + if (consumer.isStopped()) { + consumer.unsubscribe(); } - log.info("TB Rule Engine Consumer stopped."); + log.info("Rule Engine consumer stopped"); } - private void processQueueDeletion(Queue queue, TbQueueConsumer> consumer) { -// long finishTs = System.currentTimeMillis() + TimeUnit.SECONDS.toMillis(topicDeletionDelayInSec); -// try { -// int n = 0; -// while (System.currentTimeMillis() <= finishTs) { -// List> msgs = consumer.poll(queue.getPollInterval()); -// if (msgs.isEmpty()) { -// continue; -// } -// for (TbProtoQueueMsg msg : msgs) { -// try { -// MsgProtos.TbMsgProto tbMsgProto = MsgProtos.TbMsgProto.parseFrom(msg.getValue().getTbMsg().toByteArray()); -// EntityId originator = EntityIdFactory.getByTypeAndUuid(tbMsgProto.getEntityType(), new UUID(tbMsgProto.getEntityIdMSB(), tbMsgProto.getEntityIdLSB())); -// -// TopicPartitionInfo tpi = partitionService.resolve(ServiceType.TB_RULE_ENGINE, queue.getName(), TenantId.SYS_TENANT_ID, originator); -// producerProvider.getRuleEngineMsgProducer().send(tpi, msg, null); -// n++; -// } catch (Throwable e) { -// log.debug("Failed to move message to system {}: {}", consumer.getTopic(), msg, e); -// } -// } -// consumer.commit(); -// } -// if (n > 0) { -// log.info("Moved {} messages from {} to system {}", n, consumer.getFullTopicNames(), consumer.getTopic()); -// } -// -// consumer.unsubscribe(); -// for (String topic : consumer.getFullTopicNames()) { -// try { -// queueAdmin.deleteTopic(topic); -// log.info("Deleted topic {}", topic); -// } catch (Exception e) { -// log.error("Failed to delete topic {} after unsubscribing", topic, e); -// } -// } -// } catch (Exception e) { -// log.error("Failed to process deletion of {} ({})", consumer.getTopic(), queue.getTenantId(), e); -// } + private void processMsgs(List> msgs, + TbQueueConsumer> consumer, + Queue queue) throws InterruptedException { + TbRuleEngineSubmitStrategy submitStrategy = getSubmitStrategy(queue); + TbRuleEngineProcessingStrategy ackStrategy = getProcessingStrategy(queue); + submitStrategy.init(msgs); + while (!stopped && !consumer.isStopped()) { + TbMsgPackProcessingContext packCtx = new TbMsgPackProcessingContext(queue.getName(), submitStrategy, ackStrategy.isSkipTimeoutMsgs()); + submitStrategy.submitAttempt((id, msg) -> submitMessage(packCtx, id, msg)); + + final boolean timeout = !packCtx.await(queue.getPackProcessingTimeout(), TimeUnit.MILLISECONDS); + + TbRuleEngineProcessingResult result = new TbRuleEngineProcessingResult(queue.getName(), timeout, packCtx); + if (timeout) { + printFirstOrAll(packCtx, packCtx.getPendingMap(), "Timeout"); + } + if (!packCtx.getFailedMap().isEmpty()) { + printFirstOrAll(packCtx, packCtx.getFailedMap(), "Failed"); + } + packCtx.printProfilerStats(); + + TbRuleEngineProcessingDecision decision = ackStrategy.analyze(result); + if (ctx.isStatsEnabled()) { + stats.log(result, decision.isCommit()); + } + + packCtx.cleanup(); + + if (decision.isCommit()) { + submitStrategy.stop(); + consumer.commit(); + break; + } else { + submitStrategy.update(decision.getReprocessMap()); + } + } } - TbRuleEngineSubmitStrategy getSubmitStrategy(Queue configuration) { - return ctx.getSubmitStrategyFactory().newInstance(configuration.getName(), configuration.getSubmitStrategy()); + private TbRuleEngineSubmitStrategy getSubmitStrategy(Queue queue) { + return ctx.getSubmitStrategyFactory().newInstance(queue.getName(), queue.getSubmitStrategy()); } - TbRuleEngineProcessingStrategy getProcessingStrategy(Queue configuration) { - return ctx.getProcessingStrategyFactory().newInstance(configuration.getName(), configuration.getProcessingStrategy()); + private TbRuleEngineProcessingStrategy getProcessingStrategy(Queue queue) { + return ctx.getProcessingStrategyFactory().newInstance(queue.getName(), queue.getProcessingStrategy()); } - void submitMessage(Queue configuration, TbRuleEngineConsumerStats stats, TbMsgPackProcessingContext packCtx, UUID id, TbProtoQueueMsg msg) { - log.trace("[{}] Creating callback for topic {} message: {}", id, configuration.getName(), msg.getValue()); - TransportProtos.ToRuleEngineMsg toRuleEngineMsg = msg.getValue(); + private void submitMessage(TbMsgPackProcessingContext packCtx, UUID id, TbProtoQueueMsg msg) { + log.trace("[{}] Creating callback for topic {} message: {}", id, queue.getName(), msg.getValue()); + ToRuleEngineMsg toRuleEngineMsg = msg.getValue(); TenantId tenantId = TenantId.fromUUID(new UUID(toRuleEngineMsg.getTenantIdMSB(), toRuleEngineMsg.getTenantIdLSB())); - TbMsgCallback callback = ctx.prometheusStatsEnabled ? + TbMsgCallback callback = ctx.isPrometheusStatsEnabled() ? new TbMsgPackCallback(id, tenantId, packCtx, stats.getTimer(tenantId, SUCCESSFUL_STATUS), stats.getTimer(tenantId, FAILED_STATUS)) : new TbMsgPackCallback(id, tenantId, packCtx); try { if (!toRuleEngineMsg.getTbMsg().isEmpty()) { - forwardToRuleEngineActor(configuration.getName(), tenantId, toRuleEngineMsg, callback); + forwardToRuleEngineActor(queue.getName(), tenantId, toRuleEngineMsg, callback); } else { callback.onSuccess(); } @@ -392,7 +333,7 @@ public class TbRuleEngineQueueConsumerManager { } } - private void forwardToRuleEngineActor(String queueName, TenantId tenantId, TransportProtos.ToRuleEngineMsg toRuleEngineMsg, TbMsgCallback callback) { + private void forwardToRuleEngineActor(String queueName, TenantId tenantId, ToRuleEngineMsg toRuleEngineMsg, TbMsgCallback callback) { TbMsg tbMsg = TbMsg.fromBytes(queueName, toRuleEngineMsg.getTbMsg().toByteArray(), callback); QueueToRuleEngineMsg msg; ProtocolStringList relationTypesList = toRuleEngineMsg.getRelationTypesList(); @@ -406,16 +347,15 @@ public class TbRuleEngineQueueConsumerManager { ctx.getActorContext().tell(msg); } - - private void printFirstOrAll(Queue configuration, TbMsgPackProcessingContext ctx, Map> map, String prefix) { + private void printFirstOrAll(TbMsgPackProcessingContext ctx, Map> map, String prefix) { boolean printAll = log.isTraceEnabled(); - log.info("{} to process [{}] messages", prefix, map.size()); - for (Map.Entry> pending : map.entrySet()) { - TransportProtos.ToRuleEngineMsg tmp = pending.getValue().getValue(); - TbMsg tmpMsg = TbMsg.fromBytes(configuration.getName(), tmp.getTbMsg().toByteArray(), TbMsgCallback.EMPTY); + log.info("[{}] {} to process [{}] messages", queueKey, prefix, map.size()); + for (Map.Entry> pending : map.entrySet()) { + ToRuleEngineMsg tmp = pending.getValue().getValue(); + TbMsg tmpMsg = TbMsg.fromBytes(queue.getName(), tmp.getTbMsg().toByteArray(), TbMsgCallback.EMPTY); RuleNodeInfo ruleNodeInfo = ctx.getLastVisitedRuleNode(pending.getKey()); if (printAll) { - log.trace("[{}] {} to process message: {}, Last Rule Node: {}", TenantId.fromUUID(new UUID(tmp.getTenantIdMSB(), tmp.getTenantIdLSB())), prefix, tmpMsg, ruleNodeInfo); + log.trace("[{}][{}] {} to process message: {}, Last Rule Node: {}", queueKey, TenantId.fromUUID(new UUID(tmp.getTenantIdMSB(), tmp.getTenantIdLSB())), prefix, tmpMsg, ruleNodeInfo); } else { log.info("[{}] {} to process message: {}, Last Rule Node: {}", TenantId.fromUUID(new UUID(tmp.getTenantIdMSB(), tmp.getTenantIdLSB())), prefix, tmpMsg, ruleNodeInfo); break; @@ -428,4 +368,117 @@ public class TbRuleEngineQueueConsumerManager { ctx.getStatisticsService().reportQueueStats(ts, stats); stats.reset(); } + + private void drainQueue(List>> consumers) { + long finishTs = System.currentTimeMillis() + TimeUnit.SECONDS.toMillis(ctx.getTopicDeletionDelayInSec()); + try { + int n = 0; + while (System.currentTimeMillis() <= finishTs) { + for (TbQueueConsumer> consumer : consumers) { + List> msgs = consumer.poll(queue.getPollInterval()); + if (msgs.isEmpty()) { + continue; + } + for (TbProtoQueueMsg msg : msgs) { + try { + MsgProtos.TbMsgProto tbMsgProto = MsgProtos.TbMsgProto.parseFrom(msg.getValue().getTbMsg().toByteArray()); + EntityId originator = EntityIdFactory.getByTypeAndUuid(tbMsgProto.getEntityType(), new UUID(tbMsgProto.getEntityIdMSB(), tbMsgProto.getEntityIdLSB())); + + TopicPartitionInfo tpi = ctx.getPartitionService().resolve(ServiceType.TB_RULE_ENGINE, queue.getName(), TenantId.SYS_TENANT_ID, originator); + ctx.getProducerProvider().getRuleEngineMsgProducer().send(tpi, msg, null); + n++; + } catch (Throwable e) { + log.warn("Failed to move message to system {}: {}", consumer.getTopic(), msg, e); + } + } + consumer.commit(); + } + } + if (n > 0) { + log.info("Moved {} messages from {} to system {}", n, queueKey, queue.getName()); + } + } catch (Exception e) { + log.error("[{}] Failed to drain queue", queueKey, e); + } + } + + private static String partitionsToString(Collection partitions) { + return partitions.stream().map(TopicPartitionInfo::getFullTopicName).collect(Collectors.joining(", ", "[", "]")); + } + + interface ConsumerWrapper { + + void updatePartitions(Set partitions); + + Collection getConsumers(); + + } + + class ConsumerPerPartitionWrapper implements ConsumerWrapper { + private final Map consumers = new HashMap<>(); + + @Override + public void updatePartitions(Set partitions) { + Set addedPartitions = new HashSet<>(partitions); + addedPartitions.removeAll(consumers.keySet()); + + Set removedPartitions = new HashSet<>(consumers.keySet()); + removedPartitions.removeAll(partitions); + log.info("[{}] Added partitions: {}, removed partitions: {}", queueKey, partitionsToString(addedPartitions), partitionsToString(removedPartitions)); + + removedPartitions.forEach((tpi) -> { + consumers.get(tpi).initiateStop(); + }); + removedPartitions.forEach((tpi) -> { + consumers.remove(tpi).awaitFinish(); + }); + + addedPartitions.forEach((tpi) -> { + String key = queueKey + "-" + tpi.getPartition().orElse(-999999); + TbQueueConsumerTask consumer = new TbQueueConsumerTask(key, ctx.getQueueFactory().createToRuleEngineMsgConsumer(queue)); + consumers.put(tpi, consumer); + consumer.subscribe(Set.of(tpi)); + launchConsumer(consumer); + }); + } + + @Override + public Collection getConsumers() { + return consumers.values(); + } + } + + class SingleConsumerWrapper implements ConsumerWrapper { + private TbQueueConsumerTask consumer; + + @Override + public void updatePartitions(Set partitions) { + log.info("[{}] New partitions: {}", queueKey, partitionsToString(partitions)); + if (partitions.isEmpty()) { + if (consumer != null && consumer.isRunning()) { + consumer.initiateStop(); + consumer.awaitFinish(); + } + consumer = null; + return; + } + + if (consumer == null) { + consumer = new TbQueueConsumerTask(queueKey, ctx.getQueueFactory().createToRuleEngineMsgConsumer(queue)); + } + consumer.subscribe(partitions); + if (!consumer.isRunning()) { + launchConsumer(consumer); + } + } + + @Override + public Collection getConsumers() { + if (consumer == null) { + return Collections.emptyList(); + } + return List.of(consumer); + } + } + } diff --git a/common/cluster-api/src/main/java/org/thingsboard/server/queue/TbQueueConsumer.java b/common/cluster-api/src/main/java/org/thingsboard/server/queue/TbQueueConsumer.java index 9c41f9d342..21216e164e 100644 --- a/common/cluster-api/src/main/java/org/thingsboard/server/queue/TbQueueConsumer.java +++ b/common/cluster-api/src/main/java/org/thingsboard/server/queue/TbQueueConsumer.java @@ -28,6 +28,8 @@ public interface TbQueueConsumer { void subscribe(Set partitions); + void stop(); + void unsubscribe(); List poll(long durationInMillis); @@ -36,10 +38,6 @@ public interface TbQueueConsumer { boolean isStopped(); - void onQueueDelete(); - - boolean isQueueDeleted(); - List getFullTopicNames(); } diff --git a/common/queue/src/main/java/org/thingsboard/server/queue/common/AbstractTbQueueConsumerTemplate.java b/common/queue/src/main/java/org/thingsboard/server/queue/common/AbstractTbQueueConsumerTemplate.java index 2ebe41850d..073371ebb5 100644 --- a/common/queue/src/main/java/org/thingsboard/server/queue/common/AbstractTbQueueConsumerTemplate.java +++ b/common/queue/src/main/java/org/thingsboard/server/queue/common/AbstractTbQueueConsumerTemplate.java @@ -44,7 +44,6 @@ public abstract class AbstractTbQueueConsumerTemplate i protected volatile Set partitions; protected final ReentrantLock consumerLock = new ReentrantLock(); //NonfairSync final Queue> subscribeQueue = new ConcurrentLinkedQueue<>(); - protected volatile boolean queueDeleted = false; @Getter private final String topic; @@ -55,7 +54,7 @@ public abstract class AbstractTbQueueConsumerTemplate i @Override public void subscribe() { - log.info("enqueue topic subscribe {} ", topic); + log.debug("enqueue topic subscribe {} ", topic); if (stopped) { log.error("trying subscribe, but consumer stopped for topic {}", topic); return; @@ -65,7 +64,7 @@ public abstract class AbstractTbQueueConsumerTemplate i @Override public void subscribe(Set partitions) { - log.info("enqueue topics subscribe {} ", partitions); + log.debug("enqueue topics subscribe {} ", partitions); if (stopped) { log.error("trying subscribe, but consumer stopped for topic {}", topic); return; @@ -78,7 +77,8 @@ public abstract class AbstractTbQueueConsumerTemplate i List records; long startNanos = System.nanoTime(); if (stopped) { - return errorAndReturnEmpty(); + log.error("poll invoked but consumer stopped for topic " + topic, new RuntimeException("stacktrace")); + return emptyList(); } if (!subscribed && partitions == null && subscribeQueue.isEmpty()) { return sleepAndReturnEmpty(startNanos, durationInMillis); @@ -96,6 +96,7 @@ public abstract class AbstractTbQueueConsumerTemplate i } if (!subscribed) { List topicNames = getFullTopicNames(); + log.info("Subscribing to topics {}", topicNames); doSubscribe(topicNames); subscribed = true; } @@ -127,11 +128,6 @@ public abstract class AbstractTbQueueConsumerTemplate i return result; } - List errorAndReturnEmpty() { - log.error("poll invoked but consumer stopped for topic" + topic, new RuntimeException("stacktrace")); - return emptyList(); - } - List sleepAndReturnEmpty(final long startNanos, final long durationInMillis) { long durationNanos = TimeUnit.MILLISECONDS.toNanos(durationInMillis); long spentNanos = System.nanoTime() - startNanos; @@ -163,15 +159,20 @@ public abstract class AbstractTbQueueConsumerTemplate i } } + @Override + public void stop() { + stopped = true; + } + @Override public void unsubscribe() { - log.info("Unsubscribing from topics and stopping consumer for topics {}", partitions.stream() - .map(TopicPartitionInfo::getFullTopicName) - .collect(Collectors.joining(", "))); + log.info("Unsubscribing and stopping consumer for topics {}", getFullTopicNames()); stopped = true; consumerLock.lock(); try { - doUnsubscribe(); + if (subscribed) { + doUnsubscribe(); + } } finally { consumerLock.unlock(); } @@ -192,17 +193,11 @@ public abstract class AbstractTbQueueConsumerTemplate i abstract protected void doUnsubscribe(); - @Override - public void onQueueDelete() { - queueDeleted = true; - } - - public boolean isQueueDeleted() { - return queueDeleted; - } - @Override public List getFullTopicNames() { + if (partitions == null) { + return Collections.emptyList(); + } return partitions.stream().map(TopicPartitionInfo::getFullTopicName).collect(Collectors.toList()); } diff --git a/common/queue/src/main/java/org/thingsboard/server/queue/kafka/TbKafkaConsumerTemplate.java b/common/queue/src/main/java/org/thingsboard/server/queue/kafka/TbKafkaConsumerTemplate.java index 9f58446966..ff3f0cc9b3 100644 --- a/common/queue/src/main/java/org/thingsboard/server/queue/kafka/TbKafkaConsumerTemplate.java +++ b/common/queue/src/main/java/org/thingsboard/server/queue/kafka/TbKafkaConsumerTemplate.java @@ -73,7 +73,6 @@ public class TbKafkaConsumerTemplate extends AbstractTbQue protected void doSubscribe(List topicNames) { if (!topicNames.isEmpty()) { topicNames.forEach(admin::createTopicIfNotExists); - log.info("subscribe topics {}", topicNames); consumer.subscribe(topicNames); } else { log.info("unsubscribe due to empty topic list"); diff --git a/common/queue/src/main/java/org/thingsboard/server/queue/memory/InMemoryTbQueueConsumer.java b/common/queue/src/main/java/org/thingsboard/server/queue/memory/InMemoryTbQueueConsumer.java index 8711cbbcf1..a7f8cadd0d 100644 --- a/common/queue/src/main/java/org/thingsboard/server/queue/memory/InMemoryTbQueueConsumer.java +++ b/common/queue/src/main/java/org/thingsboard/server/queue/memory/InMemoryTbQueueConsumer.java @@ -31,7 +31,6 @@ public class InMemoryTbQueueConsumer implements TbQueueCon private volatile Set partitions; private volatile boolean stopped; private volatile boolean subscribed; - private volatile boolean queueDeleted; public InMemoryTbQueueConsumer(InMemoryStorage storage, String topic) { this.storage = storage; @@ -58,9 +57,15 @@ public class InMemoryTbQueueConsumer implements TbQueueCon subscribed = true; } + @Override + public void stop() { + stopped = true; + } + @Override public void unsubscribe() { stopped = true; + subscribed = false; } @Override @@ -104,16 +109,6 @@ public class InMemoryTbQueueConsumer implements TbQueueCon return stopped; } - @Override - public void onQueueDelete() { - queueDeleted = true; - } - - @Override - public boolean isQueueDeleted() { - return queueDeleted; - } - @Override public List getFullTopicNames() { return partitions.stream().map(TopicPartitionInfo::getFullTopicName).collect(Collectors.toList()); From 921b2ae4b7d41b58c616b79d3d62bce70ea6182b Mon Sep 17 00:00:00 2001 From: ViacheslavKlimov Date: Tue, 17 Oct 2023 11:24:33 +0300 Subject: [PATCH 18/43] Tests for Rule Engine consumer manager --- .../controller/TenantControllerTest.java | 40 +- .../TbRuleEngineQueueConsumerManagerTest.java | 780 ++++++++++++++++++ 2 files changed, 801 insertions(+), 19 deletions(-) create mode 100644 application/src/test/java/org/thingsboard/server/service/queue/ruleengine/TbRuleEngineQueueConsumerManagerTest.java diff --git a/application/src/test/java/org/thingsboard/server/controller/TenantControllerTest.java b/application/src/test/java/org/thingsboard/server/controller/TenantControllerTest.java index 4b594d55f9..d1aefc097f 100644 --- a/application/src/test/java/org/thingsboard/server/controller/TenantControllerTest.java +++ b/application/src/test/java/org/thingsboard/server/controller/TenantControllerTest.java @@ -42,6 +42,7 @@ import org.thingsboard.server.common.data.TenantProfile; import org.thingsboard.server.common.data.User; import org.thingsboard.server.common.data.id.EntityId; import org.thingsboard.server.common.data.id.TenantId; +import org.thingsboard.server.common.data.msg.TbMsgType; import org.thingsboard.server.common.data.page.PageData; import org.thingsboard.server.common.data.page.PageLink; import org.thingsboard.server.common.data.plugin.ComponentLifecycleEvent; @@ -54,12 +55,12 @@ import org.thingsboard.server.common.data.security.Authority; import org.thingsboard.server.common.data.tenant.profile.DefaultTenantProfileConfiguration; import org.thingsboard.server.common.data.tenant.profile.TenantProfileData; import org.thingsboard.server.common.data.tenant.profile.TenantProfileQueueConfiguration; -import org.thingsboard.server.dao.service.DaoSqlTest; import org.thingsboard.server.common.msg.TbMsg; import org.thingsboard.server.common.msg.TbMsgMetaData; import org.thingsboard.server.common.msg.queue.QueueToRuleEngineMsg; import org.thingsboard.server.common.msg.queue.ServiceType; import org.thingsboard.server.common.msg.queue.TopicPartitionInfo; +import org.thingsboard.server.dao.service.DaoSqlTest; import org.thingsboard.server.gen.transport.TransportProtos; import org.thingsboard.server.queue.TbQueueAdmin; import org.thingsboard.server.queue.discovery.PartitionService; @@ -67,9 +68,7 @@ import org.thingsboard.server.queue.discovery.PartitionService; import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; -import java.util.Deque; import java.util.HashMap; -import java.util.LinkedList; import java.util.List; import java.util.Map; import java.util.Random; @@ -680,26 +679,29 @@ public class TenantControllerTest extends AbstractControllerTest { .until(() -> partitionService.resolve(ServiceType.TB_RULE_ENGINE, MAIN_QUEUE_NAME, tenantId, tenantId) .getTenantId().get().isSysTenantId()); - Deque submittedMsgs = new LinkedList<>(); - await().atLeast(8, TimeUnit.SECONDS) // due to topic-deletion-delay - .atMost(20, TimeUnit.SECONDS) - .pollInterval(1, TimeUnit.SECONDS) - .untilAsserted(() -> { - TbMsg tbMsg = publishTbMsg(tenantId, tpi); - submittedMsgs.add(tbMsg.getId()); - - verify(queueAdmin, times(1)).deleteTopic(eq(isolatedTopic)); - }); - submittedMsgs.removeLast(); - for (UUID msgId : submittedMsgs) { - verify(actorContext, timeout(2000)).tell(argThat(msg -> { - return msg instanceof QueueToRuleEngineMsg && ((QueueToRuleEngineMsg) msg).getMsg().getId().equals(msgId); - })); + List submittedMsgs = new ArrayList<>(); + long timeLeft = TimeUnit.SECONDS.toMillis(7); // based on topic-deletion-delay + int msgs = 100; + for (int i = 1; i <= msgs; i++) { + TbMsg tbMsg = publishTbMsg(tenantId, tpi); + submittedMsgs.add(tbMsg.getId()); + Thread.sleep(timeLeft / msgs); } + await().atMost(5, TimeUnit.SECONDS).untilAsserted(() -> { + verify(queueAdmin, times(1)).deleteTopic(eq(isolatedTopic)); + }); + + await().atMost(5, TimeUnit.SECONDS).untilAsserted(() -> { + for (UUID msgId : submittedMsgs) { + verify(actorContext).tell(argThat(msg -> { + return msg instanceof QueueToRuleEngineMsg && ((QueueToRuleEngineMsg) msg).getMsg().getId().equals(msgId); + })); + } + }); } private TbMsg publishTbMsg(TenantId tenantId, TopicPartitionInfo tpi) { - TbMsg tbMsg = TbMsg.newMsg("POST_TELEMETRY_REQUEST", tenantId, TbMsgMetaData.EMPTY, "{\"test\":1}"); + TbMsg tbMsg = TbMsg.newMsg(TbMsgType.POST_TELEMETRY_REQUEST, tenantId, TbMsgMetaData.EMPTY, "{\"test\":1}"); TransportProtos.ToRuleEngineMsg msg = TransportProtos.ToRuleEngineMsg.newBuilder() .setTenantIdMSB(tenantId.getId().getMostSignificantBits()) .setTenantIdLSB(tenantId.getId().getLeastSignificantBits()) diff --git a/application/src/test/java/org/thingsboard/server/service/queue/ruleengine/TbRuleEngineQueueConsumerManagerTest.java b/application/src/test/java/org/thingsboard/server/service/queue/ruleengine/TbRuleEngineQueueConsumerManagerTest.java new file mode 100644 index 0000000000..276e65ec39 --- /dev/null +++ b/application/src/test/java/org/thingsboard/server/service/queue/ruleengine/TbRuleEngineQueueConsumerManagerTest.java @@ -0,0 +1,780 @@ +/** + * Copyright © 2016-2023 The Thingsboard Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.thingsboard.server.service.queue.ruleengine; + +import lombok.Getter; +import lombok.SneakyThrows; +import lombok.extern.slf4j.Slf4j; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.junit.MockitoJUnitRunner; +import org.testcontainers.shaded.org.apache.commons.lang3.RandomUtils; +import org.thingsboard.common.util.JacksonUtil; +import org.thingsboard.server.actors.ActorSystemContext; +import org.thingsboard.server.common.data.id.DeviceId; +import org.thingsboard.server.common.data.id.QueueId; +import org.thingsboard.server.common.data.id.TenantId; +import org.thingsboard.server.common.data.msg.TbMsgType; +import org.thingsboard.server.common.data.queue.ProcessingStrategy; +import org.thingsboard.server.common.data.queue.ProcessingStrategyType; +import org.thingsboard.server.common.data.queue.Queue; +import org.thingsboard.server.common.data.queue.SubmitStrategy; +import org.thingsboard.server.common.data.queue.SubmitStrategyType; +import org.thingsboard.server.common.msg.TbMsg; +import org.thingsboard.server.common.msg.TbMsgMetaData; +import org.thingsboard.server.common.msg.queue.QueueToRuleEngineMsg; +import org.thingsboard.server.common.msg.queue.ServiceType; +import org.thingsboard.server.common.msg.queue.TopicPartitionInfo; +import org.thingsboard.server.common.stats.StatsFactory; +import org.thingsboard.server.gen.transport.TransportProtos.ToRuleEngineMsg; +import org.thingsboard.server.queue.TbQueueAdmin; +import org.thingsboard.server.queue.TbQueueProducer; +import org.thingsboard.server.queue.common.AbstractTbQueueConsumerTemplate; +import org.thingsboard.server.queue.common.TbProtoQueueMsg; +import org.thingsboard.server.queue.discovery.PartitionService; +import org.thingsboard.server.queue.discovery.QueueKey; +import org.thingsboard.server.queue.discovery.TbServiceInfoProvider; +import org.thingsboard.server.queue.provider.TbQueueProducerProvider; +import org.thingsboard.server.queue.provider.TbRuleEngineQueueFactory; +import org.thingsboard.server.service.queue.processing.TbRuleEngineProcessingStrategyFactory; +import org.thingsboard.server.service.queue.processing.TbRuleEngineSubmitStrategyFactory; +import org.thingsboard.server.service.stats.RuleEngineStatisticsService; + +import java.io.IOException; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import java.util.Objects; +import java.util.Set; +import java.util.UUID; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.atomic.AtomicInteger; +import java.util.function.Supplier; +import java.util.stream.Collectors; +import java.util.stream.IntStream; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.awaitility.Awaitility.await; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.argThat; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.after; +import static org.mockito.Mockito.atLeast; +import static org.mockito.Mockito.atLeastOnce; +import static org.mockito.Mockito.clearInvocations; +import static org.mockito.Mockito.doAnswer; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.spy; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.verifyNoInteractions; +import static org.mockito.Mockito.verifyNoMoreInteractions; +import static org.mockito.Mockito.when; + +@Slf4j +@RunWith(MockitoJUnitRunner.class) +public class TbRuleEngineQueueConsumerManagerTest { + + @Mock + private ActorSystemContext actorContext; + @Mock + private StatsFactory statsFactory; + @Mock + private TbRuleEngineQueueFactory queueFactory; + @Mock + private RuleEngineStatisticsService statisticsService; + @Mock + private TbServiceInfoProvider serviceInfoProvider; + @Mock + private PartitionService partitionService; + @Mock + private TbQueueProducerProvider producerProvider; + private TbQueueProducer> ruleEngineMsgProducer; + @Mock + private TbQueueAdmin queueAdmin; + private TbRuleEngineConsumerContext ruleEngineConsumerContext; + + private TbRuleEngineQueueConsumerManager consumerManager; + private Queue queue; + + private Set consumers; + private boolean generateQueueMsgs; + private AtomicInteger totalConsumedMsgs; + private AtomicInteger totalProcessedMsgs; + + @Before + public void beforeEach() { + ruleEngineConsumerContext = new TbRuleEngineConsumerContext( + actorContext, statsFactory, spy(new TbRuleEngineSubmitStrategyFactory()), + spy(new TbRuleEngineProcessingStrategyFactory()), queueFactory, statisticsService, + serviceInfoProvider, partitionService, producerProvider, queueAdmin + ); + consumers = ConcurrentHashMap.newKeySet(); + generateQueueMsgs = true; + totalConsumedMsgs = new AtomicInteger(); + totalProcessedMsgs = new AtomicInteger(); + doAnswer(inv -> { + QueueToRuleEngineMsg msg = inv.getArgument(0); + msg.getMsg().getCallback().onSuccess(); + totalProcessedMsgs.incrementAndGet(); + log.trace("totalProcessedMsgs = {}", totalProcessedMsgs); + return null; + }).when(actorContext).tell(any()); + ruleEngineMsgProducer = mock(TbQueueProducer.class); + when(producerProvider.getRuleEngineMsgProducer()).thenReturn(ruleEngineMsgProducer); + ruleEngineConsumerContext.setMgmtThreadPoolSize(2); + ruleEngineConsumerContext.setTopicDeletionDelayInSec(5); + ruleEngineConsumerContext.init(); + ruleEngineConsumerContext.setReady(false); + + queue = new Queue(); + queue.setName("Test"); + queue.setTenantId(TenantId.SYS_TENANT_ID); + queue.setId(new QueueId(UUID.randomUUID())); + queue.setTopic("tb_test"); + queue.setPartitions(10); + queue.setConsumerPerPartition(true); + queue.setPollInterval(250); + queue.setPackProcessingTimeout(2000); + SubmitStrategy submitStrategy = new SubmitStrategy(); + submitStrategy.setType(SubmitStrategyType.BURST); + submitStrategy.setBatchSize(200); + queue.setSubmitStrategy(submitStrategy); + ProcessingStrategy processingStrategy = new ProcessingStrategy(); + processingStrategy.setType(ProcessingStrategyType.SKIP_ALL_FAILURES_AND_TIMED_OUT); + processingStrategy.setRetries(0); + queue.setProcessingStrategy(processingStrategy); + + doAnswer(i -> { + TestConsumer consumer = spy(new TestConsumer(queue.getTopic())); + if (generateQueueMsgs) { + consumer.setUpTestMsg(); + } + consumers.add(consumer); + return consumer; + }).when(queueFactory).createToRuleEngineMsgConsumer(any()); + + QueueKey queueKey = new QueueKey(ServiceType.TB_RULE_ENGINE, queue); + consumerManager = new TbRuleEngineQueueConsumerManager(ruleEngineConsumerContext, queueKey); + } + + @After + public void afterEach() { + consumerManager.stop(); + ruleEngineConsumerContext.stop(); + + if (generateQueueMsgs) { + await().atMost(1, TimeUnit.SECONDS) + .until(() -> totalProcessedMsgs.get() == totalConsumedMsgs.get()); + } + log.debug("totalConsumedMsgs = {}, totalProcessedMsgs = {}", totalConsumedMsgs.get(), totalProcessedMsgs.get()); + } + + @Test + public void testInit_consumerPerPartition() { + queue.setConsumerPerPartition(true); + consumerManager.init(queue); + + Set partitions = createTpis(2, 3, 4); + consumerManager.update(partitions); + partitions = createTpis(3, 4, 5); + consumerManager.update(partitions); + partitions = createTpis(1, 2, 3); + consumerManager.update(partitions); + // simulated multiple partition change events before consumer is ready; only latest partitions should be processed + verifyNoInteractions(queueFactory); + + ruleEngineConsumerContext.setReady(true); + await().atMost(2, TimeUnit.SECONDS) + .until(() -> consumers.size() == 3); + for (TopicPartitionInfo partition : partitions) { + TestConsumer consumer = getConsumer(partition); + verifySubscribedAndLaunched(consumer, Set.of(partition)); + } + } + + @Test + public void testInit_singleConsumer() { + queue.setConsumerPerPartition(false); + consumerManager.init(queue); + + Set partitions = createTpis(2, 3, 4); + consumerManager.update(partitions); + partitions = createTpis(3, 4, 5); + consumerManager.update(partitions); + partitions = createTpis(1, 2, 3); + consumerManager.update(partitions); + + verifyNoInteractions(queueFactory); + + ruleEngineConsumerContext.setReady(true); + await().atMost(2, TimeUnit.SECONDS) + .until(() -> consumers.size() == 1); + TestConsumer consumer = getConsumer(); + verifySubscribedAndLaunched(consumer, partitions); + } + + @Test + public void testPartitionsUpdate_singleConsumer() { + queue.setConsumerPerPartition(false); + consumerManager.init(queue); + ruleEngineConsumerContext.setReady(true); + + Set partitions = Collections.emptySet(); + consumerManager.update(partitions); + verify(queueFactory, after(1000).never()).createToRuleEngineMsgConsumer(any()); + + partitions = createTpis(1); + consumerManager.update(partitions); + TestConsumer consumer = getConsumer(); + verifySubscribedAndLaunched(consumer, partitions); + + partitions = createTpis(1, 2, 3); + consumerManager.update(partitions); + verifySubscribedAndLaunched(consumer, partitions); + + partitions = createTpis(4, 5, 6); + consumerManager.update(partitions); + verifySubscribedAndLaunched(consumer, partitions); + + partitions = Collections.emptySet(); + consumerManager.update(partitions); + verifyUnsubscribedAndStopped(consumer); + + partitions = createTpis(1, 2, 3); + consumerManager.update(partitions); + consumer = getConsumer(); + verifySubscribedAndLaunched(consumer, partitions); + } + + @Test + public void testPartitionsUpdate_consumerPerPartition() { + queue.setConsumerPerPartition(true); + consumerManager.init(queue); + ruleEngineConsumerContext.setReady(true); + + consumerManager.update(Collections.emptySet()); + verify(queueFactory, after(1000).never()).createToRuleEngineMsgConsumer(any()); + + consumerManager.update(createTpis(1)); + TestConsumer consumer1 = getConsumer(1); + verifySubscribedAndLaunched(consumer1, 1); + + consumerManager.update(createTpis(1, 2, 3)); + TestConsumer consumer2 = getConsumer(2); + TestConsumer consumer3 = getConsumer(3); + verifySubscribedAndLaunched(consumer2, 2); + verifySubscribedAndLaunched(consumer3, 3); + verifyNotTouched(consumer1); + + consumerManager.update(createTpis(3, 4, 5)); + TestConsumer consumer4 = getConsumer(4); + TestConsumer consumer5 = getConsumer(5); + verifySubscribedAndLaunched(consumer4, 4); + verifySubscribedAndLaunched(consumer5, 5); + verifyUnsubscribedAndStopped(consumer1); + verifyUnsubscribedAndStopped(consumer2); + verifyNotTouched(consumer3); + + consumerManager.update(Collections.emptySet()); + verifyUnsubscribedAndStopped(consumer3); + verifyUnsubscribedAndStopped(consumer4); + verifyUnsubscribedAndStopped(consumer5); + + consumerManager.update(createTpis(1, 2, 3)); + consumer1 = getConsumer(1); + consumer2 = getConsumer(2); + consumer3 = getConsumer(3); + verifySubscribedAndLaunched(consumer1, 1); + verifySubscribedAndLaunched(consumer2, 2); + verifySubscribedAndLaunched(consumer3, 3); + } + + @Test + public void testConfigUpdate_singleConsumer() { + queue.setConsumerPerPartition(false); + consumerManager.init(queue); + ruleEngineConsumerContext.setReady(true); + Set partitions = createTpis(1, 2, 3); + consumerManager.update(partitions); + TestConsumer consumer = getConsumer(); + verifySubscribedAndLaunched(consumer, partitions); + + Queue newConfig = JacksonUtil.clone(queue); + newConfig.setPollInterval(queue.getPollInterval() / 2); + newConfig.setPartitions(queue.getPartitions() / 2); + newConfig.setPackProcessingTimeout(queue.getPackProcessingTimeout() * 2); + newConfig.getSubmitStrategy().setType(SubmitStrategyType.SEQUENTIAL_BY_ORIGINATOR); + newConfig.getProcessingStrategy().setType(ProcessingStrategyType.RETRY_ALL); + consumerManager.update(newConfig); + + await().atMost(2, TimeUnit.SECONDS) + .untilAsserted(() -> { + verify(consumer, atLeastOnce()).poll(eq((long) newConfig.getPollInterval())); + verify(ruleEngineConsumerContext.getSubmitStrategyFactory(), atLeastOnce()).newInstance(any(), eq(newConfig.getSubmitStrategy())); + verify(ruleEngineConsumerContext.getProcessingStrategyFactory(), atLeastOnce()).newInstance(any(), eq(newConfig.getProcessingStrategy())); + }); + } + + @Test + public void testConfigUpdate_consumerPerPartition() { + queue.setConsumerPerPartition(true); + consumerManager.init(queue); + ruleEngineConsumerContext.setReady(true); + Set partitions = createTpis(1, 2, 3); + consumerManager.update(partitions); + TestConsumer consumer1 = getConsumer(1); + TestConsumer consumer2 = getConsumer(2); + TestConsumer consumer3 = getConsumer(3); + verifySubscribedAndLaunched(consumer1, 1); + verifySubscribedAndLaunched(consumer2, 2); + verifySubscribedAndLaunched(consumer3, 3); + + Queue newConfig = JacksonUtil.clone(queue); + newConfig.setPollInterval(queue.getPollInterval() / 2); + newConfig.setPartitions(queue.getPartitions() / 2); + newConfig.setPackProcessingTimeout(queue.getPackProcessingTimeout() * 2); + newConfig.getSubmitStrategy().setType(SubmitStrategyType.SEQUENTIAL_BY_ORIGINATOR); + newConfig.getProcessingStrategy().setType(ProcessingStrategyType.RETRY_ALL); + consumerManager.update(newConfig); + + await().atMost(2, TimeUnit.SECONDS) + .untilAsserted(() -> { + verify(consumer1, atLeastOnce()).poll(eq((long) newConfig.getPollInterval())); + verify(consumer2, atLeastOnce()).poll(eq((long) newConfig.getPollInterval())); + verify(consumer3, atLeastOnce()).poll(eq((long) newConfig.getPollInterval())); + }); + verifyNotTouched(consumer1); + verifyNotTouched(consumer2); + verifyNotTouched(consumer3); + } + + @Test + public void testConfigUpdate_fromSingleToConsumerPerPartition() { + queue.setConsumerPerPartition(false); + consumerManager.init(queue); + ruleEngineConsumerContext.setReady(true); + Set partitions = createTpis(1, 2, 3); + consumerManager.update(partitions); + TestConsumer consumer = getConsumer(); + verifySubscribedAndLaunched(consumer, partitions); + + Queue newConfig = JacksonUtil.clone(queue); + newConfig.setConsumerPerPartition(true); + consumerManager.update(newConfig); + + verifyUnsubscribedAndStopped(consumer); + verifySubscribedAndLaunched(getConsumer(1), 1); + verifySubscribedAndLaunched(getConsumer(2), 2); + verifySubscribedAndLaunched(getConsumer(3), 3); + } + + @Test + public void testConfigUpdate_fromConsumerPerPartitionToSingle() { + queue.setConsumerPerPartition(true); + consumerManager.init(queue); + ruleEngineConsumerContext.setReady(true); + Set partitions = createTpis(1, 2, 3); + consumerManager.update(partitions); + TestConsumer consumer1 = getConsumer(1); + TestConsumer consumer2 = getConsumer(2); + TestConsumer consumer3 = getConsumer(3); + verifySubscribedAndLaunched(consumer1, 1); + verifySubscribedAndLaunched(consumer2, 2); + verifySubscribedAndLaunched(consumer3, 3); + + Queue newConfig = JacksonUtil.clone(queue); + newConfig.setConsumerPerPartition(false); + consumerManager.update(newConfig); + + verifyUnsubscribedAndStopped(consumer1); + verifyUnsubscribedAndStopped(consumer2); + verifyUnsubscribedAndStopped(consumer3); + verifySubscribedAndLaunched(getConsumer(), partitions); + } + + @Test + public void testStop() { + queue.setConsumerPerPartition(true); + consumerManager.init(queue); + ruleEngineConsumerContext.setReady(true); + consumerManager.update(createTpis(1)); + TestConsumer consumer = getConsumer(1); + verifySubscribedAndLaunched(consumer, 1); + verify(queueFactory, times(1)).createToRuleEngineMsgConsumer(any()); + + consumerManager.stop(); + consumerManager.update(createTpis(1, 2, 3, 4)); // to check that no new tasks after stop are processed + consumerManager.update(createTpis(5, 6, 7)); + + verifyUnsubscribedAndStopped(consumer); + verifyNoMoreInteractions(queueFactory); + } + + @Test + public void testDelete_consumerPerPartition() { + queue.setConsumerPerPartition(true); + consumerManager.init(queue); + ruleEngineConsumerContext.setReady(true); + Set partitions = createTpis(1, 2); + consumerManager.update(partitions); + TestConsumer consumer1 = getConsumer(1); + TestConsumer consumer2 = getConsumer(2); + verifySubscribedAndLaunched(consumer1, 1); + verifySubscribedAndLaunched(consumer2, 2); + verifyMsgProcessed(consumer1.testMsg); + verifyMsgProcessed(consumer2.testMsg); + + consumerManager.delete(); + + await().atMost(2, TimeUnit.SECONDS) + .untilAsserted(() -> { + verify(ruleEngineMsgProducer).send(any(), any(), any()); + }); + clearInvocations(actorContext); + verify(consumer1, never()).unsubscribe(); + verify(consumer2, never()).unsubscribe(); + int msgCount1 = consumer1.msgCount; + int msgCount2 = consumer2.msgCount; + + await().atLeast(4, TimeUnit.SECONDS) // based on topicDeletionDelayInSec + .atMost(7, TimeUnit.SECONDS) + .untilAsserted(() -> { + partitions.stream() + .map(TopicPartitionInfo::getFullTopicName) + .forEach(topic -> { + verify(queueAdmin).deleteTopic(eq(topic)); + }); + }); + verify(consumer1).unsubscribe(); + verify(consumer2).unsubscribe(); + + int movedMsgs1 = consumer1.msgCount - msgCount1; + int movedMsgs2 = consumer2.msgCount - msgCount2; + int totalMovedMsgs = movedMsgs1 + movedMsgs2; + assertThat(totalMovedMsgs).isGreaterThan(10); + verify(ruleEngineMsgProducer, atLeast(totalMovedMsgs)).send(any(), any(), any()); + verify(actorContext, never()).tell(any()); + generateQueueMsgs = false; + } + + @Test + public void testDelete_singleConsumer() { + queue.setConsumerPerPartition(false); + consumerManager.init(queue); + ruleEngineConsumerContext.setReady(true); + Set partitions = createTpis(1, 2); + consumerManager.update(partitions); + TestConsumer consumer = getConsumer(); + verifySubscribedAndLaunched(consumer, partitions); + verifyMsgProcessed(consumer.testMsg); + + consumerManager.delete(); + + await().atMost(2, TimeUnit.SECONDS) + .untilAsserted(() -> { + verify(ruleEngineMsgProducer).send(any(), any(), any()); + }); + clearInvocations(actorContext); + verify(consumer, never()).unsubscribe(); + int msgCount = consumer.msgCount; + + await().atLeast(4, TimeUnit.SECONDS) + .atMost(7, TimeUnit.SECONDS) + .untilAsserted(() -> { + partitions.stream() + .map(TopicPartitionInfo::getFullTopicName) + .forEach(topic -> { + verify(queueAdmin).deleteTopic(eq(topic)); + }); + }); + verify(consumer).unsubscribe(); + + int movedMsgs = consumer.msgCount - msgCount; + assertThat(movedMsgs).isGreaterThan(10); + verify(ruleEngineMsgProducer, atLeast(movedMsgs)).send(any(), any(), any()); + verify(actorContext, never()).tell(any()); + generateQueueMsgs = false; + } + + @Test + public void testManyDifferentUpdates() throws Exception { + queue.setConsumerPerPartition(RandomUtils.nextBoolean()); + consumerManager.init(queue); + ruleEngineConsumerContext.setReady(true); + + Supplier queueConfigUpdater = () -> { + Queue oldConfig = consumerManager.getQueue(); + Queue newConfig = JacksonUtil.clone(oldConfig); + newConfig.setConsumerPerPartition(RandomUtils.nextBoolean()); + newConfig.setPollInterval(RandomUtils.nextInt(100, 501)); + newConfig.setPartitions(RandomUtils.nextInt(1, 10)); + newConfig.setPackProcessingTimeout(RandomUtils.nextLong(100, 5001)); + newConfig.getSubmitStrategy().setType(SubmitStrategyType.values()[RandomUtils.nextInt(0, SubmitStrategyType.values().length)]); + newConfig.getProcessingStrategy().setType(ProcessingStrategyType.values()[RandomUtils.nextInt(0, ProcessingStrategyType.values().length)]); + log.info("Generated new config: consumerPerPartition={}, pollInterval={}, processingStrategy={}", + newConfig.isConsumerPerPartition(), newConfig.getPollInterval(), newConfig.getProcessingStrategy().getType()); + return newConfig; + }; + Supplier> partitionsUpdater = () -> { + int partitionsCount = RandomUtils.nextInt(0, 20); + int[] partitions = IntStream.generate(() -> RandomUtils.nextInt(0, 20)) + .distinct().limit(partitionsCount) + .sorted().toArray(); + log.info("Generated new partitions: {}", Arrays.toString(partitions)); + return createTpis(partitions); + }; + + int iterations = 100; + Queue latestConfig = queue; + Set latestPartitions = Collections.emptySet(); + for (int i = 1; i <= iterations; i++) { + boolean updateQueueConfig = RandomUtils.nextBoolean(); + boolean updatePartitions = !updateQueueConfig; + if (updateQueueConfig) { + latestConfig = queueConfigUpdater.get(); + consumerManager.update(latestConfig); + } + if (updatePartitions) { + latestPartitions = partitionsUpdater.get(); + consumerManager.update(latestPartitions); + } + Thread.sleep(RandomUtils.nextLong(0, 200)); + } + if (latestPartitions.isEmpty()) { + do { + latestPartitions = partitionsUpdater.get(); + } while (latestPartitions.isEmpty()); + consumerManager.update(latestPartitions); + } + + Queue expectedConfig = latestConfig; + Set expectedPartitions = latestPartitions; + await().atMost(5, TimeUnit.SECONDS) + .untilAsserted(() -> { + assertThat(consumerManager.getQueue()).isEqualTo(expectedConfig); + assertThat(consumerManager.getPartitions()).isEqualTo(expectedPartitions); + }); + + if (expectedConfig.isConsumerPerPartition()) { + await().atMost(5, TimeUnit.SECONDS).until(() -> { + for (TopicPartitionInfo partition : expectedPartitions) { + if (consumers.stream().noneMatch(consumer -> consumer.subscribed && + consumer.pollingStarted && Set.of(partition).equals(consumer.getPartitions()))) { + return false; + } + } + return consumers.size() == expectedPartitions.size(); + }); + } else { + await().atMost(5, TimeUnit.SECONDS).until(() -> { + return consumers.size() == 1 && consumers.stream() + .anyMatch(consumer -> consumer.subscribed && consumer.pollingStarted && + expectedPartitions.equals(consumer.getPartitions())); + }); + } + Mockito.reset(ruleEngineConsumerContext.getSubmitStrategyFactory()); + Mockito.reset(ruleEngineConsumerContext.getProcessingStrategyFactory()); + consumers.forEach(Mockito::clearInvocations); + + await().atMost(5, TimeUnit.SECONDS).untilAsserted(() -> { + for (TestConsumer consumer : consumers) { + verify(consumer, atLeastOnce().description("consumer " + consumer.topics)).poll(expectedConfig.getPollInterval()); + } + verify(ruleEngineConsumerContext.getSubmitStrategyFactory(), atLeastOnce()).newInstance(any(), eq(expectedConfig.getSubmitStrategy())); + verify(ruleEngineConsumerContext.getProcessingStrategyFactory(), atLeastOnce()).newInstance(any(), eq(expectedConfig.getProcessingStrategy())); + }); + } + + /* + * 2023-10-15 18:34:06,090 [main] INFO o.t.s.s.q.r.TbRuleEngineQueueConsumerManagerTest - Generated new partitions: [0, 1, 2, 3, 4, 5, 6, 8, 9, 11, 12, 13, 15, 16, 17, 18, 19] +2023-10-15 18:34:06,090 [main] INFO o.t.s.s.q.r.TbRuleEngineQueueConsumerManagerTest - Generated new config: consumerPerPartition=false, pollInterval=299, processingStrategy=RETRY_FAILED + * */ + + private void verifySubscribedAndLaunched(TestConsumer consumer, Set expectedPartitions) { + await().atMost(2, TimeUnit.SECONDS) + .until(() -> consumer.subscribed && consumer.getPartitions().equals(expectedPartitions) && consumer.pollingStarted); + verify(consumer, times(1)).subscribe(any()); + verify(consumer).subscribe(eq(expectedPartitions)); + verify(consumer).doSubscribe(argThat(topics -> topics.containsAll(expectedPartitions.stream() + .map(TopicPartitionInfo::getFullTopicName).collect(Collectors.toList())))); + verify(consumer, atLeastOnce()).poll(eq((long) queue.getPollInterval())); + verify(consumer, atLeastOnce()).doPoll(eq((long) queue.getPollInterval())); + verify(consumer, never()).unsubscribe(); + Mockito.reset(consumer); + } + + private void verifySubscribedAndLaunched(TestConsumer consumer, int... expectedPartitions) { + verifySubscribedAndLaunched(consumer, createTpis(expectedPartitions)); + } + + private void verifyUnsubscribedAndStopped(TestConsumer consumer) { + await().atMost(2, TimeUnit.SECONDS) + .until(() -> !consumer.subscribed && !consumer.topics.isEmpty()); + verify(consumer, never()).subscribe(any()); + verify(consumer, never()).doSubscribe(any()); + assertThat(consumers).doesNotContain(consumer); + Mockito.reset(consumer); + } + + private void verifyNotTouched(TestConsumer consumer) { + verify(consumer, never()).subscribe(any()); + verify(consumer, never()).subscribe(); + verify(consumer, never()).doSubscribe(any()); + verify(consumer, never()).unsubscribe(); + verify(consumer, never()).doUnsubscribe(); + } + + private void verifyMsgProcessed(TbMsg tbMsg) { + await().atMost(2, TimeUnit.SECONDS).untilAsserted(() -> { + verify(actorContext, atLeastOnce()).tell(argThat(msg -> { + return ((QueueToRuleEngineMsg) msg).getMsg().getId().equals(tbMsg.getId()); + })); + }); + } + + // for consumer-per-partition + private TestConsumer getConsumer(TopicPartitionInfo tpi) { + return await().atMost(5, TimeUnit.SECONDS) + .until(() -> consumers.stream() + .filter(consumer -> consumer.getPartitions() != null && + consumer.getPartitions().size() == 1 && + consumer.getPartitions().contains(tpi)) + .findFirst().orElse(null), Objects::nonNull); + } + + private TestConsumer getConsumer(int partition) { + return await().atMost(5, TimeUnit.SECONDS) + .until(() -> consumers.stream() + .filter(consumer -> consumer.getPartitions() != null && + consumer.getPartitions().size() == 1 && + consumer.getPartitions().stream() + .anyMatch(tpi -> tpi.getPartition().get().equals(partition))) + .findFirst().orElse(null), Objects::nonNull); + } + + // for single consumer + private TestConsumer getConsumer() { + return await().atMost(5, TimeUnit.SECONDS) + .until(() -> consumers.size() == 1 ? consumers.iterator().next() : null, Objects::nonNull); + } + + private Set createTpis(int... partitions) { + return Arrays.stream(partitions) + .mapToObj(n -> TopicPartitionInfo.builder() + .tenantId(queue.getTenantId()) + .topic(queue.getTopic()) + .partition(n) + .myPartition(true) + .build()) + .collect(Collectors.toSet()); + } + + + class TestConsumer extends AbstractTbQueueConsumerTemplate> { + + @Getter + private List topics; + + private boolean subscribed; + private boolean pollingStarted; + + private TbMsg testMsg; + private int msgCount; + + public TestConsumer(String topic) { + super(topic); + } + + @SneakyThrows + @Override + protected List doPoll(long durationInMillis) { + log.debug("doPoll({} ms)", durationInMillis); + if (!subscribed) { + throw new IllegalStateException("Cannot poll because not subscribed"); + } + pollingStarted = true; + if (testMsg != null && RandomUtils.nextBoolean()) { + Thread.sleep(100); + return List.of(testMsg); + } + return Collections.emptyList(); + } + + @Override + protected TbProtoQueueMsg decode(TbMsg tbMsg) throws IOException { + log.debug("decode()"); + UUID tenantId = UUID.randomUUID(); + return new TbProtoQueueMsg<>(UUID.randomUUID(), ToRuleEngineMsg.newBuilder() + .setTenantIdMSB(tenantId.getMostSignificantBits()) + .setTenantIdLSB(tenantId.getLeastSignificantBits()) + .addRelationTypes("Success") + .setTbMsg(TbMsg.toByteString(tbMsg)) + .build()); + } + + @Override + protected void doSubscribe(List topicNames) { + log.debug("doSubscribe({})", topicNames); + this.topics = topicNames; + subscribed = true; + } + + @Override + protected void doCommit() { + if (!subscribed) { + throw new IllegalStateException("Cannot commit because not subscribed"); + } + msgCount++; + log.debug("doCommit() totalConsumedMsgs = {}", totalConsumedMsgs.incrementAndGet()); + } + + @Override + public void unsubscribe() { + super.unsubscribe(); + consumers.remove(this); + } + + @Override + protected void doUnsubscribe() { + log.debug("doUnsubscribe()"); + if (!subscribed) { + throw new IllegalStateException("Already unsubscribed!"); + } + subscribed = false; + } + + @Override + protected boolean isLongPollingSupported() { + return false; + } + + public Set getPartitions() { + return partitions; + } + + public void setUpTestMsg() { + testMsg = TbMsg.newMsg(TbMsgType.POST_TELEMETRY_REQUEST, new DeviceId(UUID.randomUUID()), new TbMsgMetaData(), "{}"); + } + } + +} From ea4eadb47f9184326f04f05e5461744376368d06 Mon Sep 17 00:00:00 2001 From: ViacheslavKlimov Date: Wed, 18 Oct 2023 14:20:41 +0300 Subject: [PATCH 19/43] Cancelling consumer loop task on stop --- .../DefaultTbRuleEngineConsumerService.java | 1 + .../service/queue/ruleengine/QueueEvent.java | 2 +- .../queue/ruleengine/TbQueueConsumerTask.java | 34 +++++++-- .../TbRuleEngineConsumerContext.java | 10 +-- .../TbRuleEngineQueueConsumerManager.java | 70 +++++++++++-------- .../TbRuleEngineQueueConsumerManagerTest.java | 10 +-- 6 files changed, 78 insertions(+), 49 deletions(-) diff --git a/application/src/main/java/org/thingsboard/server/service/queue/DefaultTbRuleEngineConsumerService.java b/application/src/main/java/org/thingsboard/server/service/queue/DefaultTbRuleEngineConsumerService.java index 64139530b1..3f05a5b923 100644 --- a/application/src/main/java/org/thingsboard/server/service/queue/DefaultTbRuleEngineConsumerService.java +++ b/application/src/main/java/org/thingsboard/server/service/queue/DefaultTbRuleEngineConsumerService.java @@ -126,6 +126,7 @@ public class DefaultTbRuleEngineConsumerService extends AbstractConsumerService< @Override protected void stopConsumers() { consumers.values().forEach(TbRuleEngineQueueConsumerManager::stop); + consumers.values().forEach(TbRuleEngineQueueConsumerManager::awaitStop); ctx.stop(); } diff --git a/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/QueueEvent.java b/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/QueueEvent.java index a4a3bcc59a..86955be7e7 100644 --- a/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/QueueEvent.java +++ b/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/QueueEvent.java @@ -19,6 +19,6 @@ import java.io.Serializable; public enum QueueEvent implements Serializable { - PARTITION_CHANGE, CONFIG_UPDATE, STOP, DELETE + PARTITION_CHANGE, CONFIG_UPDATE, DELETE } diff --git a/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbQueueConsumerTask.java b/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbQueueConsumerTask.java index a0a5579951..2e3a4676e8 100644 --- a/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbQueueConsumerTask.java +++ b/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbQueueConsumerTask.java @@ -15,7 +15,8 @@ */ package org.thingsboard.server.service.queue.ruleengine; -import lombok.Data; +import lombok.Getter; +import lombok.RequiredArgsConstructor; import lombok.extern.slf4j.Slf4j; import org.thingsboard.server.common.msg.queue.TopicPartitionInfo; import org.thingsboard.server.gen.transport.TransportProtos; @@ -23,16 +24,26 @@ import org.thingsboard.server.queue.TbQueueConsumer; import org.thingsboard.server.queue.common.TbProtoQueueMsg; import java.util.Set; +import java.util.concurrent.CountDownLatch; import java.util.concurrent.Future; import java.util.concurrent.TimeUnit; -@Data +@RequiredArgsConstructor @Slf4j public class TbQueueConsumerTask { + @Getter private final Object key; + @Getter private final TbQueueConsumer> consumer; - private volatile Future task; + + private Future task; + private CountDownLatch completionLatch; + + public void setTask(Future task) { + this.task = task; + this.completionLatch = new CountDownLatch(1); + } public void subscribe(Set partitions) { log.trace("[{}] Subscribing to partitions: {}", key, partitions); @@ -42,23 +53,32 @@ public class TbQueueConsumerTask { public void initiateStop() { log.debug("[{}] Initiating stop", key); consumer.stop(); + if (isRunning()) { + task.cancel(true); + } } - public void awaitFinish() { + public void awaitCompletion() { log.trace("[{}] Awaiting finish", key); if (isRunning()) { try { - task.get(60, TimeUnit.SECONDS); - task = null; + if (!completionLatch.await(30, TimeUnit.SECONDS)) { + throw new IllegalStateException("timeout of 30 seconds expired"); + } } catch (Exception e) { log.warn("[{}] Failed to await for consumer to stop", key, e); } + task = null; } log.trace("[{}] Awaited finish", key); } public boolean isRunning() { - return task != null && !task.isDone(); + return task != null; + } + + public void finished() { + completionLatch.countDown(); } } diff --git a/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbRuleEngineConsumerContext.java b/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbRuleEngineConsumerContext.java index 325a685972..f4c8e4c2ae 100644 --- a/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbRuleEngineConsumerContext.java +++ b/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbRuleEngineConsumerContext.java @@ -36,7 +36,6 @@ import javax.annotation.PostConstruct; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.ScheduledExecutorService; -import java.util.concurrent.TimeUnit; @Component @TbRuleEngineComponent @@ -83,12 +82,7 @@ public class TbRuleEngineConsumerContext { public void stop() { scheduler.shutdownNow(); - consumersExecutor.shutdown(); - mgmtExecutor.shutdown(); - try { - mgmtExecutor.awaitTermination(15, TimeUnit.SECONDS); - } catch (InterruptedException e) { - log.warn("Failed to await mgmtExecutor termination"); - } + consumersExecutor.shutdownNow(); + mgmtExecutor.shutdownNow(); } } diff --git a/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbRuleEngineQueueConsumerManager.java b/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbRuleEngineQueueConsumerManager.java index dc3966d0d2..3a7b2f15d8 100644 --- a/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbRuleEngineQueueConsumerManager.java +++ b/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbRuleEngineQueueConsumerManager.java @@ -85,7 +85,13 @@ public class TbRuleEngineQueueConsumerManager { } public void init(Queue queue) { - doInit(queue); + this.queue = queue; + if (queue.isConsumerPerPartition()) { + this.consumerWrapper = new ConsumerPerPartitionWrapper(); + } else { + this.consumerWrapper = new SingleConsumerWrapper(); + } + log.debug("[{}] Initialized consumer for queue: {}", queueKey, queue); } public void update(Queue queue) { @@ -96,10 +102,6 @@ public class TbRuleEngineQueueConsumerManager { addTask(new TbQueueConsumerManagerTask(QueueEvent.PARTITION_CHANGE, partitions)); } - public void stop() { - addTask(new TbQueueConsumerManagerTask(QueueEvent.STOP)); - } - public void delete() { addTask(new TbQueueConsumerManagerTask(QueueEvent.DELETE)); } @@ -135,20 +137,22 @@ public class TbRuleEngineQueueConsumerManager { newPartitions = task.getPartitions(); } else if (task.getEvent() == QueueEvent.CONFIG_UPDATE) { newConfiguration = task.getQueue(); - } else if (task.getEvent() == QueueEvent.STOP) { - doStop(); - return; } else if (task.getEvent() == QueueEvent.DELETE) { doDelete(); return; } } + if (stopped) { + return; + } if (newConfiguration != null) { doUpdate(newConfiguration); } if (newPartitions != null) { doUpdate(newPartitions); } + } catch (Exception e) { + log.error("[{}] Failed to process tasks", queueKey, e); } finally { lock.unlock(); } @@ -159,16 +163,6 @@ public class TbRuleEngineQueueConsumerManager { }); } - private void doInit(Queue queue) { - this.queue = queue; - if (queue.isConsumerPerPartition()) { - consumerWrapper = new ConsumerPerPartitionWrapper(); - } else { - consumerWrapper = new SingleConsumerWrapper(); - } - log.debug("[{}] Initialized consumer for queue: {}", queueKey, queue); - } - private void doUpdate(Queue newQueue) { log.info("[{}] Processing queue update: {}", queueKey, newQueue); var oldQueue = this.queue; @@ -179,12 +173,12 @@ public class TbRuleEngineQueueConsumerManager { } if (oldQueue == null) { - doInit(queue); + init(queue); } else if (newQueue.isConsumerPerPartition() != oldQueue.isConsumerPerPartition()) { consumerWrapper.getConsumers().forEach(TbQueueConsumerTask::initiateStop); - consumerWrapper.getConsumers().forEach(TbQueueConsumerTask::awaitFinish); + consumerWrapper.getConsumers().forEach(TbQueueConsumerTask::awaitCompletion); - doInit(queue); + init(queue); if (partitions != null) { doUpdate(partitions); // even if partitions number was changed, there can be no partition change event } @@ -200,17 +194,21 @@ public class TbRuleEngineQueueConsumerManager { consumerWrapper.updatePartitions(partitions); } - private void doStop() { + public void stop() { + log.debug("[{}] Stopping consumers", queueKey); consumerWrapper.getConsumers().forEach(TbQueueConsumerTask::initiateStop); - consumerWrapper.getConsumers().forEach(TbQueueConsumerTask::awaitFinish); - log.debug("[{}] Unsubscribed and stopped consumers", queueKey); stopped = true; } + public void awaitStop() { + consumerWrapper.getConsumers().forEach(TbQueueConsumerTask::awaitCompletion); + log.debug("[{}] Unsubscribed and stopped consumers", queueKey); + } + private void doDelete() { stopped = true; log.info("[{}] Handling queue deletion", queueKey); - consumerWrapper.getConsumers().forEach(TbQueueConsumerTask::awaitFinish); + consumerWrapper.getConsumers().forEach(TbQueueConsumerTask::awaitCompletion); List>> queueConsumers = consumerWrapper.getConsumers().stream() .map(TbQueueConsumerTask::getConsumer).collect(Collectors.toList()); @@ -240,6 +238,7 @@ public class TbRuleEngineQueueConsumerManager { Future consumerLoop = ctx.getConsumersExecutor().submit(() -> { ThingsBoardThreadFactory.updateCurrentThreadName(consumerTask.getKey().toString()); consumerLoop(consumerTask.getConsumer()); + consumerTask.finished(); }); consumerTask.setTask(consumerLoop); } @@ -253,7 +252,7 @@ public class TbRuleEngineQueueConsumerManager { } processMsgs(msgs, consumer, queue); } catch (Exception e) { - if (!stopped) { + if (!consumer.isStopped()) { log.warn("Failed to process messages from queue", e); try { Thread.sleep(ctx.getPollDuration()); @@ -279,7 +278,7 @@ public class TbRuleEngineQueueConsumerManager { TbMsgPackProcessingContext packCtx = new TbMsgPackProcessingContext(queue.getName(), submitStrategy, ackStrategy.isSkipTimeoutMsgs()); submitStrategy.submitAttempt((id, msg) -> submitMessage(packCtx, id, msg)); - final boolean timeout = !packCtx.await(queue.getPackProcessingTimeout(), TimeUnit.MILLISECONDS); + final boolean timeout = !awaitPackProcessing(packCtx, queue.getPackProcessingTimeout(), true); TbRuleEngineProcessingResult result = new TbRuleEngineProcessingResult(queue.getName(), timeout, packCtx); if (timeout) { @@ -307,6 +306,19 @@ public class TbRuleEngineQueueConsumerManager { } } + private boolean awaitPackProcessing(TbMsgPackProcessingContext packCtx, long processingTimeout, boolean ignoreInterrupt) throws InterruptedException { + try { + return packCtx.await(processingTimeout, TimeUnit.MILLISECONDS); + } catch (InterruptedException e) { + if (ignoreInterrupt) { + log.debug("Interrupt happened while waiting for pack processing, trying to await one more time"); + return awaitPackProcessing(packCtx, processingTimeout, false); + } else { + throw new RuntimeException("Failed to await pack processing due to thread interrupt", e); + } + } + } + private TbRuleEngineSubmitStrategy getSubmitStrategy(Queue queue) { return ctx.getSubmitStrategyFactory().newInstance(queue.getName(), queue.getSubmitStrategy()); } @@ -430,7 +442,7 @@ public class TbRuleEngineQueueConsumerManager { consumers.get(tpi).initiateStop(); }); removedPartitions.forEach((tpi) -> { - consumers.remove(tpi).awaitFinish(); + consumers.remove(tpi).awaitCompletion(); }); addedPartitions.forEach((tpi) -> { @@ -457,7 +469,7 @@ public class TbRuleEngineQueueConsumerManager { if (partitions.isEmpty()) { if (consumer != null && consumer.isRunning()) { consumer.initiateStop(); - consumer.awaitFinish(); + consumer.awaitCompletion(); } consumer = null; return; diff --git a/application/src/test/java/org/thingsboard/server/service/queue/ruleengine/TbRuleEngineQueueConsumerManagerTest.java b/application/src/test/java/org/thingsboard/server/service/queue/ruleengine/TbRuleEngineQueueConsumerManagerTest.java index 276e65ec39..20b765da6d 100644 --- a/application/src/test/java/org/thingsboard/server/service/queue/ruleengine/TbRuleEngineQueueConsumerManagerTest.java +++ b/application/src/test/java/org/thingsboard/server/service/queue/ruleengine/TbRuleEngineQueueConsumerManagerTest.java @@ -180,13 +180,16 @@ public class TbRuleEngineQueueConsumerManagerTest { @After public void afterEach() { consumerManager.stop(); + consumerManager.awaitStop(); ruleEngineConsumerContext.stop(); if (generateQueueMsgs) { - await().atMost(1, TimeUnit.SECONDS) - .until(() -> totalProcessedMsgs.get() == totalConsumedMsgs.get()); + await().atMost(2, TimeUnit.SECONDS) + .untilAsserted(() -> { + log.debug("totalConsumedMsgs = {}, totalProcessedMsgs = {}", totalConsumedMsgs.get(), totalProcessedMsgs.get()); + assertThat(totalProcessedMsgs.get()).isEqualTo(totalConsumedMsgs.get()); + }); } - log.debug("totalConsumedMsgs = {}, totalProcessedMsgs = {}", totalConsumedMsgs.get(), totalProcessedMsgs.get()); } @Test @@ -510,7 +513,6 @@ public class TbRuleEngineQueueConsumerManagerTest { verify(consumer).unsubscribe(); int movedMsgs = consumer.msgCount - msgCount; - assertThat(movedMsgs).isGreaterThan(10); verify(ruleEngineMsgProducer, atLeast(movedMsgs)).send(any(), any(), any()); verify(actorContext, never()).tell(any()); generateQueueMsgs = false; From 5108e98f38631ff4f828cb014965b4836ef475a2 Mon Sep 17 00:00:00 2001 From: ViacheslavKlimov Date: Thu, 19 Oct 2023 11:03:53 +0300 Subject: [PATCH 20/43] Minor refactoring --- .../service/queue/ruleengine/TbRuleEngineConsumerContext.java | 2 +- application/src/main/resources/thingsboard.yml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbRuleEngineConsumerContext.java b/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbRuleEngineConsumerContext.java index f4c8e4c2ae..b18df6b62b 100644 --- a/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbRuleEngineConsumerContext.java +++ b/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbRuleEngineConsumerContext.java @@ -74,7 +74,7 @@ public class TbRuleEngineConsumerContext { private volatile boolean isReady = false; @PostConstruct - public void init() { + void init() { this.consumersExecutor = Executors.newCachedThreadPool(ThingsBoardThreadFactory.forName("tb-rule-engine-consumer")); this.mgmtExecutor = Executors.newFixedThreadPool(mgmtThreadPoolSize, ThingsBoardThreadFactory.forName("tb-rule-engine-mgmt")); this.scheduler = Executors.newSingleThreadScheduledExecutor(ThingsBoardThreadFactory.forName("tb-rule-engine-consumer-scheduler")); diff --git a/application/src/main/resources/thingsboard.yml b/application/src/main/resources/thingsboard.yml index 6f51413ccd..be01c95fad 100644 --- a/application/src/main/resources/thingsboard.yml +++ b/application/src/main/resources/thingsboard.yml @@ -1304,7 +1304,7 @@ queue: max-pause-between-retries: "${TB_QUEUE_RE_SQ_PROCESSING_STRATEGY_MAX_RETRY_PAUSE:5}" # Max allowed time in seconds for pause between retries. # After a queue is deleted (or profile's isolation option was disabled), Rule Engine will continue reading related topics during this period, before deleting the actual topics topic-deletion-delay: "${TB_QUEUE_RULE_ENGINE_TOPIC_DELETION_DELAY_SEC:15}" - # Size of the thread pool that handles management operations such as subscribe, unsubscribe, queue delete, etc. + # Size of the thread pool that handles such operations as partition changes, config updates, queue deletion management-thread-pool-size: "${TB_QUEUE_RULE_ENGINE_MGMT_THREAD_POOL_SIZE:12}" transport: # For high priority notifications that require minimum latency and processing time From 049f40a62e4cba6ffcd863eaada4a0ad6a7f360d Mon Sep 17 00:00:00 2001 From: ViacheslavKlimov Date: Thu, 19 Oct 2023 14:00:04 +0300 Subject: [PATCH 21/43] Clear interruption status after exiting consumer while loop --- .../service/queue/ruleengine/TbQueueConsumerTask.java | 7 ++++--- .../ruleengine/TbRuleEngineQueueConsumerManager.java | 8 ++++++-- 2 files changed, 10 insertions(+), 5 deletions(-) diff --git a/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbQueueConsumerTask.java b/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbQueueConsumerTask.java index 2e3a4676e8..9c0df63ad5 100644 --- a/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbQueueConsumerTask.java +++ b/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbQueueConsumerTask.java @@ -41,8 +41,8 @@ public class TbQueueConsumerTask { private CountDownLatch completionLatch; public void setTask(Future task) { - this.task = task; this.completionLatch = new CountDownLatch(1); + this.task = task; } public void subscribe(Set partitions) { @@ -63,14 +63,14 @@ public class TbQueueConsumerTask { if (isRunning()) { try { if (!completionLatch.await(30, TimeUnit.SECONDS)) { + task = null; throw new IllegalStateException("timeout of 30 seconds expired"); } + log.trace("[{}] Awaited finish", key); } catch (Exception e) { log.warn("[{}] Failed to await for consumer to stop", key, e); } - task = null; } - log.trace("[{}] Awaited finish", key); } public boolean isRunning() { @@ -79,6 +79,7 @@ public class TbQueueConsumerTask { public void finished() { completionLatch.countDown(); + task = null; } } diff --git a/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbRuleEngineQueueConsumerManager.java b/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbRuleEngineQueueConsumerManager.java index 3a7b2f15d8..71a7c45d45 100644 --- a/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbRuleEngineQueueConsumerManager.java +++ b/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbRuleEngineQueueConsumerManager.java @@ -237,7 +237,11 @@ public class TbRuleEngineQueueConsumerManager { log.info("[{}] Launching consumer", consumerTask.getKey()); Future consumerLoop = ctx.getConsumersExecutor().submit(() -> { ThingsBoardThreadFactory.updateCurrentThreadName(consumerTask.getKey().toString()); - consumerLoop(consumerTask.getConsumer()); + try { + consumerLoop(consumerTask.getConsumer()); + } catch (Throwable e) { + log.error("Failure in consumer loop", e); + } consumerTask.finished(); }); consumerTask.setTask(consumerLoop); @@ -262,7 +266,7 @@ public class TbRuleEngineQueueConsumerManager { } } } - if (consumer.isStopped()) { + if (Thread.interrupted() || consumer.isStopped()) { consumer.unsubscribe(); } log.info("Rule Engine consumer stopped"); From 2d1640a0025798cafb3a967562c3773978b936d5 Mon Sep 17 00:00:00 2001 From: ViacheslavKlimov Date: Thu, 19 Oct 2023 15:29:46 +0300 Subject: [PATCH 22/43] Don't interrupt consumer loop task on stop --- .../queue/ruleengine/TbQueueConsumerTask.java | 23 ++++--------------- .../TbRuleEngineQueueConsumerManager.java | 18 ++------------- 2 files changed, 6 insertions(+), 35 deletions(-) diff --git a/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbQueueConsumerTask.java b/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbQueueConsumerTask.java index 9c0df63ad5..59d55285f0 100644 --- a/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbQueueConsumerTask.java +++ b/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbQueueConsumerTask.java @@ -17,6 +17,7 @@ package org.thingsboard.server.service.queue.ruleengine; import lombok.Getter; import lombok.RequiredArgsConstructor; +import lombok.Setter; import lombok.extern.slf4j.Slf4j; import org.thingsboard.server.common.msg.queue.TopicPartitionInfo; import org.thingsboard.server.gen.transport.TransportProtos; @@ -24,7 +25,6 @@ import org.thingsboard.server.queue.TbQueueConsumer; import org.thingsboard.server.queue.common.TbProtoQueueMsg; import java.util.Set; -import java.util.concurrent.CountDownLatch; import java.util.concurrent.Future; import java.util.concurrent.TimeUnit; @@ -37,13 +37,8 @@ public class TbQueueConsumerTask { @Getter private final TbQueueConsumer> consumer; + @Setter private Future task; - private CountDownLatch completionLatch; - - public void setTask(Future task) { - this.completionLatch = new CountDownLatch(1); - this.task = task; - } public void subscribe(Set partitions) { log.trace("[{}] Subscribing to partitions: {}", key, partitions); @@ -53,23 +48,18 @@ public class TbQueueConsumerTask { public void initiateStop() { log.debug("[{}] Initiating stop", key); consumer.stop(); - if (isRunning()) { - task.cancel(true); - } } public void awaitCompletion() { log.trace("[{}] Awaiting finish", key); if (isRunning()) { try { - if (!completionLatch.await(30, TimeUnit.SECONDS)) { - task = null; - throw new IllegalStateException("timeout of 30 seconds expired"); - } + task.get(30, TimeUnit.SECONDS); log.trace("[{}] Awaited finish", key); } catch (Exception e) { log.warn("[{}] Failed to await for consumer to stop", key, e); } + task = null; } } @@ -77,9 +67,4 @@ public class TbQueueConsumerTask { return task != null; } - public void finished() { - completionLatch.countDown(); - task = null; - } - } diff --git a/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbRuleEngineQueueConsumerManager.java b/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbRuleEngineQueueConsumerManager.java index 71a7c45d45..5a59cb124e 100644 --- a/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbRuleEngineQueueConsumerManager.java +++ b/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbRuleEngineQueueConsumerManager.java @@ -242,7 +242,6 @@ public class TbRuleEngineQueueConsumerManager { } catch (Throwable e) { log.error("Failure in consumer loop", e); } - consumerTask.finished(); }); consumerTask.setTask(consumerLoop); } @@ -266,7 +265,7 @@ public class TbRuleEngineQueueConsumerManager { } } } - if (Thread.interrupted() || consumer.isStopped()) { + if (consumer.isStopped()) { consumer.unsubscribe(); } log.info("Rule Engine consumer stopped"); @@ -282,7 +281,7 @@ public class TbRuleEngineQueueConsumerManager { TbMsgPackProcessingContext packCtx = new TbMsgPackProcessingContext(queue.getName(), submitStrategy, ackStrategy.isSkipTimeoutMsgs()); submitStrategy.submitAttempt((id, msg) -> submitMessage(packCtx, id, msg)); - final boolean timeout = !awaitPackProcessing(packCtx, queue.getPackProcessingTimeout(), true); + final boolean timeout = !packCtx.await(queue.getPackProcessingTimeout(), TimeUnit.MILLISECONDS); TbRuleEngineProcessingResult result = new TbRuleEngineProcessingResult(queue.getName(), timeout, packCtx); if (timeout) { @@ -310,19 +309,6 @@ public class TbRuleEngineQueueConsumerManager { } } - private boolean awaitPackProcessing(TbMsgPackProcessingContext packCtx, long processingTimeout, boolean ignoreInterrupt) throws InterruptedException { - try { - return packCtx.await(processingTimeout, TimeUnit.MILLISECONDS); - } catch (InterruptedException e) { - if (ignoreInterrupt) { - log.debug("Interrupt happened while waiting for pack processing, trying to await one more time"); - return awaitPackProcessing(packCtx, processingTimeout, false); - } else { - throw new RuntimeException("Failed to await pack processing due to thread interrupt", e); - } - } - } - private TbRuleEngineSubmitStrategy getSubmitStrategy(Queue queue) { return ctx.getSubmitStrategyFactory().newInstance(queue.getName(), queue.getSubmitStrategy()); } From be7854fb5baee31af0a9455c749755c80134b17e Mon Sep 17 00:00:00 2001 From: ViacheslavKlimov Date: Thu, 19 Oct 2023 18:58:41 +0300 Subject: [PATCH 23/43] Add 'isolated' to topic and consumer group name for isolated queues --- .../thingsboard/server/common/msg/queue/TopicPartitionInfo.java | 2 +- .../server/queue/provider/KafkaMonolithQueueFactory.java | 2 +- .../server/queue/provider/KafkaTbRuleEngineQueueFactory.java | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/common/message/src/main/java/org/thingsboard/server/common/msg/queue/TopicPartitionInfo.java b/common/message/src/main/java/org/thingsboard/server/common/msg/queue/TopicPartitionInfo.java index 7122d5ef2a..d2144e8111 100644 --- a/common/message/src/main/java/org/thingsboard/server/common/msg/queue/TopicPartitionInfo.java +++ b/common/message/src/main/java/org/thingsboard/server/common/msg/queue/TopicPartitionInfo.java @@ -42,7 +42,7 @@ public class TopicPartitionInfo { this.myPartition = myPartition; String tmp = topic; if (tenantId != null && !tenantId.isNullUid()) { - tmp += "." + tenantId.getId().toString(); + tmp += ".isolated." + tenantId.getId().toString(); } if (partition != null) { tmp += "." + partition; diff --git a/common/queue/src/main/java/org/thingsboard/server/queue/provider/KafkaMonolithQueueFactory.java b/common/queue/src/main/java/org/thingsboard/server/queue/provider/KafkaMonolithQueueFactory.java index 22a16de64f..55050ce08c 100644 --- a/common/queue/src/main/java/org/thingsboard/server/queue/provider/KafkaMonolithQueueFactory.java +++ b/common/queue/src/main/java/org/thingsboard/server/queue/provider/KafkaMonolithQueueFactory.java @@ -187,7 +187,7 @@ public class KafkaMonolithQueueFactory implements TbCoreQueueFactory, TbRuleEngi consumerBuilder.settings(kafkaSettings); consumerBuilder.topic(configuration.getTopic()); consumerBuilder.clientId("re-" + queueName + "-consumer-" + serviceInfoProvider.getServiceId() + "-" + consumerCount.incrementAndGet()); - consumerBuilder.groupId("re-" + queueName + (configuration.getTenantId().isSysTenantId() ? "" : ("-" + configuration.getTenantId())) + "-consumer"); + consumerBuilder.groupId("re-" + queueName + (configuration.getTenantId().isSysTenantId() ? "" : ("-isolated-" + configuration.getTenantId())) + "-consumer"); consumerBuilder.decoder(msg -> new TbProtoQueueMsg<>(msg.getKey(), ToRuleEngineMsg.parseFrom(msg.getData()), msg.getHeaders())); consumerBuilder.admin(ruleEngineAdmin); consumerBuilder.statsService(consumerStatsService); diff --git a/common/queue/src/main/java/org/thingsboard/server/queue/provider/KafkaTbRuleEngineQueueFactory.java b/common/queue/src/main/java/org/thingsboard/server/queue/provider/KafkaTbRuleEngineQueueFactory.java index 2e3bf784d7..cb063b6a7f 100644 --- a/common/queue/src/main/java/org/thingsboard/server/queue/provider/KafkaTbRuleEngineQueueFactory.java +++ b/common/queue/src/main/java/org/thingsboard/server/queue/provider/KafkaTbRuleEngineQueueFactory.java @@ -166,7 +166,7 @@ public class KafkaTbRuleEngineQueueFactory implements TbRuleEngineQueueFactory { consumerBuilder.settings(kafkaSettings); consumerBuilder.topic(configuration.getTopic()); consumerBuilder.clientId("re-" + queueName + "-consumer-" + serviceInfoProvider.getServiceId() + "-" + consumerCount.incrementAndGet()); - consumerBuilder.groupId("re-" + queueName + (configuration.getTenantId().isSysTenantId() ? "" : ("-" + configuration.getTenantId())) + "-consumer"); + consumerBuilder.groupId("re-" + queueName + (configuration.getTenantId().isSysTenantId() ? "" : ("-isolated-" + configuration.getTenantId())) + "-consumer"); consumerBuilder.decoder(msg -> new TbProtoQueueMsg<>(msg.getKey(), ToRuleEngineMsg.parseFrom(msg.getData()), msg.getHeaders())); consumerBuilder.admin(ruleEngineAdmin); consumerBuilder.statsService(consumerStatsService); From 23cd7f08654fddf66b6d3fa7f882f0e0ce50e336 Mon Sep 17 00:00:00 2001 From: ViacheslavKlimov Date: Fri, 20 Oct 2023 15:03:24 +0300 Subject: [PATCH 24/43] Fix testNotificationRuleProcessing_exceededRateLimits --- .../notification/NotificationRuleApiTest.java | 27 +++++++++++-------- 1 file changed, 16 insertions(+), 11 deletions(-) diff --git a/application/src/test/java/org/thingsboard/server/service/notification/NotificationRuleApiTest.java b/application/src/test/java/org/thingsboard/server/service/notification/NotificationRuleApiTest.java index 0a2854a28d..33aaf2af35 100644 --- a/application/src/test/java/org/thingsboard/server/service/notification/NotificationRuleApiTest.java +++ b/application/src/test/java/org/thingsboard/server/service/notification/NotificationRuleApiTest.java @@ -420,11 +420,11 @@ public class NotificationRuleApiTest extends AbstractNotificationApiTest { notificationRulesCache.evict(TenantId.SYS_TENANT_ID); int n = 10; - updateDefaultTenantProfile(profileConfiguration -> { - profileConfiguration.getProfileConfiguration().get().setTenantEntityExportRateLimit(n + ":600"); - profileConfiguration.getProfileConfiguration().get().setCustomerServerRestLimitsConfiguration(n + ":600"); - profileConfiguration.getProfileConfiguration().get().setTenantNotificationRequestsPerRuleRateLimit(n + ":600"); - profileConfiguration.getProfileConfiguration().get().setTransportDeviceTelemetryMsgRateLimit(n + ":600"); + updateDefaultTenantProfileConfig(profileConfiguration -> { + profileConfiguration.setTenantEntityExportRateLimit(n + ":600"); + profileConfiguration.setCustomerServerRestLimitsConfiguration(n + ":600"); + profileConfiguration.setTenantNotificationRequestsPerRuleRateLimit(n + ":600"); + profileConfiguration.setTransportDeviceTelemetryMsgRateLimit(n + ":600"); }); loginTenantAdmin(); NotificationRule rule = createNotificationRule(AlarmCommentNotificationRuleTriggerConfig.builder() @@ -434,11 +434,14 @@ public class NotificationRuleApiTest extends AbstractNotificationApiTest { rateLimitService.checkRateLimit(LimitedApi.ENTITY_EXPORT, tenantId); rateLimitService.checkRateLimit(LimitedApi.REST_REQUESTS_PER_CUSTOMER, tenantId, customerId); rateLimitService.checkRateLimit(LimitedApi.NOTIFICATION_REQUESTS_PER_RULE, tenantId, rule.getId()); + Thread.sleep(100); } loginTenantAdmin(); - List notifications = await().atMost(30, TimeUnit.SECONDS) - .until(() -> getMyNotifications(true, 10), list -> list.size() == 3); + List notifications = await().atMost(15, TimeUnit.SECONDS) + .until(() -> getMyNotifications(true, 10).stream() + .filter(notification -> notification.getType() == NotificationType.RATE_LIMITS) + .collect(Collectors.toList()), list -> list.size() == 3); assertThat(notifications).allSatisfy(notification -> { assertThat(notification.getSubject()).isEqualTo("Rate limits exceeded"); }); @@ -455,12 +458,14 @@ public class NotificationRuleApiTest extends AbstractNotificationApiTest { }); loginSysAdmin(); - notifications = await().atMost(30, TimeUnit.SECONDS) - .until(() -> getMyNotifications(true, 10), list -> list.size() == 1); - assertThat(notifications).allSatisfy(notification -> { + notifications = await().atMost(15, TimeUnit.SECONDS) + .until(() -> getMyNotifications(true, 10).stream() + .filter(notification -> notification.getType() == NotificationType.RATE_LIMITS) + .collect(Collectors.toList()), list -> list.size() == 1); + assertThat(notifications).singleElement().satisfies(notification -> { assertThat(notification.getSubject()).isEqualTo("Rate limits exceeded for tenant " + TEST_TENANT_NAME); + assertThat(notification.getText()).isEqualTo("Rate limits for entity version creation exceeded"); }); - assertThat(notifications.get(0).getText()).isEqualTo("Rate limits for entity version creation exceeded"); } @Test From aea4d267ffebaa8dca0ffe4b11a1336a4cb35df3 Mon Sep 17 00:00:00 2001 From: ViacheslavKlimov Date: Fri, 20 Oct 2023 15:26:25 +0300 Subject: [PATCH 25/43] Minor improvements --- .../queue/ruleengine/TbRuleEngineConsumerContext.java | 3 ++- .../home/components/profile/tenant-profile.component.ts | 6 +++--- 2 files changed, 5 insertions(+), 4 deletions(-) diff --git a/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbRuleEngineConsumerContext.java b/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbRuleEngineConsumerContext.java index b18df6b62b..da2a5d0db4 100644 --- a/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbRuleEngineConsumerContext.java +++ b/application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbRuleEngineConsumerContext.java @@ -19,6 +19,7 @@ import lombok.Data; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Value; import org.springframework.stereotype.Component; +import org.thingsboard.common.util.ThingsBoardExecutors; import org.thingsboard.common.util.ThingsBoardThreadFactory; import org.thingsboard.server.actors.ActorSystemContext; import org.thingsboard.server.common.stats.StatsFactory; @@ -76,7 +77,7 @@ public class TbRuleEngineConsumerContext { @PostConstruct void init() { this.consumersExecutor = Executors.newCachedThreadPool(ThingsBoardThreadFactory.forName("tb-rule-engine-consumer")); - this.mgmtExecutor = Executors.newFixedThreadPool(mgmtThreadPoolSize, ThingsBoardThreadFactory.forName("tb-rule-engine-mgmt")); + this.mgmtExecutor = ThingsBoardExecutors.newWorkStealingPool(mgmtThreadPoolSize, "tb-rule-engine-mgmt"); this.scheduler = Executors.newSingleThreadScheduledExecutor(ThingsBoardThreadFactory.forName("tb-rule-engine-consumer-scheduler")); } diff --git a/ui-ngx/src/app/modules/home/components/profile/tenant-profile.component.ts b/ui-ngx/src/app/modules/home/components/profile/tenant-profile.component.ts index 26d6611a3c..3f048ab2e3 100644 --- a/ui-ngx/src/app/modules/home/components/profile/tenant-profile.component.ts +++ b/ui-ngx/src/app/modules/home/components/profile/tenant-profile.component.ts @@ -56,7 +56,7 @@ export class TenantProfileComponent extends EntityComponent { const mainQueue = [ { id: guid(), - consumerPerPartition: true, + consumerPerPartition: false, name: 'Main', packProcessingTimeout: 10000, partitions: 1, @@ -84,7 +84,7 @@ export class TenantProfileComponent extends EntityComponent { topic: 'tb_rule_engine.hp', pollInterval: 2000, partitions: 1, - consumerPerPartition: true, + consumerPerPartition: false, packProcessingTimeout: 10000, submitStrategy: { type: 'BURST', @@ -108,7 +108,7 @@ export class TenantProfileComponent extends EntityComponent { topic: 'tb_rule_engine.sq', pollInterval: 2000, partitions: 1, - consumerPerPartition: true, + consumerPerPartition: false, packProcessingTimeout: 10000, submitStrategy: { type: 'SEQUENTIAL_BY_ORIGINATOR', From 6d7cb95492c1a90fc55dab13a5f3d95a563bf690 Mon Sep 17 00:00:00 2001 From: ViacheslavKlimov Date: Fri, 20 Oct 2023 15:46:53 +0300 Subject: [PATCH 26/43] Bigger timeout in tests for msg processing --- .../queue/ruleengine/TbRuleEngineQueueConsumerManagerTest.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/application/src/test/java/org/thingsboard/server/service/queue/ruleengine/TbRuleEngineQueueConsumerManagerTest.java b/application/src/test/java/org/thingsboard/server/service/queue/ruleengine/TbRuleEngineQueueConsumerManagerTest.java index 20b765da6d..38582d0fce 100644 --- a/application/src/test/java/org/thingsboard/server/service/queue/ruleengine/TbRuleEngineQueueConsumerManagerTest.java +++ b/application/src/test/java/org/thingsboard/server/service/queue/ruleengine/TbRuleEngineQueueConsumerManagerTest.java @@ -184,7 +184,7 @@ public class TbRuleEngineQueueConsumerManagerTest { ruleEngineConsumerContext.stop(); if (generateQueueMsgs) { - await().atMost(2, TimeUnit.SECONDS) + await().atMost(10, TimeUnit.SECONDS) .untilAsserted(() -> { log.debug("totalConsumedMsgs = {}, totalProcessedMsgs = {}", totalConsumedMsgs.get(), totalProcessedMsgs.get()); assertThat(totalProcessedMsgs.get()).isEqualTo(totalConsumedMsgs.get()); From 802890cdc0b99703f1431dad5c4e5ec643dc130c Mon Sep 17 00:00:00 2001 From: Volodymyr Babak Date: Mon, 23 Oct 2023 19:37:38 +0300 Subject: [PATCH 27/43] Fixed testIsolatedTenantProfile - correct expected number of downlink msgs --- .../server/edge/TenantProfileEdgeTest.java | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) diff --git a/application/src/test/java/org/thingsboard/server/edge/TenantProfileEdgeTest.java b/application/src/test/java/org/thingsboard/server/edge/TenantProfileEdgeTest.java index 7ec32f8aff..6f665ce462 100644 --- a/application/src/test/java/org/thingsboard/server/edge/TenantProfileEdgeTest.java +++ b/application/src/test/java/org/thingsboard/server/edge/TenantProfileEdgeTest.java @@ -32,6 +32,7 @@ import org.thingsboard.server.gen.edge.v1.TenantUpdateMsg; import org.thingsboard.server.gen.edge.v1.UpdateMsgType; import java.util.List; +import java.util.Optional; import static org.assertj.core.api.Assertions.assertThat; @@ -75,17 +76,21 @@ public class TenantProfileEdgeTest extends AbstractEdgeTest { TenantProfileQueueConfiguration mainQueueConfiguration = createQueueConfig(DataConstants.MAIN_QUEUE_NAME, DataConstants.MAIN_QUEUE_TOPIC); TenantProfileQueueConfiguration isolatedQueueConfiguration = createQueueConfig("IsolatedHighPriority", "tb_rule_engine.isolated_hp"); edgeTenantProfile.getProfileData().setQueueConfiguration(List.of(mainQueueConfiguration, isolatedQueueConfiguration)); - edgeImitator.expectMessageAmount(1); + edgeImitator.expectMessageAmount(3); edgeTenantProfile = doPost("/api/tenantProfile", edgeTenantProfile, TenantProfile.class); Assert.assertTrue(edgeImitator.waitForMessages()); - AbstractMessage latestMessage = edgeImitator.getLatestMessage(); - Assert.assertTrue(latestMessage instanceof TenantProfileUpdateMsg); - TenantProfileUpdateMsg tenantProfileUpdateMsg = (TenantProfileUpdateMsg) latestMessage; + + Optional tenantProfileUpdateMsgOpt = edgeImitator.findMessageByType(TenantProfileUpdateMsg.class); + Assert.assertTrue(tenantProfileUpdateMsgOpt.isPresent()); + TenantProfileUpdateMsg tenantProfileUpdateMsg = tenantProfileUpdateMsgOpt.get(); Assert.assertEquals(UpdateMsgType.ENTITY_UPDATED_RPC_MESSAGE, tenantProfileUpdateMsg.getMsgType()); Assert.assertEquals(edgeTenantProfile.getUuidId().getMostSignificantBits(), tenantProfileUpdateMsg.getIdMSB()); Assert.assertEquals(edgeTenantProfile.getUuidId().getLeastSignificantBits(), tenantProfileUpdateMsg.getIdLSB()); Assert.assertEquals(edgeTenantProfile.getDescription(), tenantProfileUpdateMsg.getDescription()); + List queueUpdateMsgs = edgeImitator.findAllMessagesByType(QueueUpdateMsg.class); + Assert.assertEquals(2, queueUpdateMsgs.size()); + loginTenantAdmin(); edgeImitator.expectMessageAmount(21); @@ -95,7 +100,7 @@ public class TenantProfileEdgeTest extends AbstractEdgeTest { Assert.assertTrue(edgeImitator.getDownlinkMsgs().get(0) instanceof TenantUpdateMsg); Assert.assertTrue(edgeImitator.getDownlinkMsgs().get(1) instanceof TenantProfileUpdateMsg); - List queueUpdateMsgs = edgeImitator.findAllMessagesByType(QueueUpdateMsg.class); + queueUpdateMsgs = edgeImitator.findAllMessagesByType(QueueUpdateMsg.class); Assert.assertEquals(2, queueUpdateMsgs.size()); for (QueueUpdateMsg queueUpdateMsg : queueUpdateMsgs) { Assert.assertEquals(tenantId.getId().getMostSignificantBits(), queueUpdateMsg.getTenantIdMSB()); From eddd4b2c6cf746d11cdb704cc414c98f8d495889 Mon Sep 17 00:00:00 2001 From: Igor Kulikov Date: Tue, 24 Oct 2023 10:36:46 +0300 Subject: [PATCH 28/43] UI: Outdoor Environment: Visibility widgets. --- .../widget_bundles/outdoor_environment.json | 10 +++++- .../horizontal_visibility_card.json | 28 +++++++++++++++++ ...ontal_visibility_card_with_background.json | 28 +++++++++++++++++ .../simple_visibility_chart_card.json | 31 +++++++++++++++++++ ...visibility_chart_card_with_background.json | 31 +++++++++++++++++++ .../system/widget_types/visibility_card.json | 28 +++++++++++++++++ .../visibility_card_with_background.json | 28 +++++++++++++++++ .../widget_types/visibility_chart_card.json | 31 +++++++++++++++++++ ...visibility_chart_card_with_background.json | 31 +++++++++++++++++++ 9 files changed, 245 insertions(+), 1 deletion(-) create mode 100644 application/src/main/data/json/system/widget_types/horizontal_visibility_card.json create mode 100644 application/src/main/data/json/system/widget_types/horizontal_visibility_card_with_background.json create mode 100644 application/src/main/data/json/system/widget_types/simple_visibility_chart_card.json create mode 100644 application/src/main/data/json/system/widget_types/simple_visibility_chart_card_with_background.json create mode 100644 application/src/main/data/json/system/widget_types/visibility_card.json create mode 100644 application/src/main/data/json/system/widget_types/visibility_card_with_background.json create mode 100644 application/src/main/data/json/system/widget_types/visibility_chart_card.json create mode 100644 application/src/main/data/json/system/widget_types/visibility_chart_card_with_background.json diff --git a/application/src/main/data/json/system/widget_bundles/outdoor_environment.json b/application/src/main/data/json/system/widget_bundles/outdoor_environment.json index cdc04605ad..75b41d4e4d 100644 --- a/application/src/main/data/json/system/widget_bundles/outdoor_environment.json +++ b/application/src/main/data/json/system/widget_bundles/outdoor_environment.json @@ -77,6 +77,14 @@ "air_quality_chart_card", "air_quality_chart_card_with_background", "simple_air_quality_chart_card", - "simple_air_quality_chart_card_with_background" + "simple_air_quality_chart_card_with_background", + "visibility_card", + "visibility_card_with_background", + "horizontal_visibility_card", + "horizontal_visibility_card_with_background", + "visibility_chart_card", + "visibility_chart_card_with_background", + "simple_visibility_chart_card", + "simple_visibility_chart_card_with_background" ] } \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/horizontal_visibility_card.json b/application/src/main/data/json/system/widget_types/horizontal_visibility_card.json new file mode 100644 index 0000000000..2d7507602f --- /dev/null +++ b/application/src/main/data/json/system/widget_types/horizontal_visibility_card.json @@ -0,0 +1,28 @@ +{ + "fqn": "horizontal_visibility_card", + "name": "Horizontal visibility card", + "deprecated": false, + "image": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAMgAAACgCAMAAAB+IdObAAAAolBMVEUAAADf39/f39/g4ODg4ODf39/////k5OSAwyzg4OCg0mHf8Mrz8/PP6bCQy0bv9+XOzs75+fn3+/K3t7erq6vCwsLA4Za8vLyQkJDa2trV1dXHx8ew2Xvn5+fn9NjIyMi43YhYWFg8PDx0dHTY7L2YzlPH5aOIxzmenp6Ixzrt7e2CgoKn1m5mZmYhISHb29u43Ymo1m6tra3H5aJKSkovLy/b7uh5AAAABnRSTlMAIEDfv1C6kOEmAAADOUlEQVR42u3aCU/bMBjG8a6wN27jxM7dXE3Tm2uw6/t/tb02ZWEbdFWpqoCenxCx7EjwT0xboAMAAAAAAAAAAAAAAAAAAAAAAAAAAACAc/r07tmM4YXz3o0uPnOHE9C7J53h4FLSBxBcDkb0IYwQ0jMI6RuE9A1C+gYhfXNIiNwSleXWIZaVccaHG1rQVsoevUw7JIR+SmrLUpIjqSgmMRfFNKdY3nALOXRK7jr11NNoSTueGB8R4la+EJuxp+jJZOvMaVFOFvNyEk/au5a+0JzbfrTRggcnlArmT3+P1PEhaix2fI92yjZe2JBMcgjfDWlDHDPklNPxhO9OU+ETKTOaifHRIdMNF6xDmt5yyox22rbgkKK8i23Izy7k5kdEpzMWZjddCUUz88XDKxE+C1EqDBV/a0vFS567N0SZDkUun1s9K5nMiUO2d23EIXftDT2GxHOnnNMJLT1lQ8Jd0kpMu5AHsQpdsTI7Jk3tvtsT4vMJ3+nBnBUK9me27A5PI95zp+aJFXGIS/bz75DUXmG+uMuZ2TRLX6Svh3iCuVPBZrQS4r9bUy4cOjHli+kLIbaDQ8b2Rnlm7vb1kLUNUV2IT+cWmiv9b8hGmDwbYqft8PWQ0DcbkCrB+TbHozMLV6bj3xA2OziETa+E2ChaeiFVtuncKjHbHb0/ftg3yyvhHhbSlfic4Y6fPWhJeoG8/ntC0ps9PG38tfhqn0y655Gl8MODQ5haiZ3Nd9qJbAx/XOdkBQEFI20mRhQQUR3XFOT54wJPHJu0FuJrxTyzyavUF2kXQrfcdngIc6sVV4zXIT0LKQqdN43mUUJJnmRBlOiiaHR2rbOASNcyy3KS2i7oJjt2Yz2q7IOX2MyoCzFt6/0he3QhOpKNrvVjSF3c85jn6lwnjQ0Z5TmHNFHdSM5NJL1ZqMJTv/r9pu8THRVNIs0d0VmeRDJqNM9dZ3WjyYQE5o7U2TezUCQJHeH8v1jlNb2uaO7pEH0ICYJ9i5IO0YuQPkJI3yCkbxDSNwjpm9Hg8gP8m51IXg6GTo/+gnuswBkOBp8vRs57dzH8SG+qAQAAAAAAAAAAAAAAAAAAAAAAAAAAADiTXxBy+4qYs+NTAAAAAElFTkSuQmCC", + "description": "Displays a latest visibility telemetry data in a horizontal layout.", + "descriptor": { + "type": "latest", + "sizeX": 5, + "sizeY": 1, + "resources": [], + "templateHtml": "\n", + "templateCss": "", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueCardWidget.onDataUpdated();\n};\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n horizontal: true,\n previewWidth: '420px',\n previewHeight: '90px',\n embedTitlePanel: true,\n defaultDataKeysFunction: function() {\n return [{ name: 'visibility', label: 'Visibility', type: 'timeseries' }];\n }\n };\n};\n\nself.onDestroy = function() {\n};\n", + "settingsSchema": "", + "dataKeySettingsSchema": "", + "settingsDirective": "tb-value-card-widget-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"function\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Visibility\",\"color\":\"#2196f3\",\"settings\":{},\"_hash\":0.2392660816082064,\"funcBody\":\"var value = prevValue + Math.random() * 10 - 5;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 20) {\\n\\tvalue = 20;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]}}],\"timewindow\":{\"realtime\":{\"timewindowMs\":60000}},\"showTitle\":false,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"padding\":\"0px\",\"settings\":{\"labelPosition\":\"top\",\"layout\":\"horizontal\",\"showLabel\":true,\"labelFont\":{\"family\":\"Roboto\",\"size\":16,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"labelColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showIcon\":true,\"iconSize\":40,\"iconSizeUnit\":\"px\",\"icon\":\"visibility\",\"iconColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":0,\"to\":1,\"color\":\"#D81838\"},{\"from\":1,\"to\":4,\"color\":\"#FFA600\"},{\"from\":4,\"to\":null,\"color\":\"#80C32C\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"valueFont\":{\"size\":36,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\",\"rangeList\":[{\"from\":0,\"to\":1,\"color\":\"#D81838\"},{\"from\":1,\"to\":4,\"color\":\"#FFA600\"},{\"from\":4,\"to\":null,\"color\":\"#80C32C\"}]},\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"dateColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"color\",\"color\":\"#fff\",\"overlay\":{\"enabled\":false,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Horizontal visibility card\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"units\":\"km\",\"decimals\":0,\"useDashboardTimewindow\":true,\"showLegend\":false,\"widgetStyle\":{},\"actions\":{},\"configMode\":\"basic\",\"displayTimewindow\":true,\"margin\":\"0px\",\"borderRadius\":\"0px\",\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"showTitleIcon\":false,\"titleTooltip\":\"\",\"titleFont\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1.6\"},\"titleIcon\":\"\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"iconSize\":\"14px\",\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"14px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1\"},\"color\":null}}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "visibility" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/horizontal_visibility_card_with_background.json b/application/src/main/data/json/system/widget_types/horizontal_visibility_card_with_background.json new file mode 100644 index 0000000000..95bf6c6a82 --- /dev/null +++ b/application/src/main/data/json/system/widget_types/horizontal_visibility_card_with_background.json @@ -0,0 +1,28 @@ +{ + "fqn": "horizontal_visibility_card_with_background", + "name": "Horizontal visibility card with background", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays a latest visibility telemetry data in a horizontal layout with background.", + "descriptor": { + "type": "latest", + "sizeX": 5, + "sizeY": 1, + "resources": [], + "templateHtml": "\n", + "templateCss": "", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueCardWidget.onDataUpdated();\n};\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n horizontal: true,\n previewWidth: '420px',\n previewHeight: '90px',\n embedTitlePanel: true,\n defaultDataKeysFunction: function() {\n return [{ name: 'visibility', label: 'Visibility', type: 'timeseries' }];\n }\n };\n};\n\nself.onDestroy = function() {\n};\n", + "settingsSchema": "", + "dataKeySettingsSchema": "", + "settingsDirective": "tb-value-card-widget-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"function\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Visibility\",\"color\":\"#2196f3\",\"settings\":{},\"_hash\":0.2392660816082064,\"funcBody\":\"var value = prevValue + Math.random() * 10 - 5;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 20) {\\n\\tvalue = 20;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]}}],\"timewindow\":{\"realtime\":{\"timewindowMs\":60000}},\"showTitle\":false,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"padding\":\"0px\",\"settings\":{\"labelPosition\":\"top\",\"layout\":\"horizontal\",\"showLabel\":true,\"labelFont\":{\"family\":\"Roboto\",\"size\":16,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"labelColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showIcon\":true,\"iconSize\":40,\"iconSizeUnit\":\"px\",\"icon\":\"visibility\",\"iconColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":0,\"to\":1,\"color\":\"#DE2343\"},{\"from\":1,\"to\":4,\"color\":\"#F89E0D\"},{\"from\":4,\"to\":null,\"color\":\"#7CC322\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"valueFont\":{\"size\":36,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\",\"rangeList\":[{\"from\":0,\"to\":1,\"color\":\"#DE2343\"},{\"from\":1,\"to\":4,\"color\":\"#F89E0D\"},{\"from\":4,\"to\":null,\"color\":\"#7CC322\"}]},\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"dateColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"image\",\"imageBase64\":\"data:image/png;base64,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\",\"imageUrl\":null,\"color\":\"#fff\",\"overlay\":{\"enabled\":true,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Horizontal visibility card\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"units\":\"km\",\"decimals\":0,\"useDashboardTimewindow\":true,\"showLegend\":false,\"widgetStyle\":{},\"actions\":{},\"configMode\":\"basic\",\"displayTimewindow\":true,\"margin\":\"0px\",\"borderRadius\":\"0px\",\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"showTitleIcon\":false,\"titleTooltip\":\"\",\"titleFont\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1.6\"},\"titleIcon\":\"\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"iconSize\":\"14px\",\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"14px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1\"},\"color\":null}}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "visibility" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/simple_visibility_chart_card.json b/application/src/main/data/json/system/widget_types/simple_visibility_chart_card.json new file mode 100644 index 0000000000..1114718ef3 --- /dev/null +++ b/application/src/main/data/json/system/widget_types/simple_visibility_chart_card.json @@ -0,0 +1,31 @@ +{ + "fqn": "simple_visibility_chart_card", + "name": "Simple visibility chart card", + "deprecated": false, + "image": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAMgAAACgCAMAAAB+IdObAAAAhFBMVEUAAADf39/g4ODf39/f39/g4OD////k5OTg4OCAwywhISE8PDzj4+NYWFjv9+V0dHSsrKyQkJCg0mDy8vLHx8cvLy/V1dWv2Xuenp7P6a+Qy0b3+/OIxzmCgoK6urpmZmaQykbH5aPf8MpKSkrA4Za+4ZSYzlPn9Ni43YhLS0vY7L2o1m7UZuoPAAAABnRSTlMAIL9AEN/GQiaNAAAEm0lEQVR42uzPuxGAIBQAsMdHpKCjdP89PTewBC7ZIAEAAAAAAPBfTZur8Sl53JsbV4lI42nbm6NEnu0AM0dvR+giixFZjcjLbr2rSA4DURjOTnCqCkmUJJTYDjry+7/gIvdlepcF98yAkcF/VMZKPlSBRuuCjNYFGa0LMloXZLR+BVHHI1f8pOMhGjKAOegUcM9vEXL/WBqSoK6Oo9uHeFvMQsarYgBMMDc8muoT0jaIBoUFHNk+pApLWMjgeJSKwzlhjkBOSYHUIa1Pcd4gyaOsMSegJsdeh0AqaV5VC1/rkpkRqQiGyCmwghFSFmOGhQ7J1FYk9YNBsNshECF1InMiEx5ZwGLokFQU6Q5ZAJm+IH1CmSAN+x0AySQ7JkXy9rZbjBtEpVjEBgnour8hSfq02xEQ3MjcKBrebsQ5Ue8Qr4nzE2LLP5DM9Yb9DoGoUNQ9kgGvjIYNsqyqJW4QqZnxDbKYAsaIQ9qHQI00YUn4KkoEMC39ZzGHzLAgXRcmNEMVReMNSIdt1j4EyCmE5vhJwfCNhnii/KePN2t8SMr4pPEhn3VBLshZuiCjdUFG64KM1gUZrSEhXrOfH+LJSHKNfm5IFVqLczNKPTOkFslPUannhaiIvs1+Wsgf9sywV1kQCsDf2A4gooaaoL1at1r9///3AqZmsS7eNqebz4fQoI3HA+c4Gh1cpDharQgJ0ROhSFYqwvFufOQZrVQkIC/3IlmNyI7zPgoU85dOHK1EZEewpstUIaZvIVqgCK2q3asHJpymnAjepqzoTRTzpYmkAdYQ/lI1krbFQVQGOHTtmuRLESZRj2Sop47v6A9UWERpWh1HD73slxI/YhFw19rD5Tci8qQAioy1Uy8AVNa5ZPAPTYcKkjwqXj586TPJCJfJ8ItkmggrtIZWOZuo/GgNe/2NyLCNA4E6CKFexZ5waiTsW7E48AkiGajGGtRaCuAu0R7g1It8VbF3fc3LMffeXYIIjIOS5yHRXt4iCrKuMQpmVcUQO0XkpbExbC4fsyyuUMfxEYdUhN6JIg+Hf2u4UfETkVlmZ1fAFaErnO1GAfUsEgNc9EdWm710YzHohn1YWeQ5VYkopWkktNBUBpVqQvplAPsuFDYwg8j10QVw1h+qUHEB7Tg3o4dPQ2wIE/RnODlOEMmgQG6RH4BTFxZUt8GIQfm+CyJa5dxozHL4YGZ7c4tYj75LAtT9ADcHghzMJFKb2TpFFMAdPXUB7D+LUFfJnkvk1uXb+5uIoZkikuMUOZhF5KIgG6XbGqC7h6yAQvqLUGeenUeEFRAPS0za+Z/7YokagKu3CHUX8FlEmH3kLdJOmo0qu00EniK5cJ9PzSJyNrXBcrE1I44VFKwXsSMU8xGhAQ7c8ZhFpICOxuZhTTx++2UKYg+RXIgczYN7afVIpJFNM8xRMvZouks7yt68kBw8w7Hw0/jqczhWI1L+Eo71iPwSjtWIfGYT2UTWwiayNDaRpbGJLI1NZGlsIv/buWMaAEAYAIKBhq0O8O8TJDCW5s7BG/hqhFTTKKTNcieyQcnOcbdU6/8t1YxOozAAAAAAAIAnB7h9+fIl+d57AAAAAElFTkSuQmCC", + "description": "Displays historical visibility values as a simplified chart. Optionally may display the corresponding latest visibility value.", + "descriptor": { + "type": "timeseries", + "sizeX": 4.5, + "sizeY": 2, + "resources": [], + "templateHtml": "\n\n", + "templateCss": ".legend {\n font-size: 13px;\n line-height: 10px;\n}\n\n.legend table { \n border-spacing: 0px;\n border-collapse: separate;\n}\n\n.mouse-events .flot-overlay {\n cursor: crosshair; \n}\n\n", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueChartCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueChartCardWidget.onDataUpdated();\n};\n\nself.onLatestDataUpdated = function() {\n self.ctx.$scope.valueChartCardWidget.onLatestDataUpdated();\n}\n\nself.onEditModeChanged = function() {\n self.ctx.$scope.valueChartCardWidget.onEditModeChanged();\n}\n\nself.onDestroy = function() {\n self.ctx.$scope.valueChartCardWidget.onDestroy();\n}\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '300px',\n previewHeight: '150px',\n embedTitlePanel: true,\n hasAdditionalLatestDataKeys: true,\n defaultDataKeysFunction: function() {\n return [\n { name: 'visibility', label: 'Visibility', type: 'timeseries', color: 'rgba(0, 0, 0, 0.87)'}\n ];\n },\n defaultLatestDataKeysFunction: function(configComponent) {\n return [{ name: 'visibility', label: 'Latest', type: 'timeseries'}];\n }\n };\n}\n", + "settingsSchema": "{}", + "dataKeySettingsSchema": "{}", + "latestDataKeySettingsSchema": "{}", + "settingsDirective": "tb-value-chart-card-widget-settings", + "dataKeySettingsDirective": "", + "latestDataKeySettingsDirective": "", + "hasBasicMode": true, + "basicModeDirective": "tb-value-chart-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Visibility\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 10 - 5;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 20) {\\n\\tvalue = 20;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 10 - 5;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 20) {\\n\\tvalue = 20;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"layout\":\"left\",\"autoScale\":true,\"showValue\":true,\"valueFont\":{\"family\":\"Roboto\",\"size\":28,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\",\"lineHeight\":\"32px\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":0,\"to\":1,\"color\":\"#D81838\"},{\"from\":1,\"to\":4,\"color\":\"#FFA600\"},{\"from\":4,\"to\":null,\"color\":\"#80C32C\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"color\",\"color\":\"#fff\",\"overlay\":{\"enabled\":false,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}}},\"title\":\"Visibility\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":null,\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"visibility\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"18px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":true,\"decimals\":0,\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null,\"units\":\"km\",\"displayTimewindow\":true,\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1697382151041,\"endTimeMs\":1697468551041},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"timewindowStyle\":{\"showIcon\":false,\"iconSize\":\"24px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":true}}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "visibility" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/simple_visibility_chart_card_with_background.json b/application/src/main/data/json/system/widget_types/simple_visibility_chart_card_with_background.json new file mode 100644 index 0000000000..cc20374470 --- /dev/null +++ b/application/src/main/data/json/system/widget_types/simple_visibility_chart_card_with_background.json @@ -0,0 +1,31 @@ +{ + "fqn": "simple_visibility_chart_card_with_background", + "name": "Simple visibility chart card with background", + "deprecated": false, + "image": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAMgAAACgCAMAAAB+IdObAAADAFBMVEUAAADFztBRUD5sZlK3ub6gm5ujrrOCgHSFiodiW0myvsdTUD+Yp7HAytBKSzjAytDx8/Xw8vPv8fHr7u/m6Oft8PHy9Pbr7Ozo6uvu7/Ds7e3r6+vk5eLo6enk5ODm5+Xq7O7q6+vh4Nvo7O3t7u/t7e3I0dfEzdTCzNLk5ubl5uPn6Onq6el8wyLv8fPK09jg3trj5eTh4dzj49/k5uTk49/i4t7a2tbGz9TBy9HZ2dXd3tro6Ofb29jn6evj4dy/ydDm5uXh4+KYpq+Zp7Hf3tjf4eHH0NXc3Nje4N7f39vZ2tcfHx/Y2dW9x87X19Syvsbh4d67xcyaqbJSUlOruMGotb7M1Nm6tbU4OTmuu8Ocq7VzbFZnZlKWo6ukn563sbDb3NrJycRZWkijsLmanJqopKWinZuCf25lXUzP19y2tLSGh4hxaVSQmp+3wsqtpqWNl5p3cFhUU0VOUD+Jxzmls7y0rq2foaJlalRWWEVJSzorKyweHh61wMmfrbeurq9pbFdgWkhPUUJNTTvPz8h2fXx6cVu/vLu+uLd/dmZbV0RSVUSrqapjZV5VWUjZ2da5xMrS0cnR28OutrmvqaiKlJU3NzfU1tfI0NXX4cuzusCqpKKfmpmVmpZQVEmwq6uSnaOEg3SCe2tsb1q2vsS7ubmUoKeEjI14bFawuL2moaF7g4KJh3ttbW5saVNsZE9VVkGus7a82JlmaWV9c2KVy1FkY1BoYU9TWU1TU0CrsLSWlpWWlo2Mi4BrbGxbX1RfXkxSUD1wZlLDwMCcn56HkJKTmJFzcFtYXk7R09S7vL2prbCio6SRkpGRlox6dlxubFZjZ1JeZ1FrZ1aWy1Khp6unp6icmZZ/iIdxe3ilqq6ooZ6MkIZudnOhzmheY1hxdF5FRUYfHyDNzs23uLmv04FfYGBaY0+CxS65wsjExcbHycqj0GqgpKiCg4JFSDnd49fY3dC21Y6UkId2dnbR0s/K2rNqcWzD2KiPyUWo0HV3eGKDxS6czV66w8h4Ec1kAAAAEHRSTlMAICAgICAgIBC/QEC/39+/2GDgfwAAF5ZJREFUeNrs1LFKA0EQxvETRCQovsXudrZ73YGB7UQMRjCtvZ1lfIaU+4o+hd/M5MtwHgFLi/lrkjWg5y+ze0MURVEURVEURVEURVEURVEURdHfu7461+X5Lv5R18pY3Ww2O+lLekef759oK71Yb9KTtd9/WM/WI5qmaUSllFyyVDOyRa1N6qmlptXeWmL36R5PGl+OVS3LHyxalliRL3wjXPh2NQxX682aEoMgQigxByFGORzomACBpABCSa2kwCEUMDSIBNLIkCfrlZpkQdxqrvZPo+wUEpBBpnE13KzhoGQGWUjEsifkAIg6lDJiIubQahOBLaUmJXkkeyHEFfbQt8yR4DhCrEwIF8YABN0ND3Ag31tflChjSwf6NRHfWTaR2cWqCsRhazF0AHpPWFr66Zvj1SiziSAOtjC3YMWJaIDISHY+kuXWWkJ8IsrQiZTRx8+5KAcPrDgFeHqXJRF0cCZMh8e5OoUG23AjIdPwQMnsvDtkewZCiZ91P+w8JqCY5XjkVYCZdDpsDogk21w+k9w4E89+4lvZHIDA4ad9RweiY3HbWkLQCVJGuw5PRz3VYNC5dGN40JAxq9GxoPC8zyfipx0tTzshdIjk+8D7ljr8roVnuYjMQC09KcI8SQdicR4ykaWBe0t+0yWj7y/KVFIcopIfVuzftYkwjuN4/gTvzsdooBAxCFIIuOnioBAQHhzkUA5BEJzkELpIhgydsjkIogedHERwyODaQCYdGu3o0i0lBExx01U/3+9z335zeS6/qu8++VVLe6/7PtcUn9LBezPwh0BjcAfvrgzEJ5y3DW5INj/f5BLIe/YMa3EP+Y4+8uSXgCSn4oZjkMRBEEEePLvC1a/UqWguM1cYhk0qCLC4c8G5NbpwAWu98JXnlnXlKkEKFzt6cQ0IJ3HNOaLVkPVaH4KWS8xDngdtDYKAgnd3zEMqg3iOUwk51qdsplgBCW7d5EDJIaDoQASyYmfBoZBNdtd/ctAPM7hKMQ+GyN4ig1A2u0jm+y8O+rJFAiy60T1NA4sgIikyBLJ6b+l1ohLc/h2Cryyfg2jIQxA4ZCJoFcR4kUMg3mD+w84qdwREocUvAji4e5XH/kTWHQliyuYb7MySAIsFEhycvo888idS9xjLKL7EfZR11gtECCrJGffuAYJA2fRiR9ltXCdN+rielVHc+DeFMGEZQx2IFXBgazEEXbm4+CI5GIxxv9vLuj3juj1qm6THE5n0m2nSPBld9yni2BhSLgn8HEMg+cWukNbhJI7p4KVOjLs4Mbt9k9c9AYQGEvYZkvWyZtwLvDYeiRJ8hR8InGwtXCQXFTJNbGcwsXbQEkjaaUUt241228YM0zQzJiVIP83CsL0bpkmYpde/JaNvwzQITtLrs3sr2OQPlUUGH8K/Khly/z4WQ1hyETnI1Nq4NT046NiRSMZ2HLVtFvVi07bdnj0xFlurM4mPhybuEWR4nPU7STo8Hga9xCHyrbXWVAi2cEMVEc2Zwvvcq/uvKo95bxUgibUHv6wdp9amUV48iCbYXoPYpJ2MxnEMyMSYpKuQMO41m51ukPTn9pVMZuP8MbhC5O6B4H7kEEQOloyttfW3QHy2djSzt2ybIFGWdOK2YQiu/EkMiFEITHjmQfBMXm+kUAkrgvA0+u2P9eeHSyB3BEKNMI1DmxwMdCJ0gdjMQW6fpHbXWAeJJwVIiMfRKJD807rG4etFoQQsShAaCO85QJgCCMWSgwSKVquNqz06LbZxxJDJKMs6bYYkJ0M8MMQQZBJnYTM+/oYf60MkvFwB8fdTwAhVaCAIRPaWczhJbG2c2E4683bSTtq4706iLLad+LZJdiFIbGxMr2v6sTlJMtM/HoVhepzpm6NCfErBo1/pIUAQhWGGD9l7v1f5wCNBYDgLNU4Hg8OW/7eKZEoLqV4sDqTn19esDIRCRrrk7umRFHtwMATNQLw3eLb4lEvRJXwrj4KdhZ8JytmTAXgGlZy2J/kQSDSV+BZAkKGbFqbDf3GEfmUEH/Kx8uHDY7YIRPItyKOcYlRCNc9ACYPlCF8RYTECEQQU6hblWZZQlOOa+9s+xB7nw8OS46RTzotu/Jr/sRSwAhE1IooRDHknEjA8ymVofEt9IYUwYV7gAO4pxy9XZRTiBi0zLzI4hbwG5B0oVO7AKlouq2T5aIQSSjjsTTNIFXOERoPvaRYKeZ0HCHKQbX8oTBHLSkxD9pdO4AwKOhtYBYRHkMjAmMrz5zllG5FFKRoowNTVUivVNHDOKEgWZ/jm/hcmN3tjoJTQwCxKEDUsQNCnT68/AQIJtS05irfDeC5VYISCpa45iw4Fa9l1rAK/BgRMoOYVVL1WYwba54kwRSGSb2FMvarHX0MOhZQyKyk45JBX1siPnhmRryhC9vcBoaB5vr19Xi3arMTNBVVRXapWa9WaSzRMCUta6tB9xIhygMan0I2DJrKzs+Mo588Dom15EqEoBsEBSZUwBU2jXMKOxqJ0DFINeQIeRRULsYOqwCEQSShbWyLxKcBUyeLnJLS/yiHFrdLg5q/i2rIA0PbzvlZ2kECUIp1alAODVi2NKeUSgtAZxlqzKt1k6F5k2P+KKm92KIUohTlblMxFKcIRj5hE5iCmFCKGqlxckhzp3en4bnWd8GO/cgyBhLuGhOFtMafx51IeS8ohzlFd3N00tmj0Obdc5qXxSdOOjoA4QoAQRSHXtosclrgA2WKFclQkn1BI41JoynYWO4pyfT1NbHz4+eVhbJPp5TU6ogSiExEDOEUNMOIRjBf+TWYle6t0a6lDNqmejGknGV/kpm87UzlZuNGdPJMH6uh7XuXLGyQQptDij0Li0Oiw+WH+syyhiaByiExQvgsWv/r99u3vLY6fP8FnV+QUP3/+/MuY/bu0EcZxHM8fYWmpmpsyJO0zBBOXuuSGgjSLkCWjw01xDTjcgVO3loLDlUA7SofSpcHJNIsSsDROoVaoAQmWoDakUeIPlH6+33uePHn6GOjb9HLxV+6V73OnWEBkSZUhsMZiZ/vURJTDhrDBrhd09IPtoHfPN+cbxzuRgiFIQv6Dgu6xkHDsg48mTuQBQx4Dcs/3wBeH9dHvF3i2ur9MH9CfsTBr9fv3N7S6uhr78AESsqTThkRqJnOeqKyxYSR0srNEWeQWRRMhupUXlMYfloLe6Pn0kypZ9I5VFSCSkqZYoTkTLVMWwVE7JoQlxh1PxHLw1xdCutMV/GX7ic12VIBQDFGNSSyLlZOknKTD8VUBDoZAYscTeUQOhyp5XsmRdQLPMcJIJGxiOzsebii2AgZFEFUm8z8WPAcRMiiXyzmINhpiS9REsLIiRykMUNhxuHoQ7eBl4RynEOKhntI9Kk+2H/uBGAOAadFNnEQuo0ohaJJ6Iol/JG/X1r7Sz0NMhCDELgWh19n2Qt+jRz28/uNBUgo88rBAW2zI+/13sY9K4rrpyRbjh4xEJHPkSFMzabbQYKYWAIFDShiD22khj4qr45BOGL7J4QXohEGhd1EIqvxqGJRC+ILnwxoWOaDIfeo95xEE/aBcTmkqfUgQYfoVTRm07pLMQEBQLlNmgKGjmIJj2oSgNfxF/PR07Si/QpDpCHIRdFJR3lHgFzyeK3LonzpLLhwzMHQE4fa3AEEM0fWPb4Uon1V4LoOyELdnynImyhFCKuRAZrgxiCl56xddnsxKvpnAyf6UIJ3gIpOSzaRmuNE7lKUXXLxwVB3etSFoK/byJSCUdlTKYHSFuMZU0sdg3NJ+MpnBagIEilSGZwCAUSrFK2v6YTSRxEhSz7+VewU/QZdfQHJh2MngyLWCIZpCQULnESF6BVwX/F+eDWk0GlsEkZTnFEPORHfouhAMsMSEuOtnPgtxnOEAAUIDLAgNBBORI8EbVfykSBv5DYY8cZqBx19Dt/GwwIy2AfBDPwgKF16zGgahQQECDIZwCsKWrmiDg7sz1wWBVlhLtNJpCRln9NeHdFcZrkdLS64sBZFt5NdYQa6j4i5Dtv3qzIRSKY2h/e1mtVptvomG5TElZUBqtUYtdnAAB/Vc1W+3hwQpixvXvRHX2E0PRDc6GwDBU7WEWMfmbEDn0lWlJXBXYcjC7FNAIHmoJY/rRbnKMJ/dor9ysnvS88OOTRhfYtEqw1bH72DKd3VZaDT2cEOAEOWAIGZYVJ9dd1NsAsKDcUnCkBt8KB6nw7/Gplu+beGsagFCpwgvLcQQKHBO+J+wo5YZ/R9rPgjqL3hFxWkjd+K0UeHUIUnGiqdylJLV9vYatb1arRY7PDw4PKAWOQ1pi/JzE+Li+wMSP8YZE2fIejw+oGHQgy4GIiGQ8FRkq/mNxCg83n3V3FmewkVWHj6/0R5nLjKcMpiPaiQjI4dZ1PBGkMtDBAw7tAVHe4U7QOi0YQiKg0eOuWw2i/Mmm433hRjg6ekTeGXR0uI05FfxsVZQD+m3RscBBAcPhBm5zCBhD4YUXRvkosMNDur8PHZ5GUkYohvgaBclBNFxzs+htujiOjZHbYoWtlkss7n4HENoIBqiHLv5eoIl2CrI9NPZBcdhCGdZJgSE2R76ic5jVXRJY3n2bHFxWTmuyEHdic0lRMe5RLUFNZyXEESQOYZgIDjXFWS0uJr5E3MiLJmdxeJixyQLc0yS3U/Zl9hrQMhyuYyeUTj8Ia7AkQhLaXFxaQkDWlKQdlmU/yzNz1sQYyAo+qParl/ns15LEnIkgNiSLN5MkBqQfGDGCATIX0rt5rWJIIzjeP8LD9UcFjwoBuIsScEoJYKSrkpY8BDBYrRQK0EQg4jFg7VI0pCa0OBFhEgiXkrpxdYXUNRTIihWBD0IticpngxYafXg73lmZifT9fW72c2LB/eTZ9Y00uv3pOVkULJ+IbqoTBB0h4bEx+iG4LC0xLdo9LvwfUASCJCEgvBAeCRG8uIYPji0hKdh1lbKhriuovxHT1RzgHC9kDq95XI+Xhcn7Xl1rDQPOQ4mJAT9QyAAWbQhPBCuP+jV5WOfwWEIADpAcLmneG1hnvZM4rhBw0fER5vrBs3B8GQOAaLaRzFkgz4buG/JJD4zFhdXoxfqHgeI4zgb0dW6AMS3IGogPZY1/AbLC7XG4DAMhJEQxJWZSTDAzv1NiYQLhIIsLy8biMRciOrWMRS8/bDUk0kNwVzqq9FFCxJREEiCaByXX/VzGmDaRT8BBxB6840jDNGWBO0m35/jmoA8fcqU5euHkJTUg7rpdDrZXV8HQ9Wt02gc3NEucKnUb3YB+XITK8uGeJ8OH13r19kMOPgi2RmJ8BsbR7914IyJYAGwc00dIGgZHTISpBZauicp8eRksL4EB0oCEHw7tCH90zwOOxuCkUDCbzFDsNExaHBwMAFFHJudgIITYuzXEGRz0vvYwCptQYAgAYtDEtflnxcBMcvqK10df4pHgsVFEEUxAjv88aAmYDMxZKw5hgDpSEvtiFQYzoCkoAGEh4ZCM1EJHwPZmjIQYgDSO44tKv3MSFJbIwwZdH/FEGITSdg5ggwt2vseUmQ5QvVi6ORZAQc/sSlIQdw4VhZDgLBP32JYsWTvXoawJJTDCRujBbomS0Dpa0hJp6MgxjJAwYH4KUs05QBTJEQNBLHDQIIH27EFbUcskZ/ugODMePUIfbJA4GayHQ4cuhbNowVKX6PReMiYTCYjLUSp1Riiw1NGGQqKxZgi3DhfIXplhSV88pZDPoNEri1fILP4nT8GhskjBQUIx5CAUqN6GEizIOH0+uKBGAdLtMUMxDgA0ZHEjEQj/uYwBsdDY81WiwYiIVU5EUPZg2oBYw+plMS+VGKeQwtLrStdCGKmQBAj4cWFkUhImBCjPRbDfTj81THUQmUECEuqDUBUDEEDuA3gwBBsNbzWOxWeiPBpYYFhfRiGJsKFIZBgJAwJlkxMR4/sLIisvLAABo59hcJko0KWTJCEaAxiEKLXraF4ZmFhIiYtCCZiUcxTC0J53gEuFk69ZhzcQhkbQyYLhUKlUJksXNs8EaORDr3oAEEKkggc2ywIn38IYhw2RDGgMPUS1EvhUe0pF8stbIA8h4R7b00kDGGHNROsLJ8vEDOQEIQzp247JGRrHBA9iyTarAnpTFkaR7mFA0MqhLl+ypqInYFoCUOEH0mlDAMAHLBLB7IhKDQQXOwuIB4g7EjLzKkbRRgy0yxTC6jvEQy8usbf3iqd+teucWuZ2r6TSQ/fiL0hOvqR/fvdg/TfRrt3p1LYcUhxO1L8eDcCnKNvIweHhpKHapnM2tqM7FpPM/JoHsxs7kO5+LoNRLFcJMjkZKUyXqiMj49Xr46MVKsjOIw8G+GqFO47Dzr86tUznfvU8PDw0p322PsTo+duzN6avXXu3Ojsy+nb2ezFi/lcLpfP5bPZUik/lRt9dyWfn0LZ7NTFK1fy2XwuO1Uqlaayd+/mb09PT4++nD39uNn6sbKycmflTnvi0sTExKXh4UtvcDd/dmn+7dv5+aWl+ePU0vni69fFIt2wt9vnsbXxWhH9bOd8WtsE4zge9n8M9vpyUAyEaaUIYoVUc2k0UDMjPeWmQ7YQCDKigxEJbcGYQUqX0SRCc/CyQyHHHnLsYd+f7bbuthfgJ/r4+ODh+fj9PU+bSyqmemCqKtmYdXLRT2j2ut7Vu90uLtAAelyHRd0wkiRLxHEClWz+/sz1ZZj0/ComCgnMEfOzqrDYB9bMsgYWBqwZYc0GN/gMBrPLy8vZ7PLmy5f9/Zsj52jx4/zz3d3PPtECmjZiVxpcNG3FjtnRiGXDkcRAi5GUK4VRrggSmjPSfMkoyvHX40pbJUxT7ZqRrte7kWmak253MjELEZ20urYu1uuiHYqimIhiHIoZm7HzzzvBdbncdWXCDQ4FIgC8Cz3Zca57Ms8H/OLawQjv8i53yHMcJ3BcEHABH6ArbE5/nJ2d78EDYWSkkbHIhURwQyLjNRogAUqFUYYKJo/jmMGIxDC4qTSbzcKF5h+Z6EzUg8lENZERbHQdNkjEEBGDKIVxLIoZmixjpY9eLkOi5/sN0PMbPjhqVKu1WqdjdRBKFelYnRlVkoWCmgGKyyrooLaQF5LzP3x7t9vrw0JjJVTVqLViIdFi+z+p0rT1eqXBiw1DCTYIgGGgAIYkMwRSKkEEJk2VZNrtKa6EqUIiwrp5SCXB4jASMU5FwxDJJmazr7vNRhByN+eIPBfyPEcOnOz25JzLZZlDXILAFW/d89B6Hp7yTjHgBT2Me4iPRzQYyIXdz/4SlZVmcbZcZiMNAbGteQsS6+12u16vt0gnjNlQUpYMg2RSCU6wUshjOKzc3jabOEmHRKZt9KZRFNkRkojMboSVYwPRNow4hEcsGviMs53nCZjM6YYmdnq68QgB093QBBc8uL6+do7+4Di4p+XNLxb3ve8YxeDicPHt24c9LPf5HCt62WfmfVhpWCT9FhS07cV2DbBgVigyaRSmw6VCFQUjHEUklde3zfYtmbQJukzb0wh52Hqkk5Bet20Dh4jTMOxCJEniT7uN4BIyYujJso/lQF0fpSb3Gti6UG81VJ3v10AVJVVcsB90BtgcBsDaRx1CRpYD7uwjbVx3V9iHln2W7bf6I1rpq+36IrnA96VtwXoViyFEUpo+gzRgkqJJX1fewIF4MJnimKoT255OI1XFko+iSVSHSSFSCBk4EubzWfH6i+IJAlRRwMsIoUjCoZfvQIgHlIADu99y1R6M7vfj/aOG36DX4HKora9YEvOrK6WvLTWtNWITlo3j8fri4uSE/hfENYFPGIZsmoZSmkpDZSjBQQrDNH5aqbx5276vLSgAqKjTyXSiotuEhm0gHeQTUS4iDsQxHovzvfONh4p653mBj1cPGiCQ8dbxRwQBUFOTHd7pOQ3k0oBTr1HtUD5Eh1xqsGu4nHe4EbjN+d7d8TFEVqvxasVKIS3vGHvMyYFuYvM5OIFIfTyKwxQuaBHJEGlgjaSv31SIV0/+j6cADfHyOUEtcf+TYuj8wwsa/3v38PNieO6hixPPPKNHXoKndNLnMU9wPOLR+GNeVUpKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSv6bXy94APTQ+xVCAAAAAElFTkSuQmCC", + "description": "Displays historical visibility values as a simplified chart with background. Optionally may display the corresponding latest visibility value.", + "descriptor": { + "type": "timeseries", + "sizeX": 4.5, + "sizeY": 2, + "resources": [], + "templateHtml": "\n\n", + "templateCss": ".legend {\n font-size: 13px;\n line-height: 10px;\n}\n\n.legend table { \n border-spacing: 0px;\n border-collapse: separate;\n}\n\n.mouse-events .flot-overlay {\n cursor: crosshair; \n}\n\n", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueChartCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueChartCardWidget.onDataUpdated();\n};\n\nself.onLatestDataUpdated = function() {\n self.ctx.$scope.valueChartCardWidget.onLatestDataUpdated();\n}\n\nself.onEditModeChanged = function() {\n self.ctx.$scope.valueChartCardWidget.onEditModeChanged();\n}\n\nself.onDestroy = function() {\n self.ctx.$scope.valueChartCardWidget.onDestroy();\n}\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '300px',\n previewHeight: '150px',\n embedTitlePanel: true,\n hasAdditionalLatestDataKeys: true,\n defaultDataKeysFunction: function() {\n return [\n { name: 'visibility', label: 'Visibility', type: 'timeseries', color: 'rgba(0, 0, 0, 0.87)'}\n ];\n },\n defaultLatestDataKeysFunction: function(configComponent) {\n return [{ name: 'visibility', label: 'Latest', type: 'timeseries'}];\n }\n };\n}\n", + "settingsSchema": "{}", + "dataKeySettingsSchema": "{}", + "latestDataKeySettingsSchema": "{}", + "settingsDirective": "tb-value-chart-card-widget-settings", + "dataKeySettingsDirective": "", + "latestDataKeySettingsDirective": "", + "hasBasicMode": true, + "basicModeDirective": "tb-value-chart-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Visibility\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 10 - 5;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 20) {\\n\\tvalue = 20;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 10 - 5;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 20) {\\n\\tvalue = 20;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"layout\":\"left\",\"autoScale\":true,\"showValue\":true,\"valueFont\":{\"family\":\"Roboto\",\"size\":28,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\",\"lineHeight\":\"32px\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":0,\"to\":1,\"color\":\"#DE2343\"},{\"from\":1,\"to\":4,\"color\":\"#F89E0D\"},{\"from\":4,\"to\":null,\"color\":\"#7CC322\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"image\",\"imageBase64\":\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAQoAAACACAMAAADESdfxAAADAFBMVEXGz9TEzdPI0dbK09jBytDCy9HEzNLCzNK9xsq+x83Byc6/yM6yur66wsaksbmZp7CvtLfAyMzAx8q3wci3v8O5w8q4wcSotb29xci7xcyms7uvu8OcoZ+TmpW0vMChr7e6xMm1vsKqt7+ZnputsrWsucGyvsajqaigrbWVm5i1v8eOj4GbqbOdq7Snr7Geo6GytrmmrK+9wsafpaSaoJ22vcChpqWyuLulo6SXnpiRk4arsbSrsLGVnp+XpK2vsLKrq62OlYyPkoqvtrmXoKGyvcOzsbOmq6uRlYu1ubyprq+ztLeura+bpKhnZlO/xMi4uLuWnZuvuLyZoqSRmpmVmpGHgG2SmZBPUUBWWEWxrKySlo53cFmjq6yfp6mFgnJraFWopKRZWkmPl46NkYSPj32MjHq6vsG2tLSirLBdXU2ppqeWnZWWmZOOl5qPl5aFhXi7wMOPiXZNTju3ur6jn56SmJOxr6+ioaKMlJVwalWSm5yenZtTU0WrqaqlpqeDfGq5treVoaips7aRjYF2a1W1trmlsLWKgm9ma1auq6yChXW9urqHkIq6u76TnqNfZVmtqamspqWCi4idmpiCgm52dWenqaqttbh/iYWgqayloJ+fn5+ooqGVl4+UlYq2sbGdqrGEjYxiZ1tyblicp6yKj3+Ih3eBeGZTWEuSkYJ+dWVqbVhkYlHCv75iYE69t7V8emxycV5WXE6Qm599hoONi36NhnNYX1JeX1F3dF2SjHmMkYePjYaLjYOJi31pbWVUU0COlZGJhnGBfnCHj49scVxbYlZjZFVjaFKst72anJaUkIaqtLqGiXtHSTl0fnpoa153gX5tbF2EemZrZE9nYE56hIBkZ2GJkpO5s7JvZlFQVEeinJmCf2p+fGZfWkhbWESUj3t5e2dxcmZ9dV6HfWq+vb2KlIxxenZvd3Brcmt7cluwqaeKh3vAu7qLkpB+gnOAeGJjXEu1rq1wdWB1d2J7eGF7cWJ9gGt8fHGal5bFwsFcZlGblY+liVpejnXRAAA2o0lEQVR42oSZ227bMBBE5dSSYxtoUBRBkPahF6BBYDS/0Dd/aP+0Z4crjpdG3NGSdhI0lk5mh5Q6PTw8/A69/X57e3t9ff3W9BF9kZ6enn4+/Qz9kr42vXSdTp/RY+o5tN/vj6Htcbvd7ra73WZDNU3TpJeiu7vpLl+lO6r/4FIfqFR+HWr/kEKbKn3uxGCm/H1Oaoc4O85xZkwPSCikVyQSBUWSgEWDIRwmAQoEBaNAgsGHBAmj4FQ5qEsY4sAUM0oqcVQJA8Nq30EdxabDMH2D4DAL8RAGSa4Qi0RByRZCkSxQQREgEsWJ+hwwoPBZHB6DxDMg9vtmCmRLIGaz0Lsg0IkwNOsrM4jjWvp+qlvK1igkuoxiK1swJ4reIpCoKD6Kg1okZVe8DK5wdzQUIUigWVa8+MtQ10oP2Bh2CSBivCubJtlSdoUu2iisXdN21fQHEEYhEJ2FG4SjpMULNaAwiwSh/kDCr/OanBHdEjUvKF/UDUcYQ+8PjQtXMHYc0sJrlX7YNO/cIMFCclqkKxKF46Kp5iYobAtgOCwSheQOKRrjE3UohqELvsZQW2RgwcgLZrqWOLXYnO2KFURn4SVkRJESCWeFZBJ7jqNJgJ1PpVJLiwebuZIwg+mmJ0zEKjDEYv0r6MXKH8gSjNlZYVNcr6dPa26ahlxxbiiUmkbBkQ1yTBY7pcX6B7KEIOOTSiRG0N59EIybIAwjGDqYh4u+joqeFrMbBOXOAlUSVNqioPh16QoEicaiaW0PyvsKjnlelBkapUdqYljCcJNFQaEp1XAnCQbTreCkQQQiBYgQwVk3WUZRVlNHhXNTAoRjExLNFfNmnoPHMnlXcXcVG0axbhputkV10TSg8GZK8xgVTT022xLiHhGJRFFyk7rccSYIySwaCSlBODcjNMAhS6SJdeVXyVlt8X5fmIc1WXLfkq3ANCaoSVDhCuVm2XGOuUmNrvB6eonie915S4kCL9AehAZDp1h6ZOiUlcLtVVSc/gMjtNNQzYbh9qDcIG6RFcXr6grKvhAKKlG8GMXpqkWSgyQSyxziTUNRd1eDEoSmmxnBqPIWXq5YdMHuifJCOTXTFajYImPTHUKpQX55BZEnzCJz85lC6Ql3SEQEUlwsfa/VJje4fZEQGNakY9xW2B02RZLo0nKe0c1sNNcNInkJQUYRqgvIT6FwcBZTPHcUopEkBGEzb2dQLMuyWYotzMLqHTJqxJGZEZNko5ETayMsjDmzUyiyQiz11RXeW/gu5GoNKWGBgoOXEMH4rvYQichNo9iBYicIxmDdacrhlWS9fBtilJ0hjVBXFjHz+et60i3Rzq5mxTu5icrdKSookGNTKB7dH4lCoanTkCG8q7gt2eK/EgTBMA0vIGgJpQeoHMwOTbni2FB4Ob1ukEDRODDQeJ9+6iwem/r9mFikZoQt5sjPPLmoKU1CoQFQX0in95aQfB0XkFa541ySgrRb1bvDAsXaIV5BvMWq92QDi7LHOkGCUnB6Z0GfHLZJ5BBAKAkgVKciMlJFkWExlahAqx+YUn7uYzUWJT7LFiM6wzrWBhnvTce0qGEhDm4RWNRdljcXYEgJB9MiFqnm4+ybcRWZppWC52RUvOAbdUuIl8U7byQKaOvIhAN/MMVmuQ/xdrMH5xOHoyK03o+d6yM9xWZKJHIpORwPhy0VSlfEuFTawjtyCsW1axiD6QSrwqOSSEPsAno+mZC0uPcbMardLhUUcCgriGRHDKkpCOJwKo95KRsjcXyCBeKDxYLhLjELpmmZupyaxRTU+KBXCIZ9JmPhAIA2dnCgeC8UiLPoknXLYprdcb1+SCOJlFgYRqijYKDjgZIIDCQSbSq+0KkLxsZbC1+/IUz2RDFFUUaQ9vsaef20hKBwGskhUHCa04NT0zssSAwsxqyQzudyQ9Zx2BaODMFgEgqKo7KQnROHV1OnZMfB4SdYTcOexA+2+y435BVjpoojwrtyhe/IvK8QDLOo/weQJFDJipYWlBLjPkxxT923JkkUh4zObos5QxNDIy2AhYWvv2TG9b2HYehXaMkgKQRCn2cCqKJAY2yGrlrkiRKIGH6M1XQZm5R9sQ8ccLi/WEnkCiadVvfE1IOTWeUW0ZXnoDoV77XHrKTkLT1HTEd44TSCAoJmBsUKo96ZIu8rxrwQCSpJFFsw1B6yxr1gKC+ChNRQdBjUmBitWxwXU41MfW0/FBDSgghMPR2RtlToQHn1ZGRzKNYCBQ2SKP6+/X6VBMK2GB9vuj/OZ9+l+54sYQCiCRSfAgUVJyNrqEGMwEp31+QcZRIMG4LKvNGagRtMQlJiId6KQoLIBilryN/aIFLxxNghpxfBEAYqjjUxMEaiyMe+orE9JIm+hPTJMCQuM2HUtUJv80fuC0Y6IgYRkdoKfkIAQCpWDesZ1QbBF9pYAMIsSmyahWFI3RQMgaBBIEFJxx4Y2SPACGMsxrCpu89pqY86//+8Kv2g35cYkKZDSLaUF9DKQJM0ZX94s+nl1HdkQmEWXxuLc6I4n370DvFC8vn790d8YWfE53/65DWVMRcEVVpHpHSHpe/UlXOhkL1ACcGajL56BblCnWkVTT00yF81iFi8f0eWIM6gkHKTZRZNoOBIElpJyAtx8CZc5z9HKUEriukd+RYrOc6Xsg2Y0P4Qm10+XRDuiTDFuSjcBwQqTjRQmIVR+N4UDZusf3SazYrTUBiGZ6H4Mw2YGmNRKFUQxJUIZXbdlFkWIXfR25guupzt4M5F78CrKPSefN43X86XVHzOOamdnzbnmff7JpE5nyfdIhvnxEVVrYIwIW7VPuvhGty7Z8RurKOogbxZ1UrymQPh746Gk4Ts1xEJJKBCAxWrEVHNnHWqsIlpKvIqq9g4vy8uZuHiul+0fqwqKmUVPoqM7BbPTSjwolyYxQhH30coBFMcCpY1/JsKJsXXv488iJdmxQyqfnCaVQtv3zYNKkSosIuUIRc2oVW65/9yYRUlHW1bvavoFxUixskgFGbYrvD5u3eIsjkHgyMqCEhccLBwNDXwzKgiLME12N8Ty0JiB4U2aNpGfLp52PRMY3H1X71M41x8PqtffHQshlBEkTB55eJiVCQriXDrrGvLiGtu78pJsAk+XCiB8ddwBR2gIkoiq0Ey3SRKi8CDfFgFyz+NkYmwIOwBbjbhIlIBee0t0oZdXC4XiuQ9uRCzj/fFRuhoWoEJP8jGYpG/RnQzggru2Ye9ApvgNyvIhffHnlwwIBNMD7CFOJQKk9lngAUiwcQDAsD7D3oFrKY1IQENZqlUpAtFAxeyodYZLoyL5HJhXs6m+9JRIxkMJiLgW9sUFXrnH9W4edavMFHXt8+8iRdunNnuewV5BTYNiC15xnV04baHLNTujknRwGo1LYEpQoLGEhUPyGDq8sIiTPlDpFQB8sAiE7QLgnGWimydn+7veeHGb6UjI6tk8RK4oLEM14g27AJgS0lakQ+LubJROi62pAMnDoPx64tRn8RC1IRWOChxWJpQETUiEVrCJZIygsiFZRhioYaRIMM0ohUVyEZUiU+VVb/SFUZ/c8q+UWPqaymuFU2wnskXOQdQqxEN8FbGEtpKhARGaLCC8HA/W86YUpEuDP3CMgAX1nEUdnG4mHMQf6L2jwivBnQOECXCBFw4F06Gw87ubr1HhhNTi5DjwaPhsXBbz+f1PBUsFsxVIgXZIBmfRKmKAhoMKsyg4qRUmD0mzHGAVBwOh3AhHeqeswC3MozqQB0pbEDUiIMB9bwOVA7y8l/yc8lcA6xABoyiJxd+PzQwRP6WMOuRBB9MN+tGKoqNkY6vX/dffx+PIx246G1k/+y6mXDKgvTROBXSwXku1DHq+UtvhR2Bd6aZ5JN87kNKsAbmQiNg+6aNY2tGHpbrdZHAHNExu5vHhysZJwgZ+z1rEo0DE4qMp3CBjSBVcIA1Z6F8omLhApnbRAEzMP2BD9gW00vfikWPeabBRBTa6ZVTO00DNbFODWMPnP3d3febR7tIGafNychEr0MyWMfkAy6SsY3OLUhjhNPRqki8Abb1atib3QBHkwlg6jmfCAhUdoWxhkUV9PGzBStID2tY2sRsCgowIb5bRcrYbTa73WlgqBKDi7ChYDDNk1QQDeiCWSIlKUM14gqZR3VIBc9ZKcXoH8VRtgTlIEkDWQ+pQYO5pjWgIcOQDjS7ge32bosKkTrsgnBACce+cNxf6biYqQwnLikyVCTqnaUi2GAGvTzkR1mejCsqRBRsQNMOrACkYWJiLAFSAyIAFX8egxKN3U4qUsav37/2ybFwCC5kA3i1bnvmldNI2uCMGgVD+3LXFFHz4idjwBIYSQpwGH4UCZp2IBV55bQeiCbJsINw0RUP5y086fDmTaoYRDBwsYNi4y+jZazaNhSF4Y4dGgjFdCwEDN5U2cbWYIcWXDA2hAzp6q6iS0GgJXTIkKFjx5g8h1+mb9Pv/3V0b9Q2pd8990iuS6X76b9yHwEJiV6FhjhqJiw5hAxcLHiBnnmt8RsiIeyRATO0YCx/PlOdUQPeGI4SAeHBWQCu5h0xpNKsMFFtsKGbtIkjdUTF6XT6MxjICBc0y5CO7KP4XqDCDRkr+xgq0VUso/L1exsXo/6FIR2gaETgZ0Eslj80DsGQJv1QWoMUyHNIcAz+ooHVo0GprTYZazgCKpKLrOPm6uaKCh/PhqMA2VgV9wMfRwoiHFVHhKP1K+PMNrxTVC+dhNAw0zqbxvEXfvT5rUh50ppR0wcCkGALQxGVsQM9HEYvgEmBEjE+H49RkWXkaNzAVeI5GQUV3KMDHwxjGeGjqiiz23Fzi4smtgmxsAm45k0hEQ0FI5bpF2Hd0DWAll8KTB+8ISIN1mAqlR1EBDiGhGSiiwJ9fLwfr8ao+HrqyTI+IkI2rqiArfL5c8iQjwPDFJkVExn2QR25hK5GlZsSOh2v2sXojDfCa4ZkBC+v0YGHWHhdL+rFiKFfgboewaLmMwGo64u0/PxmBLUdFpRBVcmAcgMlA9zPFQgkaDgQYBVfT7IRyINt3IA3ylM+C6s4HOQi0DYpEutVwQB8jMf3Y12uPN+cl6bbKpZxfR2pyEiGNIxYZVomp3W7eELbfcPJq0X7tm3bVwGpY+4q0x/LHmyc44FJkwIjEVnFEy7t4fLHR3EjIhzZBhU2KHxMv0ynxR+sOsbogPPA6dBtto1U2MVABcxmzWKx27Uq1sZsu44BigZ8MrtMleC0pJ7A2geMNVRmJdYrVIjexEkiLkOFbPQ+BipwYeSCElP4q417CRFJyabkbt+Si2vIycgqzkYX7a4Lt3t6zNbiRdOGEkrNBMbxTkFaffaQHGiEiPXaKvIW+Xa67GGjWEYm2RCPmpENhyNkMBPrdbEGXShAS9h49cYqWD5DbwqbiFhctBVPkmIxlNgoUJ4ewSZ1LZ2/M1h33gK0IavMes+t7vd7qTChIuuQh9goiZwMsAtMiCml0bFPTvbrYG98yo1xz+2omSHDZA8w0w5pK918LOs5/NJjGv/nYKyT8YAcANoQ7sUPrJgiY/rhxW2vgvH1m7nsVdASEiEVNBxomn6jUGAhFHM/ZUDX9If+sN7bxbHizWkVQxszh6JZ7BChLPlXjjDF/mIE75lk7P9Zd50yhZMgBYkXt7eSYZKK06V02Idk/LjJ2bhKychYxeQwOQTb6WG73U63U9jCwU19v+XyWtmmrQlFluAOkQqpUJSY75nAeUTK/f36PV8MKQT9H0z73jnYMwuV7xMVuLgduLAODUE2LGKwTaiBkQkltoigad1MN5mYmC1MpQIX1aKemdChQ4hQKuq2HK8VogwWTWy3rqWvHDnhMPq0YObjkEIpzRxAKkzORbaRX6DCfeBjzggViFhOerbucsJZYhk2nIvzql3UTTOjeiwEQkWFCqWo44E5YRC1PUhS+uphcsdX1MEXACvRUplDDtEPQDOPhqf54ufPHAvz6dOnUJFfG5q0335f54nl5PPSRjI6XwZzd9+oXazKqq21QyhLyOlo/K5gh5SrPXmCpNI2tz2Th4e7u+Vv6E5kRfLogRfOQTzG8inwQb+GNKmwC6ANZISQhKMxsDGfv5s/AR3LCUumT0LBnDL60IXlQCjKnVPRMFMqKKZoulhw9xGxsCl0rn/o7o6zuXhHCd+LDnz/LAdl52HyyOnjI4/LHjqWv9gwexUnojAM7w0IuYBMNQvLVImY7BKNZCeC+xOLBA1TTBnBZsZtZFgxsF0qN43CIiwRvAe71WLAKp2NeAWm3CsQn/ecLxMjvvOdv4l7fp55zxkTUAiGqYLxhmsLBnnFw9Oo1582uKQKBiy0aCUym5wTTUmP9u5urXkgFu023y5YuSQUJJXSi3azu3aElm/L9r0b26rzer2hi9iMJWGaDUMPSPtpj/AOZleY1J1QbNM429CoYPzjDsJODrI6LBj+byL2kMiZInLT5QaBNzBF8+RErtAmQZU5hEWZUGiDwMD2gPp0gXyHRsHUapGZhObeGtS+H9XkwJBZSRsKBvp859u3b//CeHl29gwWXgBRiMXoLxymOpeKBplmwIVs/dUkqVH6x7a3d/pALDgskDFg9YSyO3Zunhxgiz3P4LxaN8lLK7+eWpUhwrBl0o1/uCByc4wVPqTG+fm988b1+fnOJ1gAYwvHmRdEKkUYYyQJCFiqvdKiYGiPRS6QDELoZjgiU0VMeFxH3V1ni1eSHRkvrOBraVty/9vs3t3bdx1eX9enrTUBt1ylKQorBCHRCZFq2/qPb9CaEgnYxPXOJ2QwjMUah7YK+QbHmxEXKMhM8kmLQKCQNCnJcYhGoygkOiDUpDULTCEUjoSzBVEZhKpvwqJZ6x7dq9MNMUWtcFqt191Zdjqhuu84aQQN849ayjzB+pauzU8O47W08w4SBNqQ+L8z3rhMvpBCy5S3BMOe2EO36BAIUSeKooCkymjpn+D+FfuDb5VsEJbMIWkvUWnzAvGv093TRos/XbL6pdd0CoqOYskVOQXPGEQadTqRwv0TEVMyFC1jsc3D7qPwOgyFQjC+eRi3t7eeRHlW6W9n2JtlZIoMhS4/qH3AzLIoWCvKaeuJ1Rt3T3u1JqYYyhXzyhTttt4iFKq4gsPiwd17of/zbBllLN4pi7KsA58sqNeDgEGKwg9COIcIUQiRSrZtDIsXDcKawrZ8v/PunWA4Hk4GA5kprEAVjmj0RhBMoaxZyT+pYjJJkrJglkVe5BLWYMSjU30Z46QYzvnlYf7Cq22bhfSqLTTzF/OT2e7pVWPEQrVUOljmDoRqWZYt85zMky7cOIJR0agUkjJziGQ8/rozUozoeucDLIDheDgUP29/Eq9/wsK0zQJtecLqMPCVjAmVq8vL1WpVlkW6yBd5XowdjBam6HJqDmSLYXM293I/SlGQqAGCynzWO7xojCJWmSslRU4fkoosyApIZNS5AQwuM0eWRQ4HyUjAgoT88q1uYYqW79/vfP7wARqEOUO+EA6Zw1TBIJSiSN6I3rjFk0UbBRGTLycrUCji32maLpJksRhrpq29o8PD7oPeQL/HkGYgcTo4EQ1XO3gFCuq17uFFHXsheKaLiaAS40WCJowxScbjJTBExkRF40TsIG0j3AOHyFBUDIxTqJwF0OJAWoLiMzDMGiQkGARA/DG6MUYQEKBYE4HJiKKSHg8ggHBJf6CYxGm8SCcpYopRY++KbyC9XSAMWTYm8FsEJ7RJiFK2mJ+cNAe9o/0QR7BwoUC/08WYAhCTSRyvVjEw0AJjYI0cMbyHkYHCS55Q2lJkqipLueLHjx/QqHBIl1hD6ScBDcMRmDPIwBFECDAbDKgoi7IsRYJExmzjcpLGcZoIRXhxdXgIClgMBvhiOLT9QdYWFR2h7BCaQzR4/OTeNC9YOHIs0pT4CNf4OJ6s4stVCqcxPEyZ7GE0iixQUzB8kLy8jQNDwYamoSNo57uxAAaxxsFCvnnhDaI0YwRIIHxJ0yBodDDEcdyHgnGwoh/Hx2maBMG9K8+hVpvNDnRczH/pYNBRIYNAgqutxvDgEbuntnvUCMZJigdgIRofPx73j4/7pJgcFLCQcMsaxnjM+seBv18kNCTjECDLSVJk8ByK7xsYXtCAhXYKhX/J3pYlUZYOgMt84U4rpTORiPtORuLyhuKmf3Nzwz2eZxE0cMUTZwmWCQ/niiHHBMHLdfhqOHx1wl0+RYNar7sflIkoxOwxiMCB6N/vm1Z9MaZv7RqyjT9yeaUokyRIgnFGEwJLLifHQUdMTkElKGh4FIJhOJwzBMPsYf64lUokd5RAVA0Qa5Woj1i21s4xAYWby6+++UUsFvl0/+LqtNsbODUHs7eAYDNAYtaEhqsdcIpQE6JZrde7aGXjElOwxaARp8eof3MMC4IqdjuOMd3k40K2wAcqSLlKOJA5MtyDhSlDyxzvCMk2CuRQCIb5YgNDNJBoOCKCUBgUygL0FM4RX25I5F+ld1+p3hcISKA0P7+QK570TLsDqUbsYoHZEDfMmgdDbKH3R63JR70ne40OCNR5PNGiheLj/ef36Vgo/I0+SITDgUjYUcJAkNhflW0EJSOJCSiWWUAjKJKxSPBu+sOV2bQ2EUVhuD/BH+BON5KFgiAxCkm7GKPJoi5EsIsgzgyBGgiCpgtJLAxdJCoWP4IojSAkMAuxm3GRZEbUXUPwY+NKoQp+QaDgRt34vHfGRH1z77l3Jtb2PnnPOaOde4lmNKQEh0kURECqpDEKhjiIRuXSuWeYkM9MIBhDxjBkotEokxmFtp0BEKrcb7ePxSQgYFkW3RQAnH/N5Ao5YqTWsohPDhQKoMgd3Do3P5gnz+bzmIGZ6WTQwB4MMvZAqcLF58683KHiCgB0LokKaJ70ouSIhiiJRuU8G1oOoqSoJIMi0b80hEOa1VFgIFhIdApEpL/znRYQFDQSFCMjLxWGdmZBGVJJN4QCEEqRvbusxBI4ARQwQUoN2BxfXOMaRFYx195/af7zoGPjrpFNBITP3s6YF5zRQl7mIEg0Xnxw7m99Zi4xhUUchEJMtmDABffVk0Dx5cuXl19iFlMcypVEiT/iNCFgDhJlVjvO0d8NCUkYRkPPUPBGvIa27fOp4eY9DaVHrpg7kcMYZQsIDI5PTTiShUUhvsNUXF0rl8vF9sH9e84tXNMnb+vsGGFkQ4QpEL6v1XgF5RMceQ6m8gIC/Gp2vPKCIhyJNZK4sYRZNkCVX+qAQjBizXJlhgISSbJcu3kNHnF7YBjNf8YSA1wQc5CAIMXRtlOhPs38nv0raZUKMsSCg9JEDUTl0YiLWMcXE0KFcq3Is/flCiflr0llMilbRJCNWHw/xW0QgUJSGc0zOiD5PM+kvmg5J7cARavAyAcQIWVOgYKsih/h5r4aFrE3Xk9ZJJo1WAZ9QZMx4zH4zCeeYBAFHzsgbZDPCUJEJ9nifwgOGWdI7UPCcuKotVbYS54c1e+6MIMYqIruPVDYmy0WT5xotw/t2Via19m7PgFxfJ/T+zbLyIeG75viocBjRyxhIIBCLSaut4bOgmEhLLppevSGZr7T6cx9lWIe/1kDILExZmXUBIDE9givhXY4DNHQC5h/iZ/X830v5XlBwEe3kK+c3I0toFBEOZCgYzx6nihm+cWXKojEPv59T9bKZov86cahw0sLA0whQYCdzt61u1o9Db2BYhSjTp5MocDq0DyCwAE8NGHOqpazJKuQQ1T6PBDyp4k8uUmZua/fDIqvUxaKsw6L/sbBQIZHGEZhMAmjiE0QBGHgzaQf0PMVwygVpjKVW/wv0Up6uV7M1izEObOkySKiOmT3YoUju9aQLvV0VZAsaLT3zVMlIYANulp4MbpdCIz0LbY9GcMfZaY8NGJ7dNRmeUrfSC4Ri3bqr0tcnZMvwMAYzX2TAMFINDXGv1WUcDeGMr57N7pbjaqTyaQ6IUaTSTDxkA7uyxIpBxQOP7Bthxl7+AsMcoTOX4aDKuN1ic5Z0COESgVDWtSzqDLFkCi22+nLW3kbDrFSyHcUtHMcL/AcJ86SUcbWaqTTSXkDRTvZgiFxY0NAlC1KmwXBzgznnr59+vSpwSF9YUhx3SAka8LktaCMd6rVnVarWhII1JsYkQpRRDb4QdTFK92om+qm7JDX8HIaQ9RBgSyjLAT4/K0CRYKsyFI2LGMSPHK0aBGtXWX6SCHXMCi6UxImMxyp23WcbcdNBZjS8UzZ4BsS0RQHa16bRCNuJ0+qAxBQ6hAZblPT5t5KCQ4DRDMBYqK5SHC83In18+fOz9LPF6VqqVTtAaMHFXfS6/Ui4YjGkjKnCxSK5lLl/sqhFUplO9fO1Wo1kx9Za3GxrKdOTHL90afVVewgbxRwDXHt0yehKfNwka5kKJvCQTC54bhOyhGJvusGbhS42IPhpxL5UkZAVF4UpZE0tIcqsoIiDAsCwVeQ4EIxpRHzSJDM9PPrF8bLlyCYCg4vXpRKL6q9VqlVBclOtQQKmGCVcZU4joQjGkfhr8sX02fP0j7q9fp6s0nRpGI2i7k6JmnWCOSNZZXxANWiYIkOONYKq4urZatWbJ69tzUIRSIChRYsETiuy+LqRZZw0RUIOQNWbG01GqMwBUC9yXuZFOmrW6NRmKGKYVph8MJxAIoZCOONPzRwhwSIO4bH5k9tEw6bm3AAhFTaae20zOZ2qdSaYBJIQAfBAnsMbq1QKpYB0W60lSfH2pKpHbGO8M9VcNBWmXuRpY5CiVXfbTRWLm5t/FUtug7FIskQOPQd54LrQoQ3KCJKIY+tyaVYdowioK4QuKG2FqSigPPPNJl7+PbtQ2aC4xUTgeRvh3xkfPz69Y60eefn5gtQAOPKJmLFIi+gU4JKFWOQMkG11YthVMfhs8v3V+6nG1K6UV9upFfSkBCTREXS5oTWInBMiFUDWoM/fnlraWB3HSzmOrAYux4EGAQVCxT0tWdyg/ShjjqRAxJv24+JeAwUEB03kJTGVHtltBeo7gdzNwDxj/7A+PgxdsjHjx/vMImMO5ydOdUHXoAxdG6TM1ilh1xV1J5B0dnaQ/9Ay8v19XrzzJkc7qjDgpMnHQU/lNfKdI2rn9Cinr2vPvqkB9HV1VWrWT97v7Ige0Vu1O0Cw5WEwt3e3nb621xd6LNz+30zHfZ62/cc3wucKODwXEupyHOCCKnCBOMJaTwRlgk0QCEJBxO9emsSZQrkKRDAIRJ3JFDcgcYHMHDFhl2sndKT1u3nvWqphTPAwRyPU78uXrx3Mb3cXG+CYXn9zJkz9fXlxvr6+vfHj8vF2oMHD2q1cvlBeRWVEWRqvMxV1tKNWj29EQqFy18q9V2dXmGbXtLvM7b7Ty6g/oUn7oR0QYo6P1YyX8eCYKCO44Cxq1oWazzpTXqgMAKDEuXVq7evEDQIIvIGGCwxC2DEAgJBUfsf795vbl7ZxBHoOfVip4cbWuPWmG893KjcukWGUDdxBkVj5f79s2eXl0mVetNUUdZms/bAKlvlx6sPaBhNimnuGJ3mQa14pllv0E5/LYXjcc8Fhtu7wIfO8ZUYqhqOQOCFPjch0X/eu7DtGiYXgjGnNAhbfC0WjfjBEFYAjHa9yVglvqfZ+02l2bw2UsZxvP+Nhz2IKBK8bNmDgoawFweJC0kWlZIglIWQUmo7hUWStMgmZLqHNLVgsalJ2m0KtonsKiSkI5VCyWwPxc4c0p0edDdsNElnq9XP79mo+O28PDNp3T6f+f5enqlj+0riDXYlYcGOxBUKxj/hUV0anUGwPQLS0Rq24dl6M5RMhgyhsbCAKxYW5HRt5cNcPl8gV/giMYERERyISw5yluEcimVmYyI+h5QIbvLN8Rn69i8/OpRf9846jx4RDyMebJRUQHBLrLH7EgMiUFWlpwWS3+VwQfT8UIaT6hYfjLRAHQyN7e3t1fb3zX1ljhGPEYp2++joDB4iLtpV2autX5bO+mdLL7z+0pIHCW/gdQzPse2QFjK8kGKhSPDvffLTFZ6YiU8B4w1JGWrjEMtkJXUwGJfWS4mUmSBpvkIaEaXHsYbS3Oss1g9uHE6uf3dnndkqEEoyorlg9iDggs8wBtdcrjcEBgEzSYUjn9MOEbnq9xJxKXoJBDODolar7e2JL4DBLiwUDfli+1eKBIe+3Oy3jvr91lln0Ol3nMEAILZneHrSMIxkaDcEeEXi8Mur3OXlZS7HAkTkU74QB8QyaTyAIliCTpTCct83m/YnWKKkpQGZm00QG6BKJ2anltHByo1JMsBuowEMhUGBQBCAhhDiqKTQ7MoGDnKH/C531kMILYS2aRChgIznMKExwhPiCkgIihGMkTU4KJE/lECBlCla9746ah0dtTBFZwCQfqvV7w+cjtfZ1hqGFkJGKGlIZb12deMyd0mqyGezsUJ+KpLNEiDxQiQ/FQsGMwDJZlSAZCMgyWTmSKcqjLKZ2QzDLEPiampmOR6PHxzcxRMNo9FgrioxkDWQjJQN1NyTu0kVJeoKh+ALvh+ASDqhkZ43n4PDMzgIEEO6IgKkVtuHxgiGMoYcOSkgHDmpaGkfnfX+qqZS3EilUoM+IFIthNrVQWfgYYpQQwvpWrMpSWPy4Q0JkPzUDMqr6pHOMHcpq8HfM2qeGUTHmaCU8ClVJj33Jq5IjzPOzMWk/cAyvkI2f3r6/mGjwT/RYGLfUUXuqHiAQ2NXKSlfjaSWZNgQDCBLrvPBdxr2aHCPHyQUKPlak+ML3LHd9JovaASgo4/tbOzs7LEJDIUDCYt9lTcUFMWifCReKD9ZK6cULJMQKbePzHKrT7iIM4aDgeN5nm3otrGNMyafPXz2CBRwwBcRooFqAYYEb6dYlVEy3pbhdYJiguK5SPnkMPEefzaaX1ycP19cXHygCmwiPXcaL3x6evX1uoKdVEFCdHBE8si1ZDKpIUDodiMp04aIOEQZBe2yrStn8N+AhS4OMdSVput6U2uObSjBQmCA4z+JMUQKRao8HS4flVN/1swdvrFm7pupVLlcLafKnWoVFAPH7XR0sqfd1A0qipZ8xuLny6vTeD7io4s4eVtEA0EH8fn8TXS+uXm+eHMeCizPz883WX7RYX3B+ObmH6LFm+ef04L7/fffiR2cHrC8JNkR18mGkWzge2YsHJIKxUsKmq7prqu5mi1sIAEATY66JpuGeEiGrYWamsGAyOD3bepsL8Z+HrFAeyIVLIoJCDgg8949AmKamZumubdDdvlhr2V+VW6JqoOB7NWlvqRPW/e2t6Eh6RMUvODMncapGrPB4Cp9Aj6goZp/73OeOE/+Ji9zqRsTrLqY8mvjCRyCT+i2KSAJ7iZYhfApbzl9uS+vfXIICDJyY72BxAKhXU5Qd7UkAoKruzxit9hxbA0swsMVR2jsIWEGDcM2+KldBkQGHjawiMZw7Gf0fxiggAcczHumiTNMVK4eBVI/mmbFrOxs1Gops9Upt/vVar3eGcKiX69W+4NhqePQfNJreKSNuw8frVx9ekXSJD7IjDFSZGRKRDnxIY6UDwaRzGxEqggr1rT/7cQ4R8qHPwGfBE05LPzj8curu99TBpFhLDR4nuIEQ3dlcjhB48u1Xd1xiza749g6gOAAHjmNxE/puq0jV+PcpAXQdUaaqxdfomBDwmKDpz7KoWbNNAOm+VXbDNwzOQTkhlmLbuybZuqrVivVMgPhW2v1evVWq9runyFpyxHPxGtOPvppZSY+E8/nI3lai0IkQw9FmaSZlpQwL+vxt/33feN02vM3SQmL89dlaYJrcAyWwTjcxUjUGl88n8utPPp6HRJQMEga+AIlvyMhuKVS0Sq6luW6llu0bEsvYQ7FwBVSSTZE8uBCABZ1iJR0IllRxFm2boECCQollUSRwDBrlVqN6QcqFYZQ4IoRR/FLOBAIRGuBcHhtOry2RragxqjuXFYnjrP97O5PVwcz8XhumcOy2qaoihRUWvA5Hw2mtFtxeefJIo3SQUaN4BNVXoIJ1izUFt+bMWpMMB2L5OO5y5Ubj76nDzA8A2leyLOJgobmaNZF0XJLrlt03ZJeLJYsq8g8NT4Fj8XzJ24UD76dBsh2iqVS6aJkFyWwdL2InJKuUIwwyEY1kfaTxDgSxqhUYIJD5DLK1m4HTCBUopWKoGC7dat8VD1rt6QxV6tX7+5pIZ6byRfycUTrXcjnl5cLhUK8kM0En2ayPtrr7FOw0HI8fRr8nSfP5IMZRmrlRm45WT05eYBOWLJxO/i0cHr18ULD8JiMju8ajm05juEws6JbLPFVLF6g4oWrl0rctogcuLiWZmk6aCyQ7BIfdsnRnQtwAAExQEVQCIjRDglliprsaKu2Fd2qBAI1YITDFSzCKDC9Fg6Ea/uB6EbUNIHxeHp6bU3ajqpCgVi4P3uYy2cLwd9XT5hP90G3u+oLdrsniw8Y/rG5Ojc+wYArVUHPqR+L1BNW6ZuciI6uGnW7m1250V2cfzAxEcwUTr9Z8NAdLUSl4hlbHVA4IGG+GIAZWYTKhVXSLxxnOPQkZ8jHRT7TtF5RB4bGLQEHNHbZuJDT2Gef/fyPxBmiqPCoRUW//VYJMPvjra3pylYFmZXpcJu0Ea1FyZ+g2QqHw9PT4SrdmFqmwIIVWzP07eThh5f0FK8uq75CidPUm2/6SI+zsXGap9h9mg3CY5wWKy1vL0gNfuk3+AuaWqavkixOut3ug0QaJWBxzQCFcSfpSHcABc3pDAY2GIYyX+uCr57luBYGGTqd+nDYcwaOTiLRHaeHN1CpSJLsgU04cEAcBAUa4VDmuH17R5DUdgCxtQWDwOPAcfi4Eg4cP54OkyHYiZWNnejtHYLluFJ5HIBGmaiBxFkVFIPmt1eX+QIdRZzKwFQTqxPSVlEZ5f9A8r/mp8GQCsrE/RQKpk6ZmH/vOhO/rgSWBG813x2/7n83ARoWJhmqcSZ/dW3Bo8UnSmzPGQ7qA3s4rA+GvZ5l9YZur/ekd6t3YTmWhSk69eqwXh8+GQ4diR3dGToEg24z1AQbXlAUVHQIig8++5+it29TT2ChUESPj48fHx9XHleOMUUAHhwIGEJlZw9bRCV+JEgQbmGJUl0aLNl3yQ3ZLFlRvb+KkRTJBKSCWQ7+YIKXEPfxAWch4QcMfsADkhToL8bn7nObdxVB6UN51yt/WOY7eJ81tfKWodkdJtWxe4NqfdB36pT04fACGvUeRH79ddh7YjHowWiInjwZ3qoOe2QQqTIiiijgQNFTYWJRTyxJMn83bTavjZRxHO//4tGTINKb4mFVLMGTNHHAyXgpKUKxxJYhiRaMmJqDDVEP6WAOA1Y23cmmIG3Al/EQHAwuss4cMh2dsIZeEqudtF2pCX5+T4P67WReu7t9Pv3+Xp4n2aXVf1msGuIOwzDYfXFkMMw4cYIACArHCckzJdFiv6XnAIVxBBe1heqCWR6KfvqWdPH5TSSqY4sGJaTOgfS5LweqB/PMZZlcyNR8t0Qx2V7H+ziG2br0E+svLCOSqExZ0Iocsln+dDT/+ncmEI8eERM4/4pZYE/U6vHLxwDd0Xg0Ho9G9rg7urj4dXRxPRp3ua/p19fa3ccXoxGwDn6+++vdC2AIjgNYkDcQh1sU6eIpr7ScGbGBM9gHTi4hRJRyRMohB9lOvtdPQAEqJTKIWAJjLKaud+/3o0aj/uZNParnqRw0FZHFkXIInidu6o1sdpKZ4IDpdLKczxeWmY+qCiFFA5Fnd5rV853m+b2/752RN6vn7eY0m5/3WY3d+POvX/+6urrqXlxfqglhq9ei/7e7nd7DbnesKQmVETuk0fyNtE53rEDA6voAOHgI43ADGMJDJc8lt7hQmi1toKJhnOTiODZQzGANtSFy5fERFBzdyB0qDInjkDgJHNoMgNgdUHyyETEZl0l3U1bkCI0p2Y8AaMsgq22qAqqen1WlOJxV71AwKBdKf6N7crHDDEVdVPmOnZdXMo03P/vqm/6GdBW4QlhcyuoAHJgTAEOvdHo2MjVcYXc1ZAOCMt/pAKY7FhCQ0EYXHU0b4xsRXjqQ+6ODxyNQLDiIIKFgMErZc0FuNByVNYwvYqkv6mGgbgAqUbZAKkYqsrpz9frcysrSrnQUEiaUkfpypj3IZGtMzz/d3Vqrtpu01ytrVUoDyZBiQeVAEh8ECJNzVj7JIC9XwXa2c6dE51Vbl1DDGB88+u0KFD1SROuyIyA8WFR0jzOba7tsm2bXVlvHLpdNZZNrMFzAgy+tMxppSvYYz2hA4tnj0WjJdYurKkhcTMH2BcNfEEEwidOy8UBt6kkIIIQSxyB+JKWmqCsSIO/Ooyw/+YT1mYa0T7X89nJprzmARSZzh7w4aO5gD8zRvlNtkjuYjbXP1Rds1lZKJRbApdkgMiBRpeuoMk0nm5T4a61Cf+P+I4mMDo7o2ZhC2YJ/veJ5XHkmEouGqvmDBU6h78EJEIAEhmAHBCwEI/HPaPyYWxoVZFUpXRQeJMy0kiE6YuTQOT2V2KGspIfchIpvGMOcfE8SO7lDPZccggNbECF3+zf5ZbKkxe8xM2jL0j7jyOycy4SCF3PP5opIliTEHvjhFRn232zEi4oZ3jolaHgv+ZUql2d8kJNPaL3ENPb9Z7df+/rrPyEBCL6EBAKGmfK8SgocuITkTuOnozAEgw6bsmlrF2PNBgajJ6mM2Wy7DA1sIxFzUV7aXN0EhNpB5XToGox/NS0AZCtyj5egUJ44TRvDdGDkhn4S5xJB4SSUXOdE/nlQvDWvTQfNWmY6beKEhQaD6WSaGQzOOUPch9EaLMQfzZLUTBqqgeqw91jufqa0V8uoBMot2gkJm731RqF+88Nn/f6XH3YvVZaAg95CAPBMiROdEy5SSOfl0RLJFAkc5sIZZYICEhDRQKFxly9BwWtpEwmJhdy0yE2rc/bEjwDhXnEokCSpppOcAQZKrJ8ElNskCf3ATCH99a8+o3JEapkbITIFS728UEH1m8tWFm2r5UzSq6xe7m+/k81GFvN1Lmo8svJc5PfpT5iy0ZxYvAqi155/7atvPr5stR6qDKG3Kin22EFMIc7oESzS++jezPFSng4TMzTLQkOh0Ni6UIHJuGuaZb7Csg2L8tKDzc0HOONfFgoC2ky7rivXBNDpalEQ4ZrhkNiIYz/2nCTQfN8HhBYEehLoRKj5eB5Zk2y2tjeZiC9wRpMucZqhVsrqJTOOKaFCOEi4ECLEyL2qhIYqFlU5LOoGD1QpYY9kxUuVkjvrbzy9/+Z793sP9Qr6npEKCuxAsgCOXrm8fAgPYmbmLaIlxY9p+qEOC0KkzB4UIMAXmiBAGrTMpQciUCzCZHEAgru56TJ4TkGijAKNeOjEgoIDXigHgRx8TOFIMe3+Po8ilSwnE+ppTcmy1PV0WqvRO0wn9BjEz2QvI99iZSWzWlkrqlmcTKxCg8tG4Ym8mtTy7dtWLc80Jiv24PsKBZwSfUZ86ASHbvoSmGYrVQkrkjdSrV6nIlEyE3nwYA+Nsu+nQsyh6otGYIR4AQoLFPKoDIpNjMEeqZ2YgYPwcVHsuuniCd6AhwABRDwM4mEuiP0wSOIkTBJCRE3YX+/353Oig3hQzWaEOJWT2/Jal9m6BR51yMoxT4AQKzy1WN9C+W1KT+GmUCDI5O0TFU4QY/2GK2IsT5jcv5K3IXB9OSQ/khNtE1NcwgAYPQ8Cldksl1NAcMyhz4/nhypvEBGXkNDKbIKGPVIo0ObtTqyxeCk47tBNu8NhOs3muhw4N4aiJBAiBAco/ET2sePohIc02YyYVpM2Mqp/98ebCgySoan3h2R82XW1nidzVPVZPdpwpdKnLOlw57ld3lAV8egp7ssHX+Xjeu8Ai+2Jt3+86nYuO4Q8ScDutWyqqt3Re5UK6YJcOpsde96MCfYMKDki5cST/BGWw8APy2r4UBCQyiD4g0egAMECxUKcI6IEYQOAIEHBxiWKsYV4AyCOCQiqSOKYG/15RHQgAkIaaXlNZaGG0+mUlMGeGGm2/9XaYI1CQU9RrdKBosEOHQXnrGacqcWKKvWUveo6X+FjOFuD3bxVf/K607nq9GTmQRJs2aSMFkrNUh6/fwAcHx0aRyLv+Hh2Mjv+yPN8xwlD3w/DEAZjgsMGCMaS4GDn/4cCqfMFE8kR2GLInkwqUSJcyJu5WAgkoEiER5wEXIHEP3ivX59HNyokmHfklaJFbDT26/vLFpYhMljaWwcPZ/t5C/Gb5lokwMiye1nFEGqq9A4ox/JgMOX5ZGLlG1H/A9ZTe7rdBQUp0qSW9nAECVwmj87MMdDpYi3KMNgde5Lj6TfAUVZaZAn84Asi/38BwiYgJF0qFhyHUkRA8IB6soohKChpAOUIEUUh4RULilTOMTugYNgUTymktVoDc4g48D6hRPsu03P6bLT7XCmzu5Vh4RcILGpmZKxbpRKElHBPs33bovIuIkWWjNkgscCZKIui+Xsd5mCdMR21ZnoVXZIE43E8jwTGIXck02zVRstC5SHLLyBCt75gUyjEHGIJoRQs/WcKMCgxdOGgqglUsAdPwJJ2E2IFJG6RDEKqIEJgkmC8gEj8ZINFPMmZZDzUyEwXS5MsTjIia6Iu6DB3pLdiVY9p2XQvs/xpZotpOAV4SnpYoREjLAgZFUXNNeosutemFrcHW3tZ8qr8J+T5ixuv/sI6jUyw9ArTQs/RiXoyBaOi9Y2/KCLaALpD5gu5Y6ZSPAEBvFJBAAoRjjA15Q2e/QNNIK2tH5DYwAAAAABJRU5ErkJggg==\",\"imageUrl\":null,\"color\":\"#fff\",\"overlay\":{\"enabled\":true,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}}},\"title\":\"Visibility\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":null,\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"visibility\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"18px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":true,\"decimals\":0,\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null,\"units\":\"km\",\"displayTimewindow\":true,\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1697382151041,\"endTimeMs\":1697468551041},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"timewindowStyle\":{\"showIcon\":false,\"iconSize\":\"24px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":true}}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "visibility" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/visibility_card.json b/application/src/main/data/json/system/widget_types/visibility_card.json new file mode 100644 index 0000000000..e71ff3ab3e --- /dev/null +++ b/application/src/main/data/json/system/widget_types/visibility_card.json @@ -0,0 +1,28 @@ +{ + "fqn": "visibility_card", + "name": "Visibility card", + "deprecated": false, + "image": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAMgAAACgCAMAAAB+IdObAAAAolBMVEXg4ODf39/g4OAAAADg4ODf39////+Awyzh4eHv9+WQy0bP6a+rq6vv7+8hISG/4ZXIyMiIxznf8Mqv2Xvz8/PCwsKenp7n5+f3+/Kg0mGQykb5+fnOzs5YWFi7u7u2trY8PDywsLC43YiYzlPY7L10dHSo1m7V1dXH5aOg0mDn9NiQkJDa2tqkpKSw2XvU1NSCgoJKSkpmZmYvLy/H5aLb29teurMWAAAABnRSTlPvIL8Ar7DvmsykAAAGW0lEQVR42uzPyQ0AMAgDsHAI8WH/ddsxAoo3MMIcvV1awDC13sCQBx5/4ug6AVcirQgZRdgowkYRNoqwUYSNImwUeezVzW6jMBSG4d1nO+ATk4w8zcKRlUKcDlLEz/3f25QDJEwtFqk0Fos+Czhk9yrHsDU/IVvz/RAtx6vWZ0yGqRqfgkSoJIzEqq2EGLIAcjKWAkY5BVDNY9fCkEHfQeYaKxKGqNt1V4ji/XpT+Mo7AM4DAbOAOURqDpluK5KFHE7i6ZThXzVpSKpgnMTZeSd5oq71DWAbLqjq0FKb1xVQd4ikCVGcsXBVWJJkeZlykpqa4PphAvmzpRyV4xBfaUtWWtKfIyJJQspCDIpLdiiPu3EuseQcOo8pRGo5htRA2z1D+KbJhmjDEoVkgt3fMFBHwW5YsCTJcgjylvz5EeLclxA4V3tEUoSUgl24Ap8ugpV40uRIcog2kE2v10MsRZuVJkSNu7QDsC9EMfRM26Xw5MiBQwxZWfnpjJh6eUYQqJHQfbRZaULugmXzP3EHboKd8HT2OV+H1eqd4cnXbV8DTYfgDVwDNL0FOo9IgpCDGCmoaTrg7TF9R7RZaUI+xIjPPMuAaTrhdabtJSIJQi5RSPkIOeJ1sg6IpAhRxWOhpknhj5inTeKQ2F6wPZDNm3Wff9qmlRC8P1626vhxPABKsB02agxZ/5Co6PkVvzRW/f6vIXHJX3bsoLWNGAjD8O2rg2fIGo9WDbNoEC12AxJ7qf//X6skO6mJc/HBiQ56WYRYrRYedNMWte3u1mGM6/SEmxaHFvsrQOBmnL8IgqfDj9buZX8ojNrrtQPkUZI6qlf4WepM6yN6flshzNApKJQFpaPLHlD2ZwhzHUS1jo+BANtyKFft/gI3kIUCKccQ2c1TO4P6zCFGbHIghxho9ZE2QiHy+z6y2CBUVus/chIyWh8CaZRf74zXPz/xCYTFZ79G9iIz/kOAzLZicuplofpqClLGyz5PaJ8ry2LIjJhSAGd9FAR4+v283++ft03x2YnEJXucjD5CyFsqU6XJNYiLzi1v+5KdIVJWDbPAUlXO8i3XQZRElDaS/boiLDIrgDXAFUhhyTSVKWes1HgGkTcIZ/EV4glrRDwpJR8lEb4FYkS0OUWzjZiZwBEAiWQTZkfHy9SRi+B4VEfGqJkHFmpf62U1UsJCxt1d0M24p8RMvs+bRsM9sYXjuDIdkF4bkN4akN4akN4akN4akN4akN4akN4akN4akN4akN4akN4akN4akN4akDt7KR1wXReQf+zbTW+sIBQG4B3mwIKAG7hLnRh1Mav5/7/tCh58nQs3qW2qTOK7aQ+xE57yIUkpKd1p/SDxHheaRysKaZb82TfUAMEt2ueeMqdmqd0nQNyz2UWLFGXQKukDIH3zFrW/zQmJqx6im5BJWdvG7wx3WYaiH5dmE0eqdgjxMOB62gvXhAfHzcFXOWTk24AYnQETjnbNr8ohE3c4xm3dIyah2R+BOHIoiM6AxGmDKnXvgUHg4TH/hwx+ydMJG76SsF34GLlu5cqbuNbotyHtEv0G6bfZZLeHMGwFSJcuGar4mG44chbkt4LOPKLMvGC46zM3g1WC6GZ9liG+2WJmiUK6cyC4eP7Ix0Bzewmise2p1OepZ8m+eJ0HIVw7nXKIKkJGPg8A0s+7e4e9DUWk+PMgnvt7AGLZwRBMIWdiQSjMORC8RQ5A+BXaiQ2CGdTiZ/BWOgUy8q/wAIRksgOi9tfxLVSnQWbefI5A+rgMXBGiL4HgnHUAwlGiJghJLNqvbr8cQxVB4ChDCi9ExNcDWR2dQDosGFQ5RMYfHGuBuLhon9kWplI1hMrlEEl2PYpUAhnS5oPYtyGS+T+apNXRRZCrAoK+II4P9Di6tOVjvJORXANEF0/ZLTYqnCVzSDqk2OshuQNzy1g8IYoQDOjVkEeTBwun8W1r8NrLIDhIDVdDVBHCkx/RogzBoWCsFSJoyhw5BHu1oYunlsyzIVeK6azIIpf4VAyhatfPeiRdKCwXXSh+APl5ZjuT+F4+5O8j/+aG3JBPyQ2pLTekttyQv+3dAREAIAjAQAT16J/YGpPbN1iC0RhCYwiNITSG0BhCYwiNITSG0BhCYwiNITSG0BhCYwiNITSG0BhCMygk7ggdOWPZfOZMtGvt/l3kqgetqU27/4yQzgAAAABJRU5ErkJggg==", + "description": "Displays a latest visibility telemetry data in a box layout.", + "descriptor": { + "type": "latest", + "sizeX": 3, + "sizeY": 3, + "resources": [], + "templateHtml": "\n", + "templateCss": "", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueCardWidget.onDataUpdated();\n};\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '250px',\n previewHeight: '250px',\n embedTitlePanel: true,\n defaultDataKeysFunction: function() {\n return [{ name: 'visibility', label: 'Visibility', type: 'timeseries' }];\n }\n };\n};\n\nself.onDestroy = function() {\n};\n", + "settingsSchema": "", + "dataKeySettingsSchema": "", + "settingsDirective": "tb-value-card-widget-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"function\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Visibility\",\"color\":\"#2196f3\",\"settings\":{},\"_hash\":0.2392660816082064,\"funcBody\":\"var value = prevValue + Math.random() * 10 - 5;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 20) {\\n\\tvalue = 20;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]}}],\"timewindow\":{\"realtime\":{\"timewindowMs\":60000}},\"showTitle\":false,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"padding\":\"0px\",\"settings\":{\"labelPosition\":\"top\",\"layout\":\"square\",\"showLabel\":true,\"labelFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\"},\"labelColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showIcon\":true,\"iconSize\":40,\"iconSizeUnit\":\"px\",\"icon\":\"visibility\",\"iconColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":0,\"to\":1,\"color\":\"#D81838\"},{\"from\":1,\"to\":4,\"color\":\"#FFA600\"},{\"from\":4,\"to\":null,\"color\":\"#80C32C\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"valueFont\":{\"size\":52,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\",\"rangeList\":[{\"from\":0,\"to\":1,\"color\":\"#D81838\"},{\"from\":1,\"to\":4,\"color\":\"#FFA600\"},{\"from\":4,\"to\":null,\"color\":\"#80C32C\"}]},\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"dateColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"color\",\"color\":\"#fff\",\"overlay\":{\"enabled\":false,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Air quality card\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"units\":\"km\",\"decimals\":0,\"useDashboardTimewindow\":true,\"showLegend\":false,\"widgetStyle\":{},\"actions\":{},\"configMode\":\"basic\",\"displayTimewindow\":true,\"margin\":\"0px\",\"borderRadius\":\"0px\",\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"showTitleIcon\":false,\"titleTooltip\":\"\",\"titleFont\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1.6\"},\"titleIcon\":\"\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"iconSize\":\"14px\",\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"14px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1\"},\"color\":null}}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "visibility" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/visibility_card_with_background.json b/application/src/main/data/json/system/widget_types/visibility_card_with_background.json new file mode 100644 index 0000000000..86d6ce56f4 --- /dev/null +++ b/application/src/main/data/json/system/widget_types/visibility_card_with_background.json @@ -0,0 +1,28 @@ +{ + "fqn": "visibility_card_with_background", + "name": "Visibility card with background", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays a latest visibility telemetry data in a box layout with background.", + "descriptor": { + "type": "latest", + "sizeX": 3, + "sizeY": 3, + "resources": [], + "templateHtml": "\n", + "templateCss": "", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueCardWidget.onDataUpdated();\n};\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '250px',\n previewHeight: '250px',\n embedTitlePanel: true,\n defaultDataKeysFunction: function() {\n return [{ name: 'visibility', label: 'Visibility', type: 'timeseries' }];\n }\n };\n};\n\nself.onDestroy = function() {\n};\n", + "settingsSchema": "", + "dataKeySettingsSchema": "", + "settingsDirective": "tb-value-card-widget-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"function\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Visibility\",\"color\":\"#2196f3\",\"settings\":{},\"_hash\":0.2392660816082064,\"funcBody\":\"var value = prevValue + Math.random() * 10 - 5;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 20) {\\n\\tvalue = 20;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]}}],\"timewindow\":{\"realtime\":{\"timewindowMs\":60000}},\"showTitle\":false,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"padding\":\"0px\",\"settings\":{\"labelPosition\":\"top\",\"layout\":\"square\",\"showLabel\":true,\"labelFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\"},\"labelColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showIcon\":true,\"iconSize\":40,\"iconSizeUnit\":\"px\",\"icon\":\"visibility\",\"iconColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":0,\"to\":1,\"color\":\"#DE2343\"},{\"from\":1,\"to\":4,\"color\":\"#F89E0D\"},{\"from\":4,\"to\":null,\"color\":\"#7CC322\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"valueFont\":{\"size\":52,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\",\"rangeList\":[{\"from\":0,\"to\":1,\"color\":\"#DE2343\"},{\"from\":1,\"to\":4,\"color\":\"#F89E0D\"},{\"from\":4,\"to\":null,\"color\":\"#7CC322\"}]},\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"dateColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"image\",\"imageBase64\":\"data:image/png;base64,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\",\"imageUrl\":null,\"color\":\"#fff\",\"overlay\":{\"enabled\":true,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Air quality card\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"units\":\"km\",\"decimals\":0,\"useDashboardTimewindow\":true,\"showLegend\":false,\"widgetStyle\":{},\"actions\":{},\"configMode\":\"basic\",\"displayTimewindow\":true,\"margin\":\"0px\",\"borderRadius\":\"0px\",\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"showTitleIcon\":false,\"titleTooltip\":\"\",\"titleFont\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1.6\"},\"titleIcon\":\"\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"iconSize\":\"14px\",\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"14px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1\"},\"color\":null}}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "visibility" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/visibility_chart_card.json b/application/src/main/data/json/system/widget_types/visibility_chart_card.json new file mode 100644 index 0000000000..e3c8732989 --- /dev/null +++ b/application/src/main/data/json/system/widget_types/visibility_chart_card.json @@ -0,0 +1,31 @@ +{ + "fqn": "visibility_chart_card", + "name": "Visibility chart card", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays a visibility data as a combination of the latest and aggregated values. Optionally may display the corresponding historical values as a simplified chart.", + "descriptor": { + "type": "timeseries", + "sizeX": 4.5, + "sizeY": 3.5, + "resources": [], + "templateHtml": "\n\n", + "templateCss": ".legend {\n font-size: 13px;\n line-height: 10px;\n}\n\n.legend table { \n border-spacing: 0px;\n border-collapse: separate;\n}\n\n.mouse-events .flot-overlay {\n cursor: crosshair; \n}\n\n", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onDataUpdated();\n};\n\nself.onLatestDataUpdated = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onLatestDataUpdated();\n}\n\nself.onResize = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onResize();\n}\n\nself.onEditModeChanged = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onEditModeChanged();\n}\n\nself.onDestroy = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onDestroy();\n}\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '400px',\n previewHeight: '300px',\n embedTitlePanel: true,\n hasAdditionalLatestDataKeys: true,\n defaultDataKeysFunction: function() {\n return [\n { name: 'visibility', label: 'Visibility', type: 'timeseries', color: 'rgba(0, 0, 0, 0.87)', units: 'km', decimals: 0 }\n ];\n },\n defaultLatestDataKeysFunction: function(configComponent, configData) {\n return configComponent.createDefaultAggregatedValueLatestDataKeys(configData, 'visibility', 'km', 0);\n }\n };\n}\n", + "settingsSchema": "{}", + "dataKeySettingsSchema": "{}", + "latestDataKeySettingsSchema": "{}", + "settingsDirective": "tb-aggregated-value-card-widget-settings", + "dataKeySettingsDirective": "", + "latestDataKeySettingsDirective": "tb-aggregated-value-card-key-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-aggregated-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"Main building\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Visibility\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{\"showLines\":true,\"fillLines\":true,\"showPoints\":false},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 10 - 5;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 20) {\\n\\tvalue = 20;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"km\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"#4caf50\",\"settings\":{\"position\":\"center\",\"font\":{\"size\":52,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"1\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":0,\"to\":1,\"color\":\"#D81838\"},{\"from\":1,\"to\":4,\"color\":\"#FFA600\"},{\"from\":4,\"to\":null,\"color\":\"#80C32C\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.9408410830697858,\"funcBody\":\"var value = prevValue + Math.random() * 10 - 5;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 20) {\\n\\tvalue = 20;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"km\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta percent\",\"color\":\"#f44336\",\"settings\":{\"position\":\"rightTop\",\"font\":{\"size\":14,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"20px\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[{\"from\":null,\"to\":0,\"color\":\"#198038\"},{\"from\":0,\"to\":0,\"color\":\"rgba(0, 0, 0, 0.87)\"},{\"from\":0,\"to\":null,\"color\":\"#D12730\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":true},\"_hash\":0.06392321853157967,\"funcBody\":\"var value = prevValue + Math.random() * 6 - 3;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < -25) {\\n\\tvalue = -25;\\n} else if (value > 25) {\\n\\tvalue = 25;\\n} \\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta absolute\",\"color\":\"#607d8b\",\"settings\":{\"position\":\"rightBottom\",\"font\":{\"size\":11,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.44695098620509865,\"funcBody\":\"var value = prevValue + Math.random() * 4 - 2;\\nif (value < -4) {\\n\\tvalue = -4;\\n} else if (value > 4) {\\n\\tvalue = 4;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"km\",\"decimals\":1,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1691927717318,\"endTimeMs\":1692014117318},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"stack\":false,\"fontSize\":10,\"fontColor\":\"#545454\",\"showTooltip\":true,\"tooltipIndividual\":false,\"tooltipCumulative\":false,\"hideZeros\":false,\"grid\":{\"verticalLines\":true,\"horizontalLines\":true,\"outlineWidth\":1,\"color\":\"#545454\",\"backgroundColor\":null,\"tickColor\":\"#DDDDDD\"},\"xaxis\":{\"title\":null,\"showLabels\":true,\"color\":\"#545454\"},\"yaxis\":{\"min\":null,\"max\":null,\"title\":null,\"showLabels\":true,\"color\":\"#545454\",\"tickSize\":null,\"tickDecimals\":0,\"ticksFormatter\":\"\"},\"shadowSize\":4,\"smoothLines\":false,\"comparisonEnabled\":false,\"xaxisSecond\":{\"axisPosition\":\"top\",\"title\":null,\"showLabels\":true},\"showLegend\":true,\"legendConfig\":{\"direction\":\"column\",\"position\":\"bottom\",\"sortDataKeys\":false,\"showMin\":false,\"showMax\":false,\"showAvg\":true,\"showTotal\":false,\"showLatest\":false},\"customLegendEnabled\":false,\"showSubtitle\":true,\"subtitle\":\"${entityName}\",\"subtitleFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"subtitleColor\":\"rgba(0, 0, 0, 0.38)\",\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"dateColor\":\"rgba(0, 0, 0, 0.38)\",\"showChart\":true,\"chartColor\":\"rgba(0, 0, 0, 0.87)\",\"background\":{\"type\":\"color\",\"color\":\"#fff\",\"overlay\":{\"enabled\":false,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Visibility\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"visibility\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"24px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":false,\"displayTimewindow\":true,\"decimals\":0,\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"24px\",\"icon\":null,\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":false},\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "visibility" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/visibility_chart_card_with_background.json b/application/src/main/data/json/system/widget_types/visibility_chart_card_with_background.json new file mode 100644 index 0000000000..6bd2ee1cde --- /dev/null +++ b/application/src/main/data/json/system/widget_types/visibility_chart_card_with_background.json @@ -0,0 +1,31 @@ +{ + "fqn": "visibility_chart_card_with_background", + "name": "Visibility chart card with background", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays a visibility data as a combination of the latest and aggregated values with background. Optionally may display the corresponding historical values as a simplified chart.", + "descriptor": { + "type": "timeseries", + "sizeX": 4.5, + "sizeY": 3.5, + "resources": [], + "templateHtml": "\n\n", + "templateCss": ".legend {\n font-size: 13px;\n line-height: 10px;\n}\n\n.legend table { \n border-spacing: 0px;\n border-collapse: separate;\n}\n\n.mouse-events .flot-overlay {\n cursor: crosshair; \n}\n\n", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onDataUpdated();\n};\n\nself.onLatestDataUpdated = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onLatestDataUpdated();\n}\n\nself.onResize = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onResize();\n}\n\nself.onEditModeChanged = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onEditModeChanged();\n}\n\nself.onDestroy = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onDestroy();\n}\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '400px',\n previewHeight: '300px',\n embedTitlePanel: true,\n hasAdditionalLatestDataKeys: true,\n defaultDataKeysFunction: function() {\n return [\n { name: 'visibility', label: 'Visibility', type: 'timeseries', color: 'rgba(0, 0, 0, 0.87)', units: 'km', decimals: 0 }\n ];\n },\n defaultLatestDataKeysFunction: function(configComponent, configData) {\n return configComponent.createDefaultAggregatedValueLatestDataKeys(configData, 'visibility', 'km', 0);\n }\n };\n}\n", + "settingsSchema": "{}", + "dataKeySettingsSchema": "{}", + "latestDataKeySettingsSchema": "{}", + "settingsDirective": "tb-aggregated-value-card-widget-settings", + "dataKeySettingsDirective": "", + "latestDataKeySettingsDirective": "tb-aggregated-value-card-key-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-aggregated-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"Main building\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Visibility\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{\"showLines\":true,\"fillLines\":true,\"showPoints\":false},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 10 - 5;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 20) {\\n\\tvalue = 20;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"km\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"#4caf50\",\"settings\":{\"position\":\"center\",\"font\":{\"size\":52,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"1\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":0,\"to\":1,\"color\":\"#DE2343\"},{\"from\":1,\"to\":4,\"color\":\"#F89E0D\"},{\"from\":4,\"to\":null,\"color\":\"#7CC322\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.9408410830697858,\"funcBody\":\"var value = prevValue + Math.random() * 10 - 5;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 20) {\\n\\tvalue = 20;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"km\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta percent\",\"color\":\"#f44336\",\"settings\":{\"position\":\"rightTop\",\"font\":{\"size\":14,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"20px\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[{\"from\":null,\"to\":0,\"color\":\"#198038\"},{\"from\":0,\"to\":0,\"color\":\"rgba(0, 0, 0, 0.87)\"},{\"from\":0,\"to\":null,\"color\":\"#D12730\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":true},\"_hash\":0.06392321853157967,\"funcBody\":\"var value = prevValue + Math.random() * 6 - 3;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < -25) {\\n\\tvalue = -25;\\n} else if (value > 25) {\\n\\tvalue = 25;\\n} \\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta absolute\",\"color\":\"#607d8b\",\"settings\":{\"position\":\"rightBottom\",\"font\":{\"size\":11,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.44695098620509865,\"funcBody\":\"var value = prevValue + Math.random() * 4 - 2;\\nif (value < -4) {\\n\\tvalue = -4;\\n} else if (value > 4) {\\n\\tvalue = 4;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"km\",\"decimals\":1,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1691927717318,\"endTimeMs\":1692014117318},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"stack\":false,\"fontSize\":10,\"fontColor\":\"#545454\",\"showTooltip\":true,\"tooltipIndividual\":false,\"tooltipCumulative\":false,\"hideZeros\":false,\"grid\":{\"verticalLines\":true,\"horizontalLines\":true,\"outlineWidth\":1,\"color\":\"#545454\",\"backgroundColor\":null,\"tickColor\":\"#DDDDDD\"},\"xaxis\":{\"title\":null,\"showLabels\":true,\"color\":\"#545454\"},\"yaxis\":{\"min\":null,\"max\":null,\"title\":null,\"showLabels\":true,\"color\":\"#545454\",\"tickSize\":null,\"tickDecimals\":0,\"ticksFormatter\":\"\"},\"shadowSize\":4,\"smoothLines\":false,\"comparisonEnabled\":false,\"xaxisSecond\":{\"axisPosition\":\"top\",\"title\":null,\"showLabels\":true},\"showLegend\":true,\"legendConfig\":{\"direction\":\"column\",\"position\":\"bottom\",\"sortDataKeys\":false,\"showMin\":false,\"showMax\":false,\"showAvg\":true,\"showTotal\":false,\"showLatest\":false},\"customLegendEnabled\":false,\"showSubtitle\":true,\"subtitle\":\"${entityName}\",\"subtitleFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"subtitleColor\":\"rgba(0, 0, 0, 0.38)\",\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"dateColor\":\"rgba(0, 0, 0, 0.38)\",\"showChart\":true,\"chartColor\":\"rgba(0, 0, 0, 0.87)\",\"background\":{\"type\":\"image\",\"imageBase64\":\"data:image/png;base64,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\",\"imageUrl\":null,\"color\":\"#fff\",\"overlay\":{\"enabled\":true,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Visibility\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"visibility\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"24px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":false,\"displayTimewindow\":true,\"decimals\":0,\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"24px\",\"icon\":null,\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":false},\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "visibility" + ] +} \ No newline at end of file From 0851fd7c90ab0cd8dc21b3b5d71060fd34bbdb4c Mon Sep 17 00:00:00 2001 From: Igor Kulikov Date: Tue, 24 Oct 2023 11:33:11 +0300 Subject: [PATCH 29/43] UI: Outdoor Environment: Ground temperature widgets. --- .../widget_bundles/outdoor_environment.json | 10 +++++- .../widget_types/ground_temperature_card.json | 29 +++++++++++++++++ ...ound_temperature_card_with_background.json | 29 +++++++++++++++++ .../ground_temperature_chart_card.json | 32 +++++++++++++++++++ ...emperature_chart_card_with_background.json | 32 +++++++++++++++++++ .../horizontal_ground_temperature_card.json | 29 +++++++++++++++++ ...ound_temperature_card_with_background.json | 29 +++++++++++++++++ .../simple_ground_temperature_chart_card.json | 32 +++++++++++++++++++ ...emperature_chart_card_with_background.json | 32 +++++++++++++++++++ 9 files changed, 253 insertions(+), 1 deletion(-) create mode 100644 application/src/main/data/json/system/widget_types/ground_temperature_card.json create mode 100644 application/src/main/data/json/system/widget_types/ground_temperature_card_with_background.json create mode 100644 application/src/main/data/json/system/widget_types/ground_temperature_chart_card.json create mode 100644 application/src/main/data/json/system/widget_types/ground_temperature_chart_card_with_background.json create mode 100644 application/src/main/data/json/system/widget_types/horizontal_ground_temperature_card.json create mode 100644 application/src/main/data/json/system/widget_types/horizontal_ground_temperature_card_with_background.json create mode 100644 application/src/main/data/json/system/widget_types/simple_ground_temperature_chart_card.json create mode 100644 application/src/main/data/json/system/widget_types/simple_ground_temperature_chart_card_with_background.json diff --git a/application/src/main/data/json/system/widget_bundles/outdoor_environment.json b/application/src/main/data/json/system/widget_bundles/outdoor_environment.json index 75b41d4e4d..c3d69318d7 100644 --- a/application/src/main/data/json/system/widget_bundles/outdoor_environment.json +++ b/application/src/main/data/json/system/widget_bundles/outdoor_environment.json @@ -85,6 +85,14 @@ "visibility_chart_card", "visibility_chart_card_with_background", "simple_visibility_chart_card", - "simple_visibility_chart_card_with_background" + "simple_visibility_chart_card_with_background", + "ground_temperature_card", + "ground_temperature_card_with_background", + "horizontal_ground_temperature_card", + "horizontal_ground_temperature_card_with_background", + "ground_temperature_chart_card", + "ground_temperature_chart_card_with_background", + "simple_ground_temperature_chart_card", + "simple_ground_temperature_chart_card_with_background" ] } \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/ground_temperature_card.json b/application/src/main/data/json/system/widget_types/ground_temperature_card.json new file mode 100644 index 0000000000..202e88bcca --- /dev/null +++ b/application/src/main/data/json/system/widget_types/ground_temperature_card.json @@ -0,0 +1,29 @@ +{ + "fqn": "ground_temperature_card", + "name": "Ground temperature card", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays a latest ground temperature telemetry data in a box layout.", + "descriptor": { + "type": "latest", + "sizeX": 3, + "sizeY": 3, + "resources": [], + "templateHtml": "\n", + "templateCss": "", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueCardWidget.onDataUpdated();\n};\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '250px',\n previewHeight: '250px',\n embedTitlePanel: true,\n defaultDataKeysFunction: function() {\n return [{ name: 'temperature', label: 'Ground temperature', type: 'timeseries' }];\n }\n };\n};\n\nself.onDestroy = function() {\n};\n", + "settingsSchema": "", + "dataKeySettingsSchema": "", + "settingsDirective": "tb-value-card-widget-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"function\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Ground temperature\",\"color\":\"#2196f3\",\"settings\":{},\"_hash\":0.2392660816082064,\"funcBody\":\"var value = prevValue + Math.random() * 40 - 20;\\nif (value < -60) {\\n\\tvalue = -60;\\n} else if (value > 60) {\\n\\tvalue = 60;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]}}],\"timewindow\":{\"realtime\":{\"timewindowMs\":60000}},\"showTitle\":false,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"padding\":\"0px\",\"settings\":{\"labelPosition\":\"top\",\"layout\":\"square\",\"showLabel\":true,\"labelFont\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\"},\"labelColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showIcon\":true,\"iconSize\":40,\"iconSizeUnit\":\"px\",\"icon\":\"thermostat\",\"iconColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":-20,\"color\":\"#234CC7\"},{\"from\":-20,\"to\":0,\"color\":\"#305AD7\"},{\"from\":0,\"to\":10,\"color\":\"#7191EF\"},{\"from\":10,\"to\":20,\"color\":\"#FFA600\"},{\"from\":20,\"to\":30,\"color\":\"#F36900\"},{\"from\":30,\"to\":40,\"color\":\"#F04022\"},{\"from\":40,\"to\":null,\"color\":\"#D81838\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"valueFont\":{\"family\":\"Roboto\",\"size\":52,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\",\"rangeList\":[{\"from\":null,\"to\":-20,\"color\":\"#234CC7\"},{\"from\":-20,\"to\":0,\"color\":\"#305AD7\"},{\"from\":0,\"to\":10,\"color\":\"#7191EF\"},{\"from\":10,\"to\":20,\"color\":\"#FFA600\"},{\"from\":20,\"to\":30,\"color\":\"#F36900\"},{\"from\":30,\"to\":40,\"color\":\"#F04022\"},{\"from\":40,\"to\":null,\"color\":\"#D81838\"}]},\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"dateColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"color\",\"color\":\"#fff\",\"overlay\":{\"enabled\":false,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Ground temperature card\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"units\":\"°C\",\"decimals\":0,\"useDashboardTimewindow\":true,\"showLegend\":false,\"widgetStyle\":{},\"actions\":{},\"configMode\":\"basic\",\"displayTimewindow\":true,\"margin\":\"0px\",\"borderRadius\":\"0px\",\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"showTitleIcon\":false,\"titleTooltip\":\"\",\"titleFont\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1.6\"},\"titleIcon\":\"\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"iconSize\":\"14px\",\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"14px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1\"},\"color\":null}}" + }, + "externalId": null, + "tags": [ + "temperature", + "weather", + "environment", + "ground" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/ground_temperature_card_with_background.json b/application/src/main/data/json/system/widget_types/ground_temperature_card_with_background.json new file mode 100644 index 0000000000..402501f7e8 --- /dev/null +++ b/application/src/main/data/json/system/widget_types/ground_temperature_card_with_background.json @@ -0,0 +1,29 @@ +{ + "fqn": "ground_temperature_card_with_background", + "name": "Ground temperature card with background", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays a latest ground temperature telemetry data in a box layout with background.", + "descriptor": { + "type": "latest", + "sizeX": 3, + "sizeY": 3, + "resources": [], + "templateHtml": "\n", + "templateCss": "", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueCardWidget.onDataUpdated();\n};\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '250px',\n previewHeight: '250px',\n embedTitlePanel: true,\n defaultDataKeysFunction: function() {\n return [{ name: 'temperature', label: 'Ground temperature', type: 'timeseries' }];\n }\n };\n};\n\nself.onDestroy = function() {\n};\n", + "settingsSchema": "", + "dataKeySettingsSchema": "", + "settingsDirective": "tb-value-card-widget-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"function\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Ground temperature\",\"color\":\"#2196f3\",\"settings\":{},\"_hash\":0.2392660816082064,\"funcBody\":\"var value = prevValue + Math.random() * 40 - 20;\\nif (value < -60) {\\n\\tvalue = -60;\\n} else if (value > 60) {\\n\\tvalue = 60;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]}}],\"timewindow\":{\"realtime\":{\"timewindowMs\":60000}},\"showTitle\":false,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"padding\":\"0px\",\"settings\":{\"labelPosition\":\"top\",\"layout\":\"square\",\"showLabel\":true,\"labelFont\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\"},\"labelColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showIcon\":true,\"iconSize\":40,\"iconSizeUnit\":\"px\",\"icon\":\"thermostat\",\"iconColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":-20,\"color\":\"#224AC2\"},{\"from\":-20,\"to\":0,\"color\":\"#2B54CE\"},{\"from\":0,\"to\":10,\"color\":\"#6083EC\"},{\"from\":10,\"to\":20,\"color\":\"#F89E0D\"},{\"from\":20,\"to\":30,\"color\":\"#F77410\"},{\"from\":30,\"to\":40,\"color\":\"#F04022\"},{\"from\":40,\"to\":null,\"color\":\"#DE2343\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"valueFont\":{\"family\":\"Roboto\",\"size\":52,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\",\"rangeList\":[{\"from\":null,\"to\":-20,\"color\":\"#224AC2\"},{\"from\":-20,\"to\":0,\"color\":\"#2B54CE\"},{\"from\":0,\"to\":10,\"color\":\"#6083EC\"},{\"from\":10,\"to\":20,\"color\":\"#F89E0D\"},{\"from\":20,\"to\":30,\"color\":\"#F77410\"},{\"from\":30,\"to\":40,\"color\":\"#F04022\"},{\"from\":40,\"to\":null,\"color\":\"#DE2343\"}]},\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"dateColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"image\",\"imageBase64\":\"data:image/png;base64,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\",\"imageUrl\":null,\"color\":\"#fff\",\"overlay\":{\"enabled\":true,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Ground temperature card with background\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"units\":\"°C\",\"decimals\":0,\"useDashboardTimewindow\":true,\"showLegend\":false,\"widgetStyle\":{},\"actions\":{},\"configMode\":\"basic\",\"displayTimewindow\":true,\"margin\":\"0px\",\"borderRadius\":\"0px\",\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"showTitleIcon\":false,\"titleTooltip\":\"\",\"titleFont\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1.6\"},\"titleIcon\":\"\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"iconSize\":\"14px\",\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"14px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1\"},\"color\":null}}" + }, + "externalId": null, + "tags": [ + "temperature", + "weather", + "environment", + "ground" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/ground_temperature_chart_card.json b/application/src/main/data/json/system/widget_types/ground_temperature_chart_card.json new file mode 100644 index 0000000000..2f829baf42 --- /dev/null +++ b/application/src/main/data/json/system/widget_types/ground_temperature_chart_card.json @@ -0,0 +1,32 @@ +{ + "fqn": "ground_temperature_chart_card", + "name": "Ground temperature chart card", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays a ground temperature data as a combination of the latest and aggregated values. Optionally may display the corresponding historical values as a simplified chart.", + "descriptor": { + "type": "timeseries", + "sizeX": 4.5, + "sizeY": 3.5, + "resources": [], + "templateHtml": "\n\n", + "templateCss": ".legend {\n font-size: 13px;\n line-height: 10px;\n}\n\n.legend table { \n border-spacing: 0px;\n border-collapse: separate;\n}\n\n.mouse-events .flot-overlay {\n cursor: crosshair; \n}\n\n", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onDataUpdated();\n};\n\nself.onLatestDataUpdated = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onLatestDataUpdated();\n}\n\nself.onResize = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onResize();\n}\n\nself.onEditModeChanged = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onEditModeChanged();\n}\n\nself.onDestroy = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onDestroy();\n}\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '400px',\n previewHeight: '300px',\n embedTitlePanel: true,\n hasAdditionalLatestDataKeys: true,\n defaultDataKeysFunction: function() {\n return [\n { name: 'temperature', label: 'Ground temperature', type: 'timeseries', color: 'rgba(0, 0, 0, 0.87)', units: '°C', decimals: 0 }\n ];\n },\n defaultLatestDataKeysFunction: function(configComponent, configData) {\n return configComponent.createDefaultAggregatedValueLatestDataKeys(configData, 'temperature', '°C', 0);\n }\n };\n}\n", + "settingsSchema": "{}", + "dataKeySettingsSchema": "{}", + "latestDataKeySettingsSchema": "{}", + "settingsDirective": "tb-aggregated-value-card-widget-settings", + "dataKeySettingsDirective": "", + "latestDataKeySettingsDirective": "tb-aggregated-value-card-key-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-aggregated-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"Main building\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Ground temperature\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{\"showLines\":true,\"fillLines\":true,\"showPoints\":false},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 40 - 20;\\nif (value < -60) {\\n\\tvalue = -60;\\n} else if (value > 60) {\\n\\tvalue = 60;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"°C\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"#4caf50\",\"settings\":{\"position\":\"center\",\"font\":{\"size\":52,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"1\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":-20,\"color\":\"#234CC7\"},{\"from\":-20,\"to\":0,\"color\":\"#305AD7\"},{\"from\":0,\"to\":10,\"color\":\"#7191EF\"},{\"from\":10,\"to\":20,\"color\":\"#FFA600\"},{\"from\":20,\"to\":30,\"color\":\"#F36900\"},{\"from\":30,\"to\":40,\"color\":\"#F04022\"},{\"from\":40,\"to\":null,\"color\":\"#D81838\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.9408410830697858,\"funcBody\":\"var value = prevValue + Math.random() * 40 - 20;\\nif (value < -60) {\\n\\tvalue = -60;\\n} else if (value > 60) {\\n\\tvalue = 60;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"°C\",\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta percent\",\"color\":\"#f44336\",\"settings\":{\"position\":\"rightTop\",\"font\":{\"size\":14,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"20px\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[{\"from\":null,\"to\":0,\"color\":\"#198038\"},{\"from\":0,\"to\":0,\"color\":\"rgba(0, 0, 0, 0.87)\"},{\"from\":0,\"to\":null,\"color\":\"#D12730\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":true},\"_hash\":0.06392321853157967,\"funcBody\":\"var value = prevValue + Math.random() * 6 - 3;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < -25) {\\n\\tvalue = -25;\\n} else if (value > 25) {\\n\\tvalue = 25;\\n} \\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta absolute\",\"color\":\"#607d8b\",\"settings\":{\"position\":\"rightBottom\",\"font\":{\"size\":11,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.44695098620509865,\"funcBody\":\"var value = prevValue + Math.random() * 4 - 2;\\nif (value < -6) {\\n\\tvalue = -6;\\n} else if (value > 6) {\\n\\tvalue = 6;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"°C\",\"decimals\":1,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1691927717318,\"endTimeMs\":1692014117318},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"stack\":false,\"fontSize\":10,\"fontColor\":\"#545454\",\"showTooltip\":true,\"tooltipIndividual\":false,\"tooltipCumulative\":false,\"hideZeros\":false,\"grid\":{\"verticalLines\":true,\"horizontalLines\":true,\"outlineWidth\":1,\"color\":\"#545454\",\"backgroundColor\":null,\"tickColor\":\"#DDDDDD\"},\"xaxis\":{\"title\":null,\"showLabels\":true,\"color\":\"#545454\"},\"yaxis\":{\"min\":null,\"max\":null,\"title\":null,\"showLabels\":true,\"color\":\"#545454\",\"tickSize\":null,\"tickDecimals\":0,\"ticksFormatter\":\"\"},\"shadowSize\":4,\"smoothLines\":false,\"comparisonEnabled\":false,\"xaxisSecond\":{\"axisPosition\":\"top\",\"title\":null,\"showLabels\":true},\"showLegend\":true,\"legendConfig\":{\"direction\":\"column\",\"position\":\"bottom\",\"sortDataKeys\":false,\"showMin\":false,\"showMax\":false,\"showAvg\":true,\"showTotal\":false,\"showLatest\":false},\"customLegendEnabled\":false,\"showSubtitle\":true,\"subtitle\":\"${entityName}\",\"subtitleFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"subtitleColor\":\"rgba(0, 0, 0, 0.38)\",\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"dateColor\":\"rgba(0, 0, 0, 0.38)\",\"showChart\":true,\"chartColor\":\"rgba(0, 0, 0, 0.87)\",\"background\":{\"type\":\"color\",\"color\":\"#fff\",\"overlay\":{\"enabled\":false,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Ground temperature\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"device_thermostat\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"24px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":false,\"displayTimewindow\":true,\"decimals\":0,\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"24px\",\"icon\":null,\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":false},\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null}" + }, + "externalId": null, + "tags": [ + "temperature", + "weather", + "environment", + "ground" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/ground_temperature_chart_card_with_background.json b/application/src/main/data/json/system/widget_types/ground_temperature_chart_card_with_background.json new file mode 100644 index 0000000000..933461c9d8 --- /dev/null +++ b/application/src/main/data/json/system/widget_types/ground_temperature_chart_card_with_background.json @@ -0,0 +1,32 @@ +{ + "fqn": "ground_temperature_chart_card_with_background", + "name": "Ground temperature chart card with background", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays a ground temperature data as a combination of the latest and aggregated values with background. Optionally may display the corresponding historical values as a simplified chart.", + "descriptor": { + "type": "timeseries", + "sizeX": 4.5, + "sizeY": 3.5, + "resources": [], + "templateHtml": "\n\n", + "templateCss": ".legend {\n font-size: 13px;\n line-height: 10px;\n}\n\n.legend table { \n border-spacing: 0px;\n border-collapse: separate;\n}\n\n.mouse-events .flot-overlay {\n cursor: crosshair; \n}\n\n", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onDataUpdated();\n};\n\nself.onLatestDataUpdated = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onLatestDataUpdated();\n}\n\nself.onResize = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onResize();\n}\n\nself.onEditModeChanged = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onEditModeChanged();\n}\n\nself.onDestroy = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onDestroy();\n}\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '400px',\n previewHeight: '300px',\n embedTitlePanel: true,\n hasAdditionalLatestDataKeys: true,\n defaultDataKeysFunction: function() {\n return [\n { name: 'temperature', label: 'Ground temperature', type: 'timeseries', color: 'rgba(0, 0, 0, 0.87)', units: '°C', decimals: 0 }\n ];\n },\n defaultLatestDataKeysFunction: function(configComponent, configData) {\n return configComponent.createDefaultAggregatedValueLatestDataKeys(configData, 'temperature', '°C', 0);\n }\n };\n}\n", + "settingsSchema": "{}", + "dataKeySettingsSchema": "{}", + "latestDataKeySettingsSchema": "{}", + "settingsDirective": "tb-aggregated-value-card-widget-settings", + "dataKeySettingsDirective": "", + "latestDataKeySettingsDirective": "tb-aggregated-value-card-key-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-aggregated-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"Main building\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Ground temperature\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{\"showLines\":true,\"fillLines\":true,\"showPoints\":false},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 40 - 20;\\nif (value < -60) {\\n\\tvalue = -60;\\n} else if (value > 60) {\\n\\tvalue = 60;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"°C\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"#4caf50\",\"settings\":{\"position\":\"center\",\"font\":{\"size\":52,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"1\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":-20,\"color\":\"#224AC2\"},{\"from\":-20,\"to\":0,\"color\":\"#2B54CE\"},{\"from\":0,\"to\":10,\"color\":\"#6083EC\"},{\"from\":10,\"to\":20,\"color\":\"#F89E0D\"},{\"from\":20,\"to\":30,\"color\":\"#F77410\"},{\"from\":30,\"to\":40,\"color\":\"#F04022\"},{\"from\":40,\"to\":null,\"color\":\"#DE2343\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.9408410830697858,\"funcBody\":\"var value = prevValue + Math.random() * 40 - 20;\\nif (value < -60) {\\n\\tvalue = -60;\\n} else if (value > 60) {\\n\\tvalue = 60;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"°C\",\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta percent\",\"color\":\"#f44336\",\"settings\":{\"position\":\"rightTop\",\"font\":{\"size\":14,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"20px\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[{\"from\":null,\"to\":0,\"color\":\"#198038\"},{\"from\":0,\"to\":0,\"color\":\"rgba(0, 0, 0, 0.87)\"},{\"from\":0,\"to\":null,\"color\":\"#D12730\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":true},\"_hash\":0.06392321853157967,\"funcBody\":\"var value = prevValue + Math.random() * 6 - 3;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < -25) {\\n\\tvalue = -25;\\n} else if (value > 25) {\\n\\tvalue = 25;\\n} \\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta absolute\",\"color\":\"#607d8b\",\"settings\":{\"position\":\"rightBottom\",\"font\":{\"size\":11,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.44695098620509865,\"funcBody\":\"var value = prevValue + Math.random() * 4 - 2;\\nif (value < -6) {\\n\\tvalue = -6;\\n} else if (value > 6) {\\n\\tvalue = 6;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"°C\",\"decimals\":1,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1691927717318,\"endTimeMs\":1692014117318},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"stack\":false,\"fontSize\":10,\"fontColor\":\"#545454\",\"showTooltip\":true,\"tooltipIndividual\":false,\"tooltipCumulative\":false,\"hideZeros\":false,\"grid\":{\"verticalLines\":true,\"horizontalLines\":true,\"outlineWidth\":1,\"color\":\"#545454\",\"backgroundColor\":null,\"tickColor\":\"#DDDDDD\"},\"xaxis\":{\"title\":null,\"showLabels\":true,\"color\":\"#545454\"},\"yaxis\":{\"min\":null,\"max\":null,\"title\":null,\"showLabels\":true,\"color\":\"#545454\",\"tickSize\":null,\"tickDecimals\":0,\"ticksFormatter\":\"\"},\"shadowSize\":4,\"smoothLines\":false,\"comparisonEnabled\":false,\"xaxisSecond\":{\"axisPosition\":\"top\",\"title\":null,\"showLabels\":true},\"showLegend\":true,\"legendConfig\":{\"direction\":\"column\",\"position\":\"bottom\",\"sortDataKeys\":false,\"showMin\":false,\"showMax\":false,\"showAvg\":true,\"showTotal\":false,\"showLatest\":false},\"customLegendEnabled\":false,\"showSubtitle\":true,\"subtitle\":\"${entityName}\",\"subtitleFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"subtitleColor\":\"rgba(0, 0, 0, 0.38)\",\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"dateColor\":\"rgba(0, 0, 0, 0.38)\",\"showChart\":true,\"chartColor\":\"rgba(0, 0, 0, 0.87)\",\"background\":{\"type\":\"image\",\"imageBase64\":\"data:image/png;base64,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\",\"imageUrl\":null,\"color\":\"#fff\",\"overlay\":{\"enabled\":true,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Ground temperature\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"device_thermostat\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"24px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":false,\"displayTimewindow\":true,\"decimals\":0,\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"24px\",\"icon\":null,\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":false},\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null}" + }, + "externalId": null, + "tags": [ + "temperature", + "weather", + "environment", + "ground" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/horizontal_ground_temperature_card.json b/application/src/main/data/json/system/widget_types/horizontal_ground_temperature_card.json new file mode 100644 index 0000000000..e3c564e861 --- /dev/null +++ b/application/src/main/data/json/system/widget_types/horizontal_ground_temperature_card.json @@ -0,0 +1,29 @@ +{ + "fqn": "horizontal_ground_temperature_card", + "name": "Horizontal ground temperature card", + "deprecated": false, + "image": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAMgAAACgCAMAAAB+IdObAAAAqFBMVEUAAADf39/f39/g4ODg4ODf39/////k5OQjTMfg4ODy8vLIyMjI0vFYWFh1j9yQkJDOzs7k6fg+Ys50dHT5+fmsrKxKSkpmZmaRpePb29vy9PvCwsK2trasvOrV1dXn5+efsedaedU9PT28vLy6x+6enp4/Ys66urowV8taeNVMbtI8PDzt7e2dnZ2CgoIhISExV8ovLy/W3fXW3fSRpuODmuBog9nW3vRsY+KEAAAABnRSTlMAIEDfv1C6kOEmAAADiUlEQVR42u3ai1LaQBiGYar232WXzflACIRzOSnVVtv7v7P+2bQijoVYHRqZ7xkIm92M7jtmBmegBQAAAAAAAAAAAAAAAAAAAAAAAAAAAHBKnz48m3FxKT669uVn7hARfXhKXLSuFJ2B6KrVprPQRkjDIKRpENI0CGkahDTNiyGDpXygp+ZuTC8I+anogAOrpwjpyeCHHNGOu9WJVkpR9RAk+MijCR9SThT8sPOkqgX7KhTpRIlybI9UX2fUnfmPo93GRoO99WMhHTnoSod2koKEcJPtjTFzHZIRJt3EIkm/csAmpSRM6C7cpKkRX0MjFomZx8nWDTc63CyM0KGehHz1nOpyJAu+8+jejnyy/GAVjMvXsZ0d1Anp7YVMVJzGrkuJUJMqRMShO6cJr4V6kcSm+EpuLCbCkDs37pyvJjFPXT63ISml23hCNQ1k0PnmyDXvpBo5ZM3W5MseUSBXs05Xyu81Qr7vhRhNLuMgkbwQYrRWv0MS4oobrTnELG4eQ0IKXa2pprXslPc379mRo3J026v2ddu5D2wnMb5paoSM9q4qTDpZcEg8MQuVpHc2RJj0jtdcwzPJn5C7NBELY+YccpMmW7VZ3CSmDClM6FJNs0G58TJkXCbRF+mT1V0u+XzMdayzqhNC+7kkqKKqJ3txIIzanav9RUWvMpArTihDbM6OnawcD1mPOeQfKJfexGe9ahRI/x1CmEP/wRf7i6uOEb01hH9IaUanN+p27dtGL5Bd+nvIrF7ISFq39P+sqw76Yfe8lD494VSLM7k+EjKWlZ+H/9FQ188nFL2Tx3eObjnwZfDszr/1beTDq0P6VYyi64ysKKKo7ZUTbYr4fBgPKcqyaoEn3pZ0L6VTGlBvKZ1uIEfPOwPnYSwD/0hIV1oBPQ0pCi/T2uNRTnmWT6N+7hWF9qbX3jQi8oZqOs1IeXbB01N6g7GsOETfAimXI3qG26Rc+XQkpBfI0mA/xOsr7Q29KmRYZDzmuWHm5dqGtLOMQ3R/qBXn5oreie/3DsweDCHfWcpVh3ZiL8u9fqFzxUm5N83yvuprj+eup0PtURkSlX+R4TQuF4o8p9OqQl4tG9LfFTqjOpoQEkWHFhXV0YiQJkJI0yCkaRDSNAhpmnbr6gw+ZidSV60LcQYftEfiotX6fNkWH93lxTl9qQYAAAAAAAAAAAAAAAAAAAAAAAAAAADgRH4BUVMBmbp0nFsAAAAASUVORK5CYII=", + "description": "Displays a latest ground temperature telemetry data in a horizontal layout.", + "descriptor": { + "type": "latest", + "sizeX": 5, + "sizeY": 1, + "resources": [], + "templateHtml": "\n", + "templateCss": "", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueCardWidget.onDataUpdated();\n};\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n horizontal: true,\n previewWidth: '420px',\n previewHeight: '90px',\n embedTitlePanel: true\n };\n};\n\nself.onDestroy = function() {\n};\n", + "settingsSchema": "", + "dataKeySettingsSchema": "", + "settingsDirective": "tb-value-card-widget-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"function\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Ground temperature\",\"color\":\"#2196f3\",\"settings\":{},\"_hash\":0.2392660816082064,\"funcBody\":\"var value = prevValue + Math.random() * 40 - 20;\\nif (value < -60) {\\n\\tvalue = -60;\\n} else if (value > 60) {\\n\\tvalue = 60;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]}}],\"timewindow\":{\"realtime\":{\"timewindowMs\":60000}},\"showTitle\":false,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"padding\":\"0px\",\"settings\":{\"labelPosition\":\"top\",\"layout\":\"horizontal\",\"showLabel\":true,\"labelFont\":{\"family\":\"Roboto\",\"size\":16,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"labelColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showIcon\":true,\"iconSize\":40,\"iconSizeUnit\":\"px\",\"icon\":\"thermostat\",\"iconColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":-20,\"color\":\"#234CC7\"},{\"from\":-20,\"to\":0,\"color\":\"#305AD7\"},{\"from\":0,\"to\":10,\"color\":\"#7191EF\"},{\"from\":10,\"to\":20,\"color\":\"#FFA600\"},{\"from\":20,\"to\":30,\"color\":\"#F36900\"},{\"from\":30,\"to\":40,\"color\":\"#F04022\"},{\"from\":40,\"to\":null,\"color\":\"#D81838\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"valueFont\":{\"size\":36,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\",\"rangeList\":[{\"from\":null,\"to\":-20,\"color\":\"#234CC7\"},{\"from\":-20,\"to\":0,\"color\":\"#305AD7\"},{\"from\":0,\"to\":10,\"color\":\"#7191EF\"},{\"from\":10,\"to\":20,\"color\":\"#FFA600\"},{\"from\":20,\"to\":30,\"color\":\"#F36900\"},{\"from\":30,\"to\":40,\"color\":\"#F04022\"},{\"from\":40,\"to\":null,\"color\":\"#D81838\"}]},\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"dateColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"color\",\"color\":\"#fff\",\"overlay\":{\"enabled\":false,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Horizontal temperature card\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"units\":\"°C\",\"decimals\":0,\"useDashboardTimewindow\":true,\"showLegend\":false,\"widgetStyle\":{},\"actions\":{},\"configMode\":\"basic\",\"displayTimewindow\":true,\"margin\":\"0px\",\"borderRadius\":\"0px\",\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"showTitleIcon\":false,\"titleTooltip\":\"\",\"titleFont\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1.6\"},\"titleIcon\":\"\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"iconSize\":\"14px\",\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"14px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1\"},\"color\":null}}" + }, + "externalId": null, + "tags": [ + "temperature", + "weather", + "environment", + "ground" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/horizontal_ground_temperature_card_with_background.json b/application/src/main/data/json/system/widget_types/horizontal_ground_temperature_card_with_background.json new file mode 100644 index 0000000000..fd5124632b --- /dev/null +++ b/application/src/main/data/json/system/widget_types/horizontal_ground_temperature_card_with_background.json @@ -0,0 +1,29 @@ +{ + "fqn": "horizontal_ground_temperature_card_with_background", + "name": "Horizontal ground temperature card with background", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays a latest ground temperature telemetry data in a horizontal layout with background.", + "descriptor": { + "type": "latest", + "sizeX": 5, + "sizeY": 1, + "resources": [], + "templateHtml": "\n", + "templateCss": "", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueCardWidget.onDataUpdated();\n};\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n horizontal: true,\n previewWidth: '420px',\n previewHeight: '90px',\n embedTitlePanel: true\n };\n};\n\nself.onDestroy = function() {\n};\n", + "settingsSchema": "", + "dataKeySettingsSchema": "", + "settingsDirective": "tb-value-card-widget-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"function\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Ground temperature\",\"color\":\"#2196f3\",\"settings\":{},\"_hash\":0.2392660816082064,\"funcBody\":\"var value = prevValue + Math.random() * 40 - 20;\\nif (value < -60) {\\n\\tvalue = -60;\\n} else if (value > 60) {\\n\\tvalue = 60;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]}}],\"timewindow\":{\"realtime\":{\"timewindowMs\":60000}},\"showTitle\":false,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"padding\":\"0px\",\"settings\":{\"labelPosition\":\"top\",\"layout\":\"horizontal\",\"showLabel\":true,\"labelFont\":{\"family\":\"Roboto\",\"size\":16,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"labelColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showIcon\":true,\"iconSize\":40,\"iconSizeUnit\":\"px\",\"icon\":\"thermostat\",\"iconColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":-20,\"color\":\"#224AC2\"},{\"from\":-20,\"to\":0,\"color\":\"#2B54CE\"},{\"from\":0,\"to\":10,\"color\":\"#6083EC\"},{\"from\":10,\"to\":20,\"color\":\"#F89E0D\"},{\"from\":20,\"to\":30,\"color\":\"#F77410\"},{\"from\":30,\"to\":40,\"color\":\"#F04022\"},{\"from\":40,\"to\":null,\"color\":\"#DE2343\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"valueFont\":{\"size\":36,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\",\"rangeList\":[{\"from\":null,\"to\":-20,\"color\":\"#224AC2\"},{\"from\":-20,\"to\":0,\"color\":\"#2B54CE\"},{\"from\":0,\"to\":10,\"color\":\"#6083EC\"},{\"from\":10,\"to\":20,\"color\":\"#F89E0D\"},{\"from\":20,\"to\":30,\"color\":\"#F77410\"},{\"from\":30,\"to\":40,\"color\":\"#F04022\"},{\"from\":40,\"to\":null,\"color\":\"#DE2343\"}]},\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"dateColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"image\",\"imageBase64\":\"data:image/png;base64,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\",\"imageUrl\":null,\"color\":\"#fff\",\"overlay\":{\"enabled\":true,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Horizontal temperature card with background\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"units\":\"°C\",\"decimals\":0,\"useDashboardTimewindow\":true,\"showLegend\":false,\"widgetStyle\":{},\"actions\":{},\"configMode\":\"basic\",\"displayTimewindow\":true,\"margin\":\"0px\",\"borderRadius\":\"0px\",\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"showTitleIcon\":false,\"titleTooltip\":\"\",\"titleFont\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1.6\"},\"titleIcon\":\"\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"iconSize\":\"14px\",\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"14px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1\"},\"color\":null}}" + }, + "externalId": null, + "tags": [ + "temperature", + "weather", + "environment", + "ground" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/simple_ground_temperature_chart_card.json b/application/src/main/data/json/system/widget_types/simple_ground_temperature_chart_card.json new file mode 100644 index 0000000000..01567fb8a7 --- /dev/null +++ b/application/src/main/data/json/system/widget_types/simple_ground_temperature_chart_card.json @@ -0,0 +1,32 @@ +{ + "fqn": "simple_ground_temperature_chart_card", + "name": "Simple ground temperature chart card", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays historical ground temperature values as a simplified chart. Optionally may display the corresponding latest ground temperature value.", + "descriptor": { + "type": "timeseries", + "sizeX": 4.5, + "sizeY": 2, + "resources": [], + "templateHtml": "\n\n", + "templateCss": ".legend {\n font-size: 13px;\n line-height: 10px;\n}\n\n.legend table { \n border-spacing: 0px;\n border-collapse: separate;\n}\n\n.mouse-events .flot-overlay {\n cursor: crosshair; \n}\n\n", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueChartCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueChartCardWidget.onDataUpdated();\n};\n\nself.onLatestDataUpdated = function() {\n self.ctx.$scope.valueChartCardWidget.onLatestDataUpdated();\n}\n\nself.onEditModeChanged = function() {\n self.ctx.$scope.valueChartCardWidget.onEditModeChanged();\n}\n\nself.onDestroy = function() {\n self.ctx.$scope.valueChartCardWidget.onDestroy();\n}\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '300px',\n previewHeight: '150px',\n embedTitlePanel: true,\n hasAdditionalLatestDataKeys: true,\n defaultDataKeysFunction: function() {\n return [\n { name: 'temperature', label: 'Ground temperature', type: 'timeseries', color: 'rgba(0, 0, 0, 0.87)'}\n ];\n },\n defaultLatestDataKeysFunction: function(configComponent) {\n return [{ name: 'temperature', label: 'Latest', type: 'timeseries'}];\n }\n };\n}\n", + "settingsSchema": "{}", + "dataKeySettingsSchema": "{}", + "latestDataKeySettingsSchema": "{}", + "settingsDirective": "tb-value-chart-card-widget-settings", + "dataKeySettingsDirective": "", + "latestDataKeySettingsDirective": "", + "hasBasicMode": true, + "basicModeDirective": "tb-value-chart-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Ground temperature\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 40 - 20;\\nif (value < -60) {\\n\\tvalue = -60;\\n} else if (value > 60) {\\n\\tvalue = 60;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 40 - 20;\\nif (value < -60) {\\n\\tvalue = -60;\\n} else if (value > 60) {\\n\\tvalue = 60;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"layout\":\"left\",\"autoScale\":true,\"showValue\":true,\"valueFont\":{\"family\":\"Roboto\",\"size\":28,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\",\"lineHeight\":\"32px\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":-20,\"color\":\"#234CC7\"},{\"from\":-20,\"to\":0,\"color\":\"#305AD7\"},{\"from\":0,\"to\":10,\"color\":\"#7191EF\"},{\"from\":10,\"to\":20,\"color\":\"#FFA600\"},{\"from\":20,\"to\":30,\"color\":\"#F36900\"},{\"from\":30,\"to\":40,\"color\":\"#F04022\"},{\"from\":40,\"to\":null,\"color\":\"#D81838\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"color\",\"color\":\"#fff\",\"overlay\":{\"enabled\":false,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}}},\"title\":\"Ground temperature\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":null,\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"thermostat\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"18px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":true,\"decimals\":0,\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null,\"units\":\"°C\",\"displayTimewindow\":true,\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1697382151041,\"endTimeMs\":1697468551041},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"timewindowStyle\":{\"showIcon\":false,\"iconSize\":\"24px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":true}}" + }, + "externalId": null, + "tags": [ + "temperature", + "weather", + "environment", + "ground" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/simple_ground_temperature_chart_card_with_background.json b/application/src/main/data/json/system/widget_types/simple_ground_temperature_chart_card_with_background.json new file mode 100644 index 0000000000..6bacc358a2 --- /dev/null +++ b/application/src/main/data/json/system/widget_types/simple_ground_temperature_chart_card_with_background.json @@ -0,0 +1,32 @@ +{ + "fqn": "simple_ground_temperature_chart_card_with_background", + "name": "Simple ground temperature chart card with background", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays historical ground temperature values as a simplified chart with background. Optionally may display the corresponding latest ground temperature value.", + "descriptor": { + "type": "timeseries", + "sizeX": 4.5, + "sizeY": 2, + "resources": [], + "templateHtml": "\n\n", + "templateCss": ".legend {\n font-size: 13px;\n line-height: 10px;\n}\n\n.legend table { \n border-spacing: 0px;\n border-collapse: separate;\n}\n\n.mouse-events .flot-overlay {\n cursor: crosshair; \n}\n\n", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueChartCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueChartCardWidget.onDataUpdated();\n};\n\nself.onLatestDataUpdated = function() {\n self.ctx.$scope.valueChartCardWidget.onLatestDataUpdated();\n}\n\nself.onEditModeChanged = function() {\n self.ctx.$scope.valueChartCardWidget.onEditModeChanged();\n}\n\nself.onDestroy = function() {\n self.ctx.$scope.valueChartCardWidget.onDestroy();\n}\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '300px',\n previewHeight: '150px',\n embedTitlePanel: true,\n hasAdditionalLatestDataKeys: true,\n defaultDataKeysFunction: function() {\n return [\n { name: 'temperature', label: 'Ground temperature', type: 'timeseries', color: 'rgba(0, 0, 0, 0.87)'}\n ];\n },\n defaultLatestDataKeysFunction: function(configComponent) {\n return [{ name: 'temperature', label: 'Latest', type: 'timeseries'}];\n }\n };\n}\n", + "settingsSchema": "{}", + "dataKeySettingsSchema": "{}", + "latestDataKeySettingsSchema": "{}", + "settingsDirective": "tb-value-chart-card-widget-settings", + "dataKeySettingsDirective": "", + "latestDataKeySettingsDirective": "", + "hasBasicMode": true, + "basicModeDirective": "tb-value-chart-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Ground temperature\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 40 - 20;\\nif (value < -60) {\\n\\tvalue = -60;\\n} else if (value > 60) {\\n\\tvalue = 60;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 40 - 20;\\nif (value < -60) {\\n\\tvalue = -60;\\n} else if (value > 60) {\\n\\tvalue = 60;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"layout\":\"left\",\"autoScale\":true,\"showValue\":true,\"valueFont\":{\"family\":\"Roboto\",\"size\":28,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\",\"lineHeight\":\"32px\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":-20,\"color\":\"#224AC2\"},{\"from\":-20,\"to\":0,\"color\":\"#2B54CE\"},{\"from\":0,\"to\":10,\"color\":\"#6083EC\"},{\"from\":10,\"to\":20,\"color\":\"#F89E0D\"},{\"from\":20,\"to\":30,\"color\":\"#F77410\"},{\"from\":30,\"to\":40,\"color\":\"#F04022\"},{\"from\":40,\"to\":null,\"color\":\"#DE2343\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"image\",\"imageBase64\":\"data:image/png;base64,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\",\"imageUrl\":null,\"color\":\"#fff\",\"overlay\":{\"enabled\":true,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}}},\"title\":\"Ground temperature\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":null,\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"thermostat\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"18px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":true,\"decimals\":0,\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null,\"units\":\"°C\",\"displayTimewindow\":true,\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1697382151041,\"endTimeMs\":1697468551041},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"timewindowStyle\":{\"showIcon\":false,\"iconSize\":\"24px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":true}}" + }, + "externalId": null, + "tags": [ + "temperature", + "weather", + "environment", + "ground" + ] +} \ No newline at end of file From 0571f7e6ddbe62605bc703cfbecfa4c177e2411a Mon Sep 17 00:00:00 2001 From: Andrii Shvaika Date: Tue, 24 Oct 2023 12:24:01 +0300 Subject: [PATCH 30/43] Fix compatibility between CE and PE --- .../server/service/queue/ProtoUtils.java | 22 ++++++- .../server/service/queue/ProtoUtilsTest.java | 40 +++--------- common/cluster-api/src/main/proto/queue.proto | 60 +++++++++--------- .../server/common/data/EntityType.java | 63 ++++++++++--------- .../msg/plugin/ComponentLifecycleMsg.java | 2 + 5 files changed, 98 insertions(+), 89 deletions(-) diff --git a/application/src/main/java/org/thingsboard/server/service/queue/ProtoUtils.java b/application/src/main/java/org/thingsboard/server/service/queue/ProtoUtils.java index 3406265747..e39949e891 100644 --- a/application/src/main/java/org/thingsboard/server/service/queue/ProtoUtils.java +++ b/application/src/main/java/org/thingsboard/server/service/queue/ProtoUtils.java @@ -15,33 +15,51 @@ */ package org.thingsboard.server.service.queue; +import org.thingsboard.server.common.data.EntityType; import org.thingsboard.server.common.data.id.EntityIdFactory; import org.thingsboard.server.common.data.id.TenantId; import org.thingsboard.server.common.data.plugin.ComponentLifecycleEvent; import org.thingsboard.server.common.msg.plugin.ComponentLifecycleMsg; import org.thingsboard.server.gen.transport.TransportProtos; +import java.util.Arrays; import java.util.UUID; public class ProtoUtils { + private static final EntityType[] entityTypeByProtoNumber; + + static { + int arraySize = Arrays.stream(EntityType.values()).mapToInt(EntityType::getProtoNumber).max().orElse(0); + entityTypeByProtoNumber = new EntityType[arraySize + 1]; + Arrays.stream(EntityType.values()).forEach(entityType -> entityTypeByProtoNumber[entityType.getProtoNumber()] = entityType); + } + public static TransportProtos.ComponentLifecycleMsgProto toProto(ComponentLifecycleMsg msg) { return TransportProtos.ComponentLifecycleMsgProto.newBuilder() .setTenantIdMSB(msg.getTenantId().getId().getMostSignificantBits()) .setTenantIdLSB(msg.getTenantId().getId().getLeastSignificantBits()) - .setEntityType(TransportProtos.EntityType.forNumber(msg.getEntityId().getEntityType().ordinal())) + .setEntityType(toProto(msg.getEntityId().getEntityType())) .setEntityIdMSB(msg.getEntityId().getId().getMostSignificantBits()) .setEntityIdLSB(msg.getEntityId().getId().getLeastSignificantBits()) .setEvent(TransportProtos.ComponentLifecycleEvent.forNumber(msg.getEvent().ordinal())) .build(); } + public static TransportProtos.EntityTypeProto toProto(EntityType entityType) { + return TransportProtos.EntityTypeProto.forNumber(entityType.getProtoNumber()); + } + public static ComponentLifecycleMsg fromProto(TransportProtos.ComponentLifecycleMsgProto proto) { return new ComponentLifecycleMsg( TenantId.fromUUID(new UUID(proto.getTenantIdMSB(), proto.getTenantIdLSB())), - EntityIdFactory.getByTypeAndUuid(proto.getEntityTypeValue(), new UUID(proto.getEntityIdMSB(), proto.getEntityIdLSB())), + EntityIdFactory.getByTypeAndUuid(fromProto(proto.getEntityType()), new UUID(proto.getEntityIdMSB(), proto.getEntityIdLSB())), ComponentLifecycleEvent.values()[proto.getEventValue()] ); } + public static EntityType fromProto(TransportProtos.EntityTypeProto entityType) { + return entityTypeByProtoNumber[entityType.getNumber()]; + } + } diff --git a/application/src/test/java/org/thingsboard/server/service/queue/ProtoUtilsTest.java b/application/src/test/java/org/thingsboard/server/service/queue/ProtoUtilsTest.java index c63055a6f1..e235076635 100644 --- a/application/src/test/java/org/thingsboard/server/service/queue/ProtoUtilsTest.java +++ b/application/src/test/java/org/thingsboard/server/service/queue/ProtoUtilsTest.java @@ -16,6 +16,7 @@ package org.thingsboard.server.service.queue; import org.junit.jupiter.api.Test; +import org.thingsboard.server.common.data.EntityType; import org.thingsboard.server.common.data.id.EntityId; import org.thingsboard.server.common.data.id.RuleChainId; import org.thingsboard.server.common.data.id.TenantId; @@ -31,41 +32,18 @@ class ProtoUtilsTest { TenantId tenantId = TenantId.fromUUID(UUID.fromString("35e10f77-16e7-424d-ae46-ee780f87ac4f")); EntityId entityId = new RuleChainId(UUID.fromString("c640b635-4f0f-41e6-b10b-25a86003094e")); @Test - void toProtoComponentLifecycleMsg() { + void protoComponentLifecycleSerialization() { ComponentLifecycleMsg msg = new ComponentLifecycleMsg(tenantId, entityId, ComponentLifecycleEvent.UPDATED); - - TransportProtos.ComponentLifecycleMsgProto proto = ProtoUtils.toProto(msg); - - assertThat(proto).as("to proto").isEqualTo(TransportProtos.ComponentLifecycleMsgProto.newBuilder() - .setTenantIdMSB(tenantId.getId().getMostSignificantBits()) - .setTenantIdLSB(tenantId.getId().getLeastSignificantBits()) - .setEntityType(TransportProtos.EntityType.forNumber(entityId.getEntityType().ordinal())) - .setEntityIdMSB(entityId.getId().getMostSignificantBits()) - .setEntityIdLSB(entityId.getId().getLeastSignificantBits()) - .setEvent(TransportProtos.ComponentLifecycleEvent.forNumber(ComponentLifecycleEvent.UPDATED.ordinal())) - .build() - ); - - assertThat(ProtoUtils.fromProto(proto)).as("from proto").isEqualTo(msg); + assertThat(ProtoUtils.fromProto(ProtoUtils.toProto(msg))).as("deserialized").isEqualTo(msg); + msg = new ComponentLifecycleMsg(tenantId, entityId, ComponentLifecycleEvent.STARTED); + assertThat(ProtoUtils.fromProto(ProtoUtils.toProto(msg))).as("deserialized").isEqualTo(msg); } @Test - void fromProtoComponentLifecycleMsg() { - TransportProtos.ComponentLifecycleMsgProto proto = TransportProtos.ComponentLifecycleMsgProto.newBuilder() - .setTenantIdMSB(tenantId.getId().getMostSignificantBits()) - .setTenantIdLSB(tenantId.getId().getLeastSignificantBits()) - .setEntityType(TransportProtos.EntityType.forNumber(entityId.getEntityType().ordinal())) - .setEntityIdMSB(entityId.getId().getMostSignificantBits()) - .setEntityIdLSB(entityId.getId().getLeastSignificantBits()) - .setEvent(TransportProtos.ComponentLifecycleEvent.forNumber(ComponentLifecycleEvent.STARTED.ordinal())) - .build(); - - ComponentLifecycleMsg msg = ProtoUtils.fromProto(proto); - - assertThat(msg).as("from proto").isEqualTo( - new ComponentLifecycleMsg(tenantId, entityId, ComponentLifecycleEvent.STARTED)); - - assertThat(ProtoUtils.toProto(msg)).as("to proto").isEqualTo(proto); + void protoEntityTypeSerialization() { + for(EntityType entityType : EntityType.values()){ + assertThat(ProtoUtils.fromProto(ProtoUtils.toProto(entityType))).as(entityType.getNormalName()).isEqualTo(entityType); + } } } \ No newline at end of file diff --git a/common/cluster-api/src/main/proto/queue.proto b/common/cluster-api/src/main/proto/queue.proto index d8439d0cd0..e560dfccf5 100644 --- a/common/cluster-api/src/main/proto/queue.proto +++ b/common/cluster-api/src/main/proto/queue.proto @@ -23,33 +23,37 @@ option java_outer_classname = "TransportProtos"; /** * Common data structures */ -enum EntityType { - TENANT = 0; - CUSTOMER = 1; - USER = 2; - DASHBOARD = 3; - ASSET = 4; - DEVICE = 5; - ALARM = 6; - RULE_CHAIN = 7; - RULE_NODE = 8; - ENTITY_VIEW = 9; - WIDGETS_BUNDLE = 10; - WIDGET_TYPE = 11; - TENANT_PROFILE = 12; - DEVICE_PROFILE = 13; - ASSET_PROFILE = 14; - API_USAGE_STATE = 15; - TB_RESOURCE = 16; - OTA_PACKAGE = 17; - EDGE = 18; - RPC = 19; - QUEUE = 20; - NOTIFICATION_TARGET = 21; - NOTIFICATION_TEMPLATE = 22; - NOTIFICATION_REQUEST = 23; - NOTIFICATION = 24; - NOTIFICATION_RULE = 25; +enum EntityTypeProto { + UNSPECIFIED = 0; + TENANT = 1; + CUSTOMER = 2; + USER = 3; + DASHBOARD = 4; + ASSET = 5; + DEVICE = 6; + ALARM = 7; + // next 2 reserved for PE; + RULE_CHAIN = 10; + RULE_NODE = 11; + // next 2 reserved for PE; + ENTITY_VIEW = 14; + WIDGETS_BUNDLE = 15; + WIDGET_TYPE = 16; + // next 2 reserved for PE; + TENANT_PROFILE = 19; + DEVICE_PROFILE = 20; + ASSET_PROFILE = 21; + API_USAGE_STATE = 22; + TB_RESOURCE = 23; + OTA_PACKAGE = 24; + EDGE = 25; + RPC = 26; + QUEUE = 27; + NOTIFICATION_TARGET = 28; + NOTIFICATION_TEMPLATE = 29; + NOTIFICATION_REQUEST = 30; + NOTIFICATION = 31; + NOTIFICATION_RULE = 32; } /** @@ -776,7 +780,7 @@ enum ComponentLifecycleEvent { message ComponentLifecycleMsgProto { int64 tenantIdMSB = 1; int64 tenantIdLSB = 2; - EntityType entityType = 3; + EntityTypeProto entityType = 3; int64 entityIdMSB = 4; int64 entityIdLSB = 5; ComponentLifecycleEvent event = 6; diff --git a/common/data/src/main/java/org/thingsboard/server/common/data/EntityType.java b/common/data/src/main/java/org/thingsboard/server/common/data/EntityType.java index c4344e8789..c755659966 100644 --- a/common/data/src/main/java/org/thingsboard/server/common/data/EntityType.java +++ b/common/data/src/main/java/org/thingsboard/server/common/data/EntityType.java @@ -26,39 +26,46 @@ import java.util.stream.Collectors; * @author Andrew Shvayka */ public enum EntityType { - // In sync with EntityType proto - TENANT, - CUSTOMER, - USER, - DASHBOARD, - ASSET, - DEVICE, - ALARM, - RULE_CHAIN, - RULE_NODE, - ENTITY_VIEW { + TENANT(1), + CUSTOMER(2), + USER(3), + DASHBOARD(4), + ASSET(5), + DEVICE(6), + ALARM (7), + RULE_CHAIN (10), + RULE_NODE (11), + + ENTITY_VIEW (14) { // backward compatibility for TbOriginatorTypeSwitchNode to return correct rule node connection. @Override - public String getNormalName() { + public String getNormalName () { return "Entity View"; } }, - WIDGETS_BUNDLE, - WIDGET_TYPE, - TENANT_PROFILE, - DEVICE_PROFILE, - ASSET_PROFILE, - API_USAGE_STATE, - TB_RESOURCE, - OTA_PACKAGE, - EDGE, - RPC, - QUEUE, - NOTIFICATION_TARGET, - NOTIFICATION_TEMPLATE, - NOTIFICATION_REQUEST, - NOTIFICATION, - NOTIFICATION_RULE; + WIDGETS_BUNDLE (15), + WIDGET_TYPE (16), + TENANT_PROFILE (19), + DEVICE_PROFILE (20), + ASSET_PROFILE (21), + API_USAGE_STATE (22), + TB_RESOURCE (23), + OTA_PACKAGE (24), + EDGE (25), + RPC (26), + QUEUE (27), + NOTIFICATION_TARGET (28), + NOTIFICATION_TEMPLATE (29), + NOTIFICATION_REQUEST (30), + NOTIFICATION (31), + NOTIFICATION_RULE (32); + + @Getter + private final int protoNumber; // Corresponds to EntityTypeProto + + private EntityType(int protoNumber) { + this.protoNumber = protoNumber; + } public static final List NORMAL_NAMES = EnumSet.allOf(EntityType.class).stream() .map(EntityType::getNormalName).collect(Collectors.toUnmodifiableList()); diff --git a/common/message/src/main/java/org/thingsboard/server/common/msg/plugin/ComponentLifecycleMsg.java b/common/message/src/main/java/org/thingsboard/server/common/msg/plugin/ComponentLifecycleMsg.java index f110a6f209..f293b5dc24 100644 --- a/common/message/src/main/java/org/thingsboard/server/common/msg/plugin/ComponentLifecycleMsg.java +++ b/common/message/src/main/java/org/thingsboard/server/common/msg/plugin/ComponentLifecycleMsg.java @@ -32,6 +32,8 @@ import java.util.Optional; */ @Data public class ComponentLifecycleMsg implements TenantAwareMsg, ToAllNodesMsg { + private static final long serialVersionUID = -5303421482781273062L; + private final TenantId tenantId; private final EntityId entityId; private final ComponentLifecycleEvent event; From b2098fc11258fd37af36057b2f308cb8eadc0345 Mon Sep 17 00:00:00 2001 From: Andrii Shvaika Date: Tue, 24 Oct 2023 12:30:17 +0300 Subject: [PATCH 31/43] Fix compatibility between CE and PE --- common/cluster-api/src/main/proto/queue.proto | 40 +++++++++---------- .../server/common/data/EntityType.java | 38 +++++++++--------- 2 files changed, 39 insertions(+), 39 deletions(-) diff --git a/common/cluster-api/src/main/proto/queue.proto b/common/cluster-api/src/main/proto/queue.proto index e560dfccf5..8202f1c749 100644 --- a/common/cluster-api/src/main/proto/queue.proto +++ b/common/cluster-api/src/main/proto/queue.proto @@ -32,28 +32,28 @@ enum EntityTypeProto { ASSET = 5; DEVICE = 6; ALARM = 7; + // next 3 reserved for PE; + RULE_CHAIN = 11; + RULE_NODE = 12; // next 2 reserved for PE; - RULE_CHAIN = 10; - RULE_NODE = 11; + ENTITY_VIEW = 15; + WIDGETS_BUNDLE = 16; + WIDGET_TYPE = 17; // next 2 reserved for PE; - ENTITY_VIEW = 14; - WIDGETS_BUNDLE = 15; - WIDGET_TYPE = 16; - // next 2 reserved for PE; - TENANT_PROFILE = 19; - DEVICE_PROFILE = 20; - ASSET_PROFILE = 21; - API_USAGE_STATE = 22; - TB_RESOURCE = 23; - OTA_PACKAGE = 24; - EDGE = 25; - RPC = 26; - QUEUE = 27; - NOTIFICATION_TARGET = 28; - NOTIFICATION_TEMPLATE = 29; - NOTIFICATION_REQUEST = 30; - NOTIFICATION = 31; - NOTIFICATION_RULE = 32; + TENANT_PROFILE = 20; + DEVICE_PROFILE = 21; + ASSET_PROFILE = 22; + API_USAGE_STATE = 23; + TB_RESOURCE = 24; + OTA_PACKAGE = 25; + EDGE = 26; + RPC = 27; + QUEUE = 28; + NOTIFICATION_TARGET = 29; + NOTIFICATION_TEMPLATE = 30; + NOTIFICATION_REQUEST = 31; + NOTIFICATION = 32; + NOTIFICATION_RULE = 33; } /** diff --git a/common/data/src/main/java/org/thingsboard/server/common/data/EntityType.java b/common/data/src/main/java/org/thingsboard/server/common/data/EntityType.java index c755659966..ce87edf43a 100644 --- a/common/data/src/main/java/org/thingsboard/server/common/data/EntityType.java +++ b/common/data/src/main/java/org/thingsboard/server/common/data/EntityType.java @@ -33,32 +33,32 @@ public enum EntityType { ASSET(5), DEVICE(6), ALARM (7), - RULE_CHAIN (10), - RULE_NODE (11), + RULE_CHAIN (11), + RULE_NODE (12), - ENTITY_VIEW (14) { + ENTITY_VIEW (15) { // backward compatibility for TbOriginatorTypeSwitchNode to return correct rule node connection. @Override public String getNormalName () { return "Entity View"; } }, - WIDGETS_BUNDLE (15), - WIDGET_TYPE (16), - TENANT_PROFILE (19), - DEVICE_PROFILE (20), - ASSET_PROFILE (21), - API_USAGE_STATE (22), - TB_RESOURCE (23), - OTA_PACKAGE (24), - EDGE (25), - RPC (26), - QUEUE (27), - NOTIFICATION_TARGET (28), - NOTIFICATION_TEMPLATE (29), - NOTIFICATION_REQUEST (30), - NOTIFICATION (31), - NOTIFICATION_RULE (32); + WIDGETS_BUNDLE (16), + WIDGET_TYPE (17), + TENANT_PROFILE (20), + DEVICE_PROFILE (21), + ASSET_PROFILE (22), + API_USAGE_STATE (23), + TB_RESOURCE (24), + OTA_PACKAGE (25), + EDGE (26), + RPC (27), + QUEUE (28), + NOTIFICATION_TARGET (29), + NOTIFICATION_TEMPLATE (30), + NOTIFICATION_REQUEST (31), + NOTIFICATION (32), + NOTIFICATION_RULE (33); @Getter private final int protoNumber; // Corresponds to EntityTypeProto From 18fcc48a6c49ba4eda1341eb7d150b025a70cbc4 Mon Sep 17 00:00:00 2001 From: Igor Kulikov Date: Tue, 24 Oct 2023 13:14:28 +0300 Subject: [PATCH 32/43] UI: Outdoor Environment: Soil moisture widgets. --- .../widget_bundles/outdoor_environment.json | 12 ++++++- .../horizontal_soil_moisture_card.json | 29 +++++++++++++++++ ...al_soil_moisture_card_with_background.json | 29 +++++++++++++++++ .../simple_soil_moisture_chart_card.json | 32 +++++++++++++++++++ ...l_moisture_chart_card_with_background.json | 32 +++++++++++++++++++ .../widget_types/soil_moisture_card.json | 29 +++++++++++++++++ .../soil_moisture_card_with_background.json | 29 +++++++++++++++++ .../soil_moisture_chart_card.json | 32 +++++++++++++++++++ ...l_moisture_chart_card_with_background.json | 32 +++++++++++++++++++ .../soil_moisture_progress_bar.json | 30 +++++++++++++++++ ...moisture_progress_bar_with_background.json | 30 +++++++++++++++++ 11 files changed, 315 insertions(+), 1 deletion(-) create mode 100644 application/src/main/data/json/system/widget_types/horizontal_soil_moisture_card.json create mode 100644 application/src/main/data/json/system/widget_types/horizontal_soil_moisture_card_with_background.json create mode 100644 application/src/main/data/json/system/widget_types/simple_soil_moisture_chart_card.json create mode 100644 application/src/main/data/json/system/widget_types/simple_soil_moisture_chart_card_with_background.json create mode 100644 application/src/main/data/json/system/widget_types/soil_moisture_card.json create mode 100644 application/src/main/data/json/system/widget_types/soil_moisture_card_with_background.json create mode 100644 application/src/main/data/json/system/widget_types/soil_moisture_chart_card.json create mode 100644 application/src/main/data/json/system/widget_types/soil_moisture_chart_card_with_background.json create mode 100644 application/src/main/data/json/system/widget_types/soil_moisture_progress_bar.json create mode 100644 application/src/main/data/json/system/widget_types/soil_moisture_progress_bar_with_background.json diff --git a/application/src/main/data/json/system/widget_bundles/outdoor_environment.json b/application/src/main/data/json/system/widget_bundles/outdoor_environment.json index c3d69318d7..2c3d0b8919 100644 --- a/application/src/main/data/json/system/widget_bundles/outdoor_environment.json +++ b/application/src/main/data/json/system/widget_bundles/outdoor_environment.json @@ -93,6 +93,16 @@ "ground_temperature_chart_card", "ground_temperature_chart_card_with_background", "simple_ground_temperature_chart_card", - "simple_ground_temperature_chart_card_with_background" + "simple_ground_temperature_chart_card_with_background", + "soil_moisture_card", + "soil_moisture_card_with_background", + "horizontal_soil_moisture_card", + "horizontal_soil_moisture_card_with_background", + "soil_moisture_chart_card", + "soil_moisture_chart_card_with_background", + "simple_soil_moisture_chart_card", + "simple_soil_moisture_chart_card_with_background", + "soil_moisture_progress_bar", + "soil_moisture_progress_bar_with_background" ] } \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/horizontal_soil_moisture_card.json b/application/src/main/data/json/system/widget_types/horizontal_soil_moisture_card.json new file mode 100644 index 0000000000..1fb4e01f9e --- /dev/null +++ b/application/src/main/data/json/system/widget_types/horizontal_soil_moisture_card.json @@ -0,0 +1,29 @@ +{ + "fqn": "horizontal_soil_moisture_card", + "name": "Horizontal soil moisture card", + "deprecated": false, + "image": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAMgAAACgCAMAAAB+IdObAAAAolBMVEUAAADf39/f39/g4ODg4ODf39/////k5OQjTMfg4ODy8vLk6fg+Ys7IyMjOzs5YWFjj4+Py9Pv5+fmRpeN1j9zV1dWsrKyQkJDb29u7u7uDmuDCwsK2trZaedUwV8t0dHTn5+eesefW3fVKSkrI0vFMbtE8PDyRpuNmZmasvOqCgoK6x+6rq6uenp7t7e2tvOoxV8rW3fRohNkhISGwsLAvLy8aKS4pAAAABnRSTlMAIEDfv1C6kOEmAAADj0lEQVR42u3aCW/aMBjGcbZ2b42P3CEXCYSrQKHXtu//1faaQQPTFCYNlbR6fhVSaquS/3UcoZYeAAAAAAAAAAAAAAAAAAAAAAAAAAAAwHv68uH1rK83dx+dd/ONO+4C+vDk3dferaRPILjt9elT6COkYxDSNQjpGoR0DUK65u8h9dynI3KbeGRlxgyIvEQSJTFZI0lMXv/92l9D7oXQihru1kyJuCWOBwmR+Z7xa0CSRzZ2XC63JPnLk/ZFl6OeZmTN6vCBDvw6VGdCmo7TEjfxPHJHrpcMdiFLl0buwJsu17Sg0dqNF27MQ8ZdbNZL17tYRilEaVdeHi9IaT0XL+0hTQc7urvkZpHwSgfrfcjIlW4yWGc09RY03cZyNPB2IUZ+H4y2l+rQonya8EUu5rNJZJus8NknHfHs7EzIROzldDAiWpgpbZN9iJtNN6NdiFyQMdOYQ6a0tCE/jfHoMiIR0s6rXbMvxD5EE5UR5frcjmhx8JacTN0RrZdT7xAif3p2E9zE3lp8M214a5YLDqHEXcZ0EUpoUqr59hBSC6V0roQ6E7ISIqorUb0KcdQs969T8nhONmMXsRLlnNfwQsxX6m1/fDuqdERnQrQtj6oJze2WXFHIJz18Fc/2qD6d3OmTCdVanQl54R+5f5hP6L752euIhP2ll6K2Sw9zzRdvVLWahKFqC5kJVtkOFtGVNGc9FPlh7c9+MxepquSHcEuI2ne81tWVd6QW+T7k6YmYFrPm+Kj8mUfylhDi9T/wfnC1vWg5wPLxzwFJlzQT2ieaixVVNkFVb88pX4cU7R7CbSGhEDq350Q3T63h4bn0mNJOEFDQd+xAnwIiGm/GFKTp7wkekJe5t3RY2kXUvKJQNzf6gx17VnxQ2kJ8LQ5WRyFx7KTGOHxVUJEWWTAsnDg2TvboZAGRM5ZZlpJ0dhOOyej/+TmvobTbwBWiCv2TyZLn/LYQUoeSmo5DnKE0ztj5HTKOU77msXHqFGYX0k9TDjHDsZGcW0i6AF8dlqrs1Smlzr3X8ldzIapoQm9+OGnhDGNTSLsjTpYWQzk0Do89ZmPjkA0J7I6Msx92Ii4KehftIeel45bJ2KT0DzoREgRtk5L+RSdCugghXYOQrkFI1yCka/q920/wb3YiecsfGLj+H27/W8AfGOh9u/HuPrqbr5/pQzUAAAAAAAAAAAAAAAAAAAAAAAAAAAAA7+QX7yoAidBTT3IAAAAASUVORK5CYII=", + "description": "Displays a latest soil moisture telemetry data in a horizontal layout.", + "descriptor": { + "type": "latest", + "sizeX": 5, + "sizeY": 1, + "resources": [], + "templateHtml": "\n", + "templateCss": "", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueCardWidget.onDataUpdated();\n};\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n horizontal: true,\n previewWidth: '420px',\n previewHeight: '90px',\n embedTitlePanel: true,\n defaultDataKeysFunction: function() {\n return [{ name: 'soilMoisture', label: 'Soil Moisture', type: 'timeseries' }];\n }\n };\n};\n\nself.onDestroy = function() {\n};\n", + "settingsSchema": "", + "dataKeySettingsSchema": "", + "settingsDirective": "tb-value-card-widget-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"function\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Soil Moisture\",\"color\":\"#2196f3\",\"settings\":{},\"_hash\":0.2392660816082064,\"funcBody\":\"var value = prevValue + Math.random() * 7;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]}}],\"timewindow\":{\"realtime\":{\"timewindowMs\":60000}},\"showTitle\":false,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"padding\":\"0px\",\"settings\":{\"labelPosition\":\"top\",\"layout\":\"horizontal\",\"showLabel\":true,\"labelFont\":{\"family\":\"Roboto\",\"size\":16,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"labelColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showIcon\":true,\"iconSize\":40,\"iconSizeUnit\":\"px\",\"icon\":\"mdi:water-percent\",\"iconColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":0,\"to\":20,\"color\":\"#D81838\"},{\"from\":20,\"to\":40,\"color\":\"#F36900\"},{\"from\":40,\"to\":60,\"color\":\"#4B70DD\"},{\"from\":60,\"to\":100,\"color\":\"#234CC7\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"valueFont\":{\"size\":36,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\",\"rangeList\":[{\"from\":0,\"to\":20,\"color\":\"#D81838\"},{\"from\":20,\"to\":40,\"color\":\"#F36900\"},{\"from\":40,\"to\":60,\"color\":\"#4B70DD\"},{\"from\":60,\"to\":100,\"color\":\"#234CC7\"}]},\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"dateColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"color\",\"color\":\"#fff\",\"overlay\":{\"enabled\":false,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Horizontal soil moisture card\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"units\":\"%\",\"decimals\":0,\"useDashboardTimewindow\":true,\"showLegend\":false,\"widgetStyle\":{},\"actions\":{},\"configMode\":\"basic\",\"displayTimewindow\":true,\"margin\":\"0px\",\"borderRadius\":\"0px\",\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"showTitleIcon\":false,\"titleTooltip\":\"\",\"titleFont\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1.6\"},\"titleIcon\":\"\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"iconSize\":\"14px\",\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"14px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1\"},\"color\":null}}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "soil", + "moisture" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/horizontal_soil_moisture_card_with_background.json b/application/src/main/data/json/system/widget_types/horizontal_soil_moisture_card_with_background.json new file mode 100644 index 0000000000..3a40804efe --- /dev/null +++ b/application/src/main/data/json/system/widget_types/horizontal_soil_moisture_card_with_background.json @@ -0,0 +1,29 @@ +{ + "fqn": "horizontal_soil_moisture_card_with_background", + "name": "Horizontal soil moisture card with background", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays a latest soil moisture telemetry data in a horizontal layout with background.", + "descriptor": { + "type": "latest", + "sizeX": 5, + "sizeY": 1, + "resources": [], + "templateHtml": "\n", + "templateCss": "", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueCardWidget.onDataUpdated();\n};\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n horizontal: true,\n previewWidth: '420px',\n previewHeight: '90px',\n embedTitlePanel: true,\n defaultDataKeysFunction: function() {\n return [{ name: 'soilMoisture', label: 'Soil Moisture', type: 'timeseries' }];\n }\n };\n};\n\nself.onDestroy = function() {\n};\n", + "settingsSchema": "", + "dataKeySettingsSchema": "", + "settingsDirective": "tb-value-card-widget-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"function\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Soil Moisture\",\"color\":\"#2196f3\",\"settings\":{},\"_hash\":0.2392660816082064,\"funcBody\":\"var value = prevValue + Math.random() * 7;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]}}],\"timewindow\":{\"realtime\":{\"timewindowMs\":60000}},\"showTitle\":false,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"padding\":\"0px\",\"settings\":{\"labelPosition\":\"top\",\"layout\":\"horizontal\",\"showLabel\":true,\"labelFont\":{\"family\":\"Roboto\",\"size\":16,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"labelColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showIcon\":true,\"iconSize\":40,\"iconSizeUnit\":\"px\",\"icon\":\"mdi:water-percent\",\"iconColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":0,\"to\":20,\"color\":\"#DE2343\"},{\"from\":20,\"to\":40,\"color\":\"#F77410\"},{\"from\":40,\"to\":60,\"color\":\"#4369DD\"},{\"from\":60,\"to\":100,\"color\":\"#224AC2\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"valueFont\":{\"size\":36,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\",\"rangeList\":[{\"from\":0,\"to\":20,\"color\":\"#DE2343\"},{\"from\":20,\"to\":40,\"color\":\"#F77410\"},{\"from\":40,\"to\":60,\"color\":\"#4369DD\"},{\"from\":60,\"to\":100,\"color\":\"#224AC2\"}]},\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"dateColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"image\",\"imageBase64\":\"data:image/png;base64,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\",\"imageUrl\":null,\"color\":\"#fff\",\"overlay\":{\"enabled\":true,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Horizontal soil moisture card\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"units\":\"%\",\"decimals\":0,\"useDashboardTimewindow\":true,\"showLegend\":false,\"widgetStyle\":{},\"actions\":{},\"configMode\":\"basic\",\"displayTimewindow\":true,\"margin\":\"0px\",\"borderRadius\":\"0px\",\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"showTitleIcon\":false,\"titleTooltip\":\"\",\"titleFont\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1.6\"},\"titleIcon\":\"\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"iconSize\":\"14px\",\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"14px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1\"},\"color\":null}}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "soil", + "moisture" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/simple_soil_moisture_chart_card.json b/application/src/main/data/json/system/widget_types/simple_soil_moisture_chart_card.json new file mode 100644 index 0000000000..b28d7eb204 --- /dev/null +++ b/application/src/main/data/json/system/widget_types/simple_soil_moisture_chart_card.json @@ -0,0 +1,32 @@ +{ + "fqn": "simple_soil_moisture_chart_card", + "name": "Simple soil moisture chart card", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays historical soil moisture values as a simplified chart. Optionally may display the corresponding latest soil moisture value.", + "descriptor": { + "type": "timeseries", + "sizeX": 4.5, + "sizeY": 2, + "resources": [], + "templateHtml": "\n\n", + "templateCss": ".legend {\n font-size: 13px;\n line-height: 10px;\n}\n\n.legend table { \n border-spacing: 0px;\n border-collapse: separate;\n}\n\n.mouse-events .flot-overlay {\n cursor: crosshair; \n}\n\n", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueChartCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueChartCardWidget.onDataUpdated();\n};\n\nself.onLatestDataUpdated = function() {\n self.ctx.$scope.valueChartCardWidget.onLatestDataUpdated();\n}\n\nself.onEditModeChanged = function() {\n self.ctx.$scope.valueChartCardWidget.onEditModeChanged();\n}\n\nself.onDestroy = function() {\n self.ctx.$scope.valueChartCardWidget.onDestroy();\n}\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '300px',\n previewHeight: '150px',\n embedTitlePanel: true,\n hasAdditionalLatestDataKeys: true,\n defaultDataKeysFunction: function() {\n return [\n { name: 'soilMoisture', label: 'Soil Moisture', type: 'timeseries', color: 'rgba(0, 0, 0, 0.87)'}\n ];\n },\n defaultLatestDataKeysFunction: function(configComponent) {\n return [{ name: 'soilMoisture', label: 'Latest', type: 'timeseries'}];\n }\n };\n}\n", + "settingsSchema": "{}", + "dataKeySettingsSchema": "{}", + "latestDataKeySettingsSchema": "{}", + "settingsDirective": "tb-value-chart-card-widget-settings", + "dataKeySettingsDirective": "", + "latestDataKeySettingsDirective": "", + "hasBasicMode": true, + "basicModeDirective": "tb-value-chart-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Soil Moisture\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 7;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 7;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"layout\":\"left\",\"autoScale\":true,\"showValue\":true,\"valueFont\":{\"family\":\"Roboto\",\"size\":28,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\",\"lineHeight\":\"32px\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":0,\"to\":20,\"color\":\"#D81838\"},{\"from\":20,\"to\":40,\"color\":\"#F36900\"},{\"from\":40,\"to\":60,\"color\":\"#4B70DD\"},{\"from\":60,\"to\":100,\"color\":\"#234CC7\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"color\",\"color\":\"#fff\",\"overlay\":{\"enabled\":false,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}}},\"title\":\"Soil Moisture\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":null,\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"mdi:water-percent\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"18px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":true,\"decimals\":0,\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null,\"units\":\"%\",\"displayTimewindow\":true,\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1697382151041,\"endTimeMs\":1697468551041},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"timewindowStyle\":{\"showIcon\":false,\"iconSize\":\"24px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":true}}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "soil", + "moisture" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/simple_soil_moisture_chart_card_with_background.json b/application/src/main/data/json/system/widget_types/simple_soil_moisture_chart_card_with_background.json new file mode 100644 index 0000000000..f520d56552 --- /dev/null +++ b/application/src/main/data/json/system/widget_types/simple_soil_moisture_chart_card_with_background.json @@ -0,0 +1,32 @@ +{ + "fqn": "simple_soil_moisture_chart_card_with_background", + "name": "Simple soil moisture chart card with background", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays historical soil moisture values as a simplified chart with background. Optionally may display the corresponding latest soil moisture value.", + "descriptor": { + "type": "timeseries", + "sizeX": 4.5, + "sizeY": 2, + "resources": [], + "templateHtml": "\n\n", + "templateCss": ".legend {\n font-size: 13px;\n line-height: 10px;\n}\n\n.legend table { \n border-spacing: 0px;\n border-collapse: separate;\n}\n\n.mouse-events .flot-overlay {\n cursor: crosshair; \n}\n\n", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueChartCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueChartCardWidget.onDataUpdated();\n};\n\nself.onLatestDataUpdated = function() {\n self.ctx.$scope.valueChartCardWidget.onLatestDataUpdated();\n}\n\nself.onEditModeChanged = function() {\n self.ctx.$scope.valueChartCardWidget.onEditModeChanged();\n}\n\nself.onDestroy = function() {\n self.ctx.$scope.valueChartCardWidget.onDestroy();\n}\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '300px',\n previewHeight: '150px',\n embedTitlePanel: true,\n hasAdditionalLatestDataKeys: true,\n defaultDataKeysFunction: function() {\n return [\n { name: 'soilMoisture', label: 'Soil Moisture', type: 'timeseries', color: 'rgba(0, 0, 0, 0.87)'}\n ];\n },\n defaultLatestDataKeysFunction: function(configComponent) {\n return [{ name: 'soilMoisture', label: 'Latest', type: 'timeseries'}];\n }\n };\n}\n", + "settingsSchema": "{}", + "dataKeySettingsSchema": "{}", + "latestDataKeySettingsSchema": "{}", + "settingsDirective": "tb-value-chart-card-widget-settings", + "dataKeySettingsDirective": "", + "latestDataKeySettingsDirective": "", + "hasBasicMode": true, + "basicModeDirective": "tb-value-chart-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Soil Moisture\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 7;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 7;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"layout\":\"left\",\"autoScale\":true,\"showValue\":true,\"valueFont\":{\"family\":\"Roboto\",\"size\":28,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\",\"lineHeight\":\"32px\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":0,\"to\":20,\"color\":\"#DE2343\"},{\"from\":20,\"to\":40,\"color\":\"#F77410\"},{\"from\":40,\"to\":60,\"color\":\"#4369DD\"},{\"from\":60,\"to\":100,\"color\":\"#224AC2\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"image\",\"imageBase64\":\"data:image/png;base64,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\",\"imageUrl\":null,\"color\":\"#fff\",\"overlay\":{\"enabled\":true,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}}},\"title\":\"Soil Moisture\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":null,\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"mdi:water-percent\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"18px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":true,\"decimals\":0,\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null,\"units\":\"%\",\"displayTimewindow\":true,\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1697382151041,\"endTimeMs\":1697468551041},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"timewindowStyle\":{\"showIcon\":false,\"iconSize\":\"24px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":true}}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "soil", + "moisture" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/soil_moisture_card.json b/application/src/main/data/json/system/widget_types/soil_moisture_card.json new file mode 100644 index 0000000000..05204d5204 --- /dev/null +++ b/application/src/main/data/json/system/widget_types/soil_moisture_card.json @@ -0,0 +1,29 @@ +{ + "fqn": "soil_moisture_card", + "name": "Soil moisture card", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays a latest soil moisture telemetry data in a box layout.", + "descriptor": { + "type": "latest", + "sizeX": 3, + "sizeY": 3, + "resources": [], + "templateHtml": "\n", + "templateCss": "", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueCardWidget.onDataUpdated();\n};\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '250px',\n previewHeight: '250px',\n embedTitlePanel: true,\n defaultDataKeysFunction: function() {\n return [{ name: 'soilMoisture', label: 'Soil Moisture', type: 'timeseries' }];\n }\n };\n};\n\nself.onDestroy = function() {\n};\n", + "settingsSchema": "", + "dataKeySettingsSchema": "", + "settingsDirective": "tb-value-card-widget-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"function\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Soil Moisture\",\"color\":\"#2196f3\",\"settings\":{},\"_hash\":0.2392660816082064,\"funcBody\":\"var value = prevValue + Math.random() * 7;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]}}],\"timewindow\":{\"realtime\":{\"timewindowMs\":60000}},\"showTitle\":false,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"padding\":\"0px\",\"settings\":{\"labelPosition\":\"top\",\"layout\":\"square\",\"showLabel\":true,\"labelFont\":{\"family\":\"Roboto\",\"size\":16,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"labelColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showIcon\":true,\"iconSize\":40,\"iconSizeUnit\":\"px\",\"icon\":\"mdi:water-percent\",\"iconColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":0,\"to\":20,\"color\":\"#D81838\"},{\"from\":20,\"to\":40,\"color\":\"#F36900\"},{\"from\":40,\"to\":60,\"color\":\"#4B70DD\"},{\"from\":60,\"to\":100,\"color\":\"#234CC7\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"valueFont\":{\"family\":\"Roboto\",\"size\":52,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\",\"rangeList\":[{\"from\":0,\"to\":20,\"color\":\"#D81838\"},{\"from\":20,\"to\":40,\"color\":\"#F36900\"},{\"from\":40,\"to\":60,\"color\":\"#4B70DD\"},{\"from\":60,\"to\":100,\"color\":\"#234CC7\"}]},\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"dateColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"color\",\"color\":\"#fff\",\"overlay\":{\"enabled\":false,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Soil moisture card\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"units\":\"%\",\"decimals\":0,\"useDashboardTimewindow\":true,\"showLegend\":false,\"widgetStyle\":{},\"actions\":{},\"configMode\":\"basic\",\"displayTimewindow\":true,\"margin\":\"0px\",\"borderRadius\":\"0px\",\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"showTitleIcon\":false,\"titleTooltip\":\"\",\"titleFont\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1.6\"},\"titleIcon\":\"\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"iconSize\":\"14px\",\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"14px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1\"},\"color\":null}}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "soil", + "moisture" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/soil_moisture_card_with_background.json b/application/src/main/data/json/system/widget_types/soil_moisture_card_with_background.json new file mode 100644 index 0000000000..ba153c1ba7 --- /dev/null +++ b/application/src/main/data/json/system/widget_types/soil_moisture_card_with_background.json @@ -0,0 +1,29 @@ +{ + "fqn": "soil_moisture_card_with_background", + "name": "Soil moisture card with background", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays a latest soil moisture telemetry data in a box layout with background.", + "descriptor": { + "type": "latest", + "sizeX": 3, + "sizeY": 3, + "resources": [], + "templateHtml": "\n", + "templateCss": "", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueCardWidget.onDataUpdated();\n};\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '250px',\n previewHeight: '250px',\n embedTitlePanel: true,\n defaultDataKeysFunction: function() {\n return [{ name: 'soilMoisture', label: 'Soil Moisture', type: 'timeseries' }];\n }\n };\n};\n\nself.onDestroy = function() {\n};\n", + "settingsSchema": "", + "dataKeySettingsSchema": "", + "settingsDirective": "tb-value-card-widget-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"function\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Soil Moisture\",\"color\":\"#2196f3\",\"settings\":{},\"_hash\":0.2392660816082064,\"funcBody\":\"var value = prevValue + Math.random() * 7;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]}}],\"timewindow\":{\"realtime\":{\"timewindowMs\":60000}},\"showTitle\":false,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"padding\":\"0px\",\"settings\":{\"labelPosition\":\"top\",\"layout\":\"square\",\"showLabel\":true,\"labelFont\":{\"family\":\"Roboto\",\"size\":16,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"labelColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showIcon\":true,\"iconSize\":40,\"iconSizeUnit\":\"px\",\"icon\":\"mdi:water-percent\",\"iconColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":0,\"to\":20,\"color\":\"#DE2343\"},{\"from\":20,\"to\":40,\"color\":\"#F77410\"},{\"from\":40,\"to\":60,\"color\":\"#4369DD\"},{\"from\":60,\"to\":100,\"color\":\"#224AC2\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"valueFont\":{\"family\":\"Roboto\",\"size\":52,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\",\"rangeList\":[{\"from\":0,\"to\":20,\"color\":\"#DE2343\"},{\"from\":20,\"to\":40,\"color\":\"#F77410\"},{\"from\":40,\"to\":60,\"color\":\"#4369DD\"},{\"from\":60,\"to\":100,\"color\":\"#224AC2\"}]},\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"dateColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"image\",\"imageBase64\":\"data:image/png;base64,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\",\"imageUrl\":null,\"color\":\"#fff\",\"overlay\":{\"enabled\":true,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Soil moisture card\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"units\":\"%\",\"decimals\":0,\"useDashboardTimewindow\":true,\"showLegend\":false,\"widgetStyle\":{},\"actions\":{},\"configMode\":\"basic\",\"displayTimewindow\":true,\"margin\":\"0px\",\"borderRadius\":\"0px\",\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"showTitleIcon\":false,\"titleTooltip\":\"\",\"titleFont\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1.6\"},\"titleIcon\":\"\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"iconSize\":\"14px\",\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"14px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1\"},\"color\":null}}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "soil", + "moisture" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/soil_moisture_chart_card.json b/application/src/main/data/json/system/widget_types/soil_moisture_chart_card.json new file mode 100644 index 0000000000..742f8cd9b4 --- /dev/null +++ b/application/src/main/data/json/system/widget_types/soil_moisture_chart_card.json @@ -0,0 +1,32 @@ +{ + "fqn": "soil_moisture_chart_card", + "name": "Soil moisture chart card", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays a soil moisture data as a combination of the latest and aggregated values. Optionally may display the corresponding historical values as a simplified chart.", + "descriptor": { + "type": "timeseries", + "sizeX": 4.5, + "sizeY": 3.5, + "resources": [], + "templateHtml": "\n\n", + "templateCss": ".legend {\n font-size: 13px;\n line-height: 10px;\n}\n\n.legend table { \n border-spacing: 0px;\n border-collapse: separate;\n}\n\n.mouse-events .flot-overlay {\n cursor: crosshair; \n}\n\n", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onDataUpdated();\n};\n\nself.onLatestDataUpdated = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onLatestDataUpdated();\n}\n\nself.onResize = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onResize();\n}\n\nself.onEditModeChanged = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onEditModeChanged();\n}\n\nself.onDestroy = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onDestroy();\n}\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '400px',\n previewHeight: '300px',\n embedTitlePanel: true,\n hasAdditionalLatestDataKeys: true,\n defaultDataKeysFunction: function() {\n return [\n { name: 'soilMoisture', label: 'Soil Moisture', type: 'timeseries', color: 'rgba(0, 0, 0, 0.87)', units: '%', decimals: 0 }\n ];\n },\n defaultLatestDataKeysFunction: function(configComponent, configData) {\n return configComponent.createDefaultAggregatedValueLatestDataKeys(configData, 'soilMoisture', '%', 0);\n }\n };\n}\n", + "settingsSchema": "{}", + "dataKeySettingsSchema": "{}", + "latestDataKeySettingsSchema": "{}", + "settingsDirective": "tb-aggregated-value-card-widget-settings", + "dataKeySettingsDirective": "", + "latestDataKeySettingsDirective": "tb-aggregated-value-card-key-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-aggregated-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"Main building\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Soil Moisture\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{\"showLines\":true,\"fillLines\":true,\"showPoints\":false},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 7;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"#4caf50\",\"settings\":{\"position\":\"center\",\"font\":{\"size\":52,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"1\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":0,\"to\":20,\"color\":\"#D81838\"},{\"from\":20,\"to\":40,\"color\":\"#F36900\"},{\"from\":40,\"to\":60,\"color\":\"#4B70DD\"},{\"from\":60,\"to\":100,\"color\":\"#234CC7\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.9408410830697858,\"funcBody\":\"var value = prevValue + Math.random() * 7;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta percent\",\"color\":\"#f44336\",\"settings\":{\"position\":\"rightTop\",\"font\":{\"size\":14,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"20px\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[{\"from\":null,\"to\":0,\"color\":\"#198038\"},{\"from\":0,\"to\":0,\"color\":\"rgba(0, 0, 0, 0.87)\"},{\"from\":0,\"to\":null,\"color\":\"#D12730\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":true},\"_hash\":0.06392321853157967,\"funcBody\":\"var value = prevValue + Math.random() * 6 - 3;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < -25) {\\n\\tvalue = -25;\\n} else if (value > 25) {\\n\\tvalue = 25;\\n} \\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta absolute\",\"color\":\"#607d8b\",\"settings\":{\"position\":\"rightBottom\",\"font\":{\"size\":11,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.44695098620509865,\"funcBody\":\"var value = prevValue + Math.random() * 4 - 2;\\nif (value < -6) {\\n\\tvalue = -6;\\n} else if (value > 6) {\\n\\tvalue = 6;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":1,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1691927717318,\"endTimeMs\":1692014117318},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"stack\":false,\"fontSize\":10,\"fontColor\":\"#545454\",\"showTooltip\":true,\"tooltipIndividual\":false,\"tooltipCumulative\":false,\"hideZeros\":false,\"grid\":{\"verticalLines\":true,\"horizontalLines\":true,\"outlineWidth\":1,\"color\":\"#545454\",\"backgroundColor\":null,\"tickColor\":\"#DDDDDD\"},\"xaxis\":{\"title\":null,\"showLabels\":true,\"color\":\"#545454\"},\"yaxis\":{\"min\":null,\"max\":null,\"title\":null,\"showLabels\":true,\"color\":\"#545454\",\"tickSize\":null,\"tickDecimals\":0,\"ticksFormatter\":\"\"},\"shadowSize\":4,\"smoothLines\":false,\"comparisonEnabled\":false,\"xaxisSecond\":{\"axisPosition\":\"top\",\"title\":null,\"showLabels\":true},\"showLegend\":true,\"legendConfig\":{\"direction\":\"column\",\"position\":\"bottom\",\"sortDataKeys\":false,\"showMin\":false,\"showMax\":false,\"showAvg\":true,\"showTotal\":false,\"showLatest\":false},\"customLegendEnabled\":false,\"showSubtitle\":true,\"subtitle\":\"${entityName}\",\"subtitleFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"subtitleColor\":\"rgba(0, 0, 0, 0.38)\",\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"dateColor\":\"rgba(0, 0, 0, 0.38)\",\"showChart\":true,\"chartColor\":\"rgba(0, 0, 0, 0.87)\",\"background\":{\"type\":\"color\",\"color\":\"#fff\",\"overlay\":{\"enabled\":false,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Soil Moisture\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"mdi:water-percent\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"24px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":false,\"displayTimewindow\":true,\"decimals\":0,\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"24px\",\"icon\":null,\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":false},\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "soil", + "moisture" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/soil_moisture_chart_card_with_background.json b/application/src/main/data/json/system/widget_types/soil_moisture_chart_card_with_background.json new file mode 100644 index 0000000000..60624f716a --- /dev/null +++ b/application/src/main/data/json/system/widget_types/soil_moisture_chart_card_with_background.json @@ -0,0 +1,32 @@ +{ + "fqn": "soil_moisture_chart_card_with_background", + "name": "Soil moisture chart card with background", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays a soil moisture data as a combination of the latest and aggregated values with background. Optionally may display the corresponding historical values as a simplified chart.", + "descriptor": { + "type": "timeseries", + "sizeX": 4.5, + "sizeY": 3.5, + "resources": [], + "templateHtml": "\n\n", + "templateCss": ".legend {\n font-size: 13px;\n line-height: 10px;\n}\n\n.legend table { \n border-spacing: 0px;\n border-collapse: separate;\n}\n\n.mouse-events .flot-overlay {\n cursor: crosshair; \n}\n\n", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onDataUpdated();\n};\n\nself.onLatestDataUpdated = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onLatestDataUpdated();\n}\n\nself.onResize = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onResize();\n}\n\nself.onEditModeChanged = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onEditModeChanged();\n}\n\nself.onDestroy = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onDestroy();\n}\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '400px',\n previewHeight: '300px',\n embedTitlePanel: true,\n hasAdditionalLatestDataKeys: true,\n defaultDataKeysFunction: function() {\n return [\n { name: 'soilMoisture', label: 'Soil Moisture', type: 'timeseries', color: 'rgba(0, 0, 0, 0.87)', units: '%', decimals: 0 }\n ];\n },\n defaultLatestDataKeysFunction: function(configComponent, configData) {\n return configComponent.createDefaultAggregatedValueLatestDataKeys(configData, 'soilMoisture', '%', 0);\n }\n };\n}\n", + "settingsSchema": "{}", + "dataKeySettingsSchema": "{}", + "latestDataKeySettingsSchema": "{}", + "settingsDirective": "tb-aggregated-value-card-widget-settings", + "dataKeySettingsDirective": "", + "latestDataKeySettingsDirective": "tb-aggregated-value-card-key-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-aggregated-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"Main building\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Soil Moisture\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{\"showLines\":true,\"fillLines\":true,\"showPoints\":false},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 7;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"#4caf50\",\"settings\":{\"position\":\"center\",\"font\":{\"size\":52,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"1\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":0,\"to\":20,\"color\":\"#DE2343\"},{\"from\":20,\"to\":40,\"color\":\"#F77410\"},{\"from\":40,\"to\":60,\"color\":\"#4369DD\"},{\"from\":60,\"to\":100,\"color\":\"#224AC2\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.9408410830697858,\"funcBody\":\"var value = prevValue + Math.random() * 7;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta percent\",\"color\":\"#f44336\",\"settings\":{\"position\":\"rightTop\",\"font\":{\"size\":14,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"20px\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[{\"from\":null,\"to\":0,\"color\":\"#198038\"},{\"from\":0,\"to\":0,\"color\":\"rgba(0, 0, 0, 0.87)\"},{\"from\":0,\"to\":null,\"color\":\"#D12730\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":true},\"_hash\":0.06392321853157967,\"funcBody\":\"var value = prevValue + Math.random() * 6 - 3;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < -25) {\\n\\tvalue = -25;\\n} else if (value > 25) {\\n\\tvalue = 25;\\n} \\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta absolute\",\"color\":\"#607d8b\",\"settings\":{\"position\":\"rightBottom\",\"font\":{\"size\":11,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.44695098620509865,\"funcBody\":\"var value = prevValue + Math.random() * 4 - 2;\\nif (value < -6) {\\n\\tvalue = -6;\\n} else if (value > 6) {\\n\\tvalue = 6;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":1,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1691927717318,\"endTimeMs\":1692014117318},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"stack\":false,\"fontSize\":10,\"fontColor\":\"#545454\",\"showTooltip\":true,\"tooltipIndividual\":false,\"tooltipCumulative\":false,\"hideZeros\":false,\"grid\":{\"verticalLines\":true,\"horizontalLines\":true,\"outlineWidth\":1,\"color\":\"#545454\",\"backgroundColor\":null,\"tickColor\":\"#DDDDDD\"},\"xaxis\":{\"title\":null,\"showLabels\":true,\"color\":\"#545454\"},\"yaxis\":{\"min\":null,\"max\":null,\"title\":null,\"showLabels\":true,\"color\":\"#545454\",\"tickSize\":null,\"tickDecimals\":0,\"ticksFormatter\":\"\"},\"shadowSize\":4,\"smoothLines\":false,\"comparisonEnabled\":false,\"xaxisSecond\":{\"axisPosition\":\"top\",\"title\":null,\"showLabels\":true},\"showLegend\":true,\"legendConfig\":{\"direction\":\"column\",\"position\":\"bottom\",\"sortDataKeys\":false,\"showMin\":false,\"showMax\":false,\"showAvg\":true,\"showTotal\":false,\"showLatest\":false},\"customLegendEnabled\":false,\"showSubtitle\":true,\"subtitle\":\"${entityName}\",\"subtitleFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"subtitleColor\":\"rgba(0, 0, 0, 0.38)\",\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"dateColor\":\"rgba(0, 0, 0, 0.38)\",\"showChart\":true,\"chartColor\":\"rgba(0, 0, 0, 0.87)\",\"background\":{\"type\":\"image\",\"imageBase64\":\"data:image/png;base64,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\",\"imageUrl\":null,\"color\":\"#fff\",\"overlay\":{\"enabled\":true,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Soil Moisture\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"mdi:water-percent\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"24px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":false,\"displayTimewindow\":true,\"decimals\":0,\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"24px\",\"icon\":null,\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":false},\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "soil", + "moisture" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/soil_moisture_progress_bar.json b/application/src/main/data/json/system/widget_types/soil_moisture_progress_bar.json new file mode 100644 index 0000000000..946390b231 --- /dev/null +++ b/application/src/main/data/json/system/widget_types/soil_moisture_progress_bar.json @@ -0,0 +1,30 @@ +{ + "fqn": "soil_moisture_progress_bar", + "name": "Soil moisture progress bar", + "deprecated": false, + "image": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAMgAAACgCAMAAAB+IdObAAAAq1BMVEXg4ODf39/g4OAAAADg4ODf39/////g4OAjTMf19fUhISHk5OQ9PT1YWFh0dHTx8fGsrKzk6fgvLy/Hx8e6urqQkJDI0vF1j9xaeNXv7++enp7y9PutvOrV1dU+Ys6GhoaDmt+Xl5cwV8vW3fX39/efsee5ubmpqamCgoLLy8tmZmZKSkq6x+2RpeNLbdGRpuPCwsKOjo7c3NxohNl+fn51dXXU1NSxsbHb4O/m3dkHAAAABnRSTlPvIL8Ar7DvmsykAAAEw0lEQVR42uzPwREAQAQDwDiGp7f+G702wmQ7WLg91HZhDsPkeg1DdB4wD5Un4EqkFCGjCBtF2CjCRhE2irBRhI0in9062JUVhMEAvOvib6GkyIaErTHj+7/fpeKNnmPOLMks5l8wENH0i3Tip+UL+bR8IZ+WdxBNpSx0T4pMCXEs1nRezCnRFY6JZuc9hAU9wnTlhfWCBCCTRwC60rDTlVLpTeZABEW1INxtjX5ANv/NuEF8rXQFQm8yBwLzcRftgBIL+2kqfIfIsSNCDsgaNz9rWpJrtpiYWoGVNl5LLUqptK3PtY7H0RyIodLIYhBY85rzHbL1JSleDtEdZn6JEYg6YIfoKoCs47UImAIMgXg8bhokAVK5T1SMqZnpb0iz4NtWhxQU76F0QNRL31BpGG6QV24kyNQQpkGII4CotHjpjnhAXlAKQg7ZweTlDYhZJmV9Qpr31It8v86CeJIgUEEl6mP6DckZlfsSOIv10SF+n4VED4hrF4zwJEgruY9q0IRyQNYHhCxs4ANi5ruxDwjpGgXLH5CQPDoJkhFGy+uYCfgJ8aYmAsbKrx2QHBcvOJ4Gwx2isG5gpUkQ78ya+uCzmCIiPSEKpAHJkFoNfPaIpCUiuaG28/7/ENoQUpV5za7RAIvqs9H1T8goDRjtBMnn328TwPxAVqAQCxDkhBwSIPAsiIdZT9SYvA8zPW9VHqs/t36/fr+Qf+zPMQrAIBTA0O3zVxcpFErRA3j/21Wws64Z8qasYXOExhEaR2gcoXGExhEaR2gcoXGExhEaR2gcoXGExhEaR2gcoXGExhGa80gp8btrrUF1GOlvyywrr5yeEUz7kZHTGuktlyuQ5sj242O/jlkbhoEwDG/Hl/EWSaBDCLvabGXwkv//yyo7anBbEBhjuBA9WzLlRb5TPMSJaRWA6IkDoPPxaoUwEJiexnoUE2BJo1aIA5gqL2K2uDcM2X4zG+NpxwCRNGqETEByKO67uICB6xmRKo2QGT8SbaILwDDSxmY3kiKNEAsMJSEB8HVmioVpZRyZhVjPLm6HSD2ZRCsjyQJhqzKWRkd2Ii3aIUyF2S8qqcPuwxSjKFpg7ZDx/8YdEGjFc2LHpEYjJAHy2rjGWlNv+OFVKmZW82w1QjzgXrMi9Vi4fllw5iBZSIdGCC1AZH8HQqkagDuTCWvVU2CZadIyJq0QH1DUq0NQOXpKM0kk0XLPt0KILYp68bHbouZfpUvQMu+NkPpS6Pcf+G+qmj8qH/TO/iZ6iDY9RJseok0P0aaHaNNDtPmAEHa4Rn7cTjgeknEVdybk63AIrnM743CIw1XymY7jJ8IZ13CPMx0fvLXeTA/Rpod8t3fHLAzCQBiGY20/EYcuWc7lOBDELYrV///PWkvmQlxypvdC9nvIcONpyyDa+gEJs3hkbggjABIRigOlQ4gJsiBrLe8MYAyYBAsPtFI6ZOsBn/1L6IAwoV0RdmCc0iHTqAby+j7vDaIFwgSsCCchtLboN2QtQmTBJlgE4C4dAs+zIG8R0rEcgn2e/amFOAzQEsWB/nuzXyuDaMsg2jKItgyiLYNoyyDaMoi2DKItg2jLINoqCOJQRI27FXB6Gng+XOUKOD5NH0Zd3Zur525V/QaCIDJe0ogfNAAAAABJRU5ErkJggg==", + "description": "Displays soil moisture reading as a horizontal progress bar. Allows to configure value range, bar colors, and other settings.", + "descriptor": { + "type": "latest", + "sizeX": 3, + "sizeY": 2, + "resources": [], + "templateHtml": "\n", + "templateCss": "", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.progressBarWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.progressBarWidget.onDataUpdated();\n};\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '280px',\n previewHeight: '180px',\n embedTitlePanel: true,\n defaultDataKeysFunction: function() {\n return [{ name: 'soilMoisture', label: 'Soil Moisture', type: 'timeseries' }];\n }\n };\n};\n\n\nself.onDestroy = function() {\n};\n", + "settingsSchema": "", + "dataKeySettingsSchema": "", + "settingsDirective": "tb-progress-bar-widget-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-progress-bar-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"function\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Soil Moisture\",\"color\":\"#2196f3\",\"settings\":{},\"_hash\":0.2392660816082064,\"funcBody\":\"var value = prevValue + Math.random() * 7;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]}}],\"timewindow\":{\"realtime\":{\"timewindowMs\":60000}},\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"padding\":\"0px\",\"settings\":{\"layout\":\"default\",\"autoScale\":true,\"showValue\":true,\"valueFont\":{\"family\":\"Roboto\",\"size\":24,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\",\"lineHeight\":\"32px\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":0,\"to\":20,\"color\":\"#D81838\"},{\"from\":20,\"to\":40,\"color\":\"#F36900\"},{\"from\":40,\"to\":60,\"color\":\"#4B70DD\"},{\"from\":60,\"to\":100,\"color\":\"#234CC7\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"tickMin\":0,\"tickMax\":100,\"showTicks\":true,\"ticksFont\":{\"family\":\"Roboto\",\"size\":11,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"ticksColor\":\"rgba(0,0,0,0.54)\",\"background\":{\"type\":\"color\",\"color\":\"#fff\",\"overlay\":{\"enabled\":false,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"barColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\",\"rangeList\":[{\"from\":0,\"to\":20,\"color\":\"#D81838\"},{\"from\":20,\"to\":40,\"color\":\"#F36900\"},{\"from\":40,\"to\":60,\"color\":\"#4B70DD\"},{\"from\":60,\"to\":100,\"color\":\"#234CC7\"}]},\"barBackground\":\"rgba(0, 0, 0, 0.04)\"},\"title\":\"Soil Moisture\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"units\":\"%\",\"decimals\":0,\"useDashboardTimewindow\":true,\"showLegend\":false,\"widgetStyle\":{},\"actions\":{},\"configMode\":\"basic\",\"displayTimewindow\":true,\"margin\":\"0px\",\"borderRadius\":\"0px\",\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"showTitleIcon\":false,\"titleTooltip\":\"\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"titleIcon\":\"mdi:water-percent\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"iconSize\":\"18px\",\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"14px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1\"},\"color\":null},\"titleColor\":\"rgba(0, 0, 0, 0.87)\"}" + }, + "externalId": null, + "tags": [ + "progress", + "weather", + "environment", + "soil", + "moisture" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/soil_moisture_progress_bar_with_background.json b/application/src/main/data/json/system/widget_types/soil_moisture_progress_bar_with_background.json new file mode 100644 index 0000000000..5747df6085 --- /dev/null +++ b/application/src/main/data/json/system/widget_types/soil_moisture_progress_bar_with_background.json @@ -0,0 +1,30 @@ +{ + "fqn": "soil_moisture_progress_bar_with_background", + "name": "Soil moisture progress bar with background", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays soil moisture reading as a horizontal progress bar with background. Allows to configure value range, bar colors, and other settings.", + "descriptor": { + "type": "latest", + "sizeX": 3, + "sizeY": 2, + "resources": [], + "templateHtml": "\n", + "templateCss": "", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.progressBarWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.progressBarWidget.onDataUpdated();\n};\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '280px',\n previewHeight: '180px',\n embedTitlePanel: true,\n defaultDataKeysFunction: function() {\n return [{ name: 'soilMoisture', label: 'Soil Moisture', type: 'timeseries' }];\n }\n };\n};\n\n\nself.onDestroy = function() {\n};\n", + "settingsSchema": "", + "dataKeySettingsSchema": "", + "settingsDirective": "tb-progress-bar-widget-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-progress-bar-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"function\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Soil Moisture\",\"color\":\"#2196f3\",\"settings\":{},\"_hash\":0.2392660816082064,\"funcBody\":\"var value = prevValue + Math.random() * 7;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]}}],\"timewindow\":{\"realtime\":{\"timewindowMs\":60000}},\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"padding\":\"0px\",\"settings\":{\"layout\":\"default\",\"autoScale\":true,\"showValue\":true,\"valueFont\":{\"family\":\"Roboto\",\"size\":24,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\",\"lineHeight\":\"32px\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\",\"rangeList\":[{\"from\":0,\"to\":20,\"color\":\"#DE2343\"},{\"from\":20,\"to\":40,\"color\":\"#F77410\"},{\"from\":40,\"to\":60,\"color\":\"#4369DD\"},{\"from\":60,\"to\":100,\"color\":\"#224AC2\"}]},\"tickMin\":0,\"tickMax\":100,\"showTicks\":true,\"ticksFont\":{\"family\":\"Roboto\",\"size\":11,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"ticksColor\":\"rgba(0,0,0,0.54)\",\"background\":{\"type\":\"image\",\"imageBase64\":\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAMUAAACACAMAAACMc10dAAADAFBMVEWMdGuBa2SJcWp1YVt4ZF1oWFRcT0xvXVc4NDJyX1lsWlSdhHh8Z2BmVlGHb2gyMC5JQT5+aGRGPzxDPTouLSs+OTY7NzRgUk9fUUxMQ0CDbGiEbWRXS0cqKShRR0RjVE5BOzg1MjB6ZGFPRUFUSEQkJSSSeG5/amGXf3NaTUibf3ZfhkCOeG1plUGOdW92Yl9hgkGghnySeXOSfHBYgDenjIJbgT5liUWWe3FsW1hlkD+kiX5eWExgiz2rkIR0m01USUiFcme6nZG0mIxwXVywk4hliD5umkROZzx5aV5jVlNHXzqJeGhwkkNZej9chDp5oEyBrDODskqXfHd+o1OOfmt8cV6VvldRbztSezNph01qj0l1mEdYZEVZeDh6g1VwlE17qUpogUZVdj5ffTuVh3GJsFqHqlN5nlNYTExjgznApJiRtFRzpERsjEG31SBXUkiav2Zxak+oyDJMcy+71S50b1hwhkhaiTSRuGSMlmN4iUymvHKQnWOTtnCUr12cjHSGfWKBd2KChlxgfUOvzSSAflpyZ1mKt05ZcEabl2qNjWRkW01zjFWauE19rkGzzzdGay2boW14lVdrnT5gYkyAkVd6dlVifEunwolpYlRxg1GSt0Chv4GJmVdpY0mNrjc9WC54qDaUiGZvnzWcsGeTpVWPrk1BSTallXqavHiSpWiDpUpgaUmKtjI3Ry2ZuISVkWyMg1xvYldPXkA4Ty2LhWiZkFubuzK+0KJ/oGGdvFyNuVdTU0FXWkampnqIo1eDhmWBd1tidUWjnYGEl0lyfl1oa1GYmEp9ekdNTD9BYi2Kj1upxj2Hq2ZqdFJveUyAq1ivzEyIhkymwmWpwE+BnDWSo0WwxZmclXmirXCinViyxHKrsFfC2jm10w2qo2eipUyOj0SHoz23tWp+jT5mljW3yl1GVTqtoIOAkmWbwkN5ki/JrqOKqXmesj+8zpa4w4rl1c9xckHK1qS1zm9vhTDPurHT3K2xr37D0E1hZjfy5ePYxsDH036NXWUP+EK7AAA8rElEQVR42mzYUUiVZxzH8XOz3Q2imy0Y7WK7GRKci4MHpDh3RyE85xDBzHNypqIiamULd5jzXMxtBpmLk85q6QqXUcoGc2PrrDBkCxqZhm5dRLsYS/FiK3Agu4h9f//nec/bar/UtXzP+z6f9/887/M8b+TGt9/euHHjg4/eVs6ePVuvNDVFB1pINBqP19cPFYvr66NDRL8ZSDXX1dXU1MzO7vapIXV1zc2pyoqKXbuqdpBTp/hRVbXLkq6sjKVSqWY+p7yzb9++WCxWWRklLalUg0+L/UsF56jiHNXVdoIKfVhHkwqfKH+309XsXltbu0QiEECEBiUejVb68+Koz8IoYuC3XlFDQKw5hDG8AgQGi7WiyrfEX9gggSJtjBaPSDVU6nL+TqAQg1uQ5liO94o43/5sNGMWhhL5QBFBkYCgjTVYYnw2nkVAZADhFSCer4Ua4AxdXY6hkiS5rt1CMZoxmCINwhRhLSxiSOEYKECECuIUA6nUsWPqEKYA4BFDKJog6Dh90lUeBc1/ypDyPSpUyGEIFGUEDJpBY2qzMCriBAahB3FeEB0V0WhSinI1vMLXgqiaKCyhImqhKcaYlWJIBB9VwgyGIHY5hoZlbGxMCNct/ldhN1EGn2qSSDRmRchmxXCJESmSyTgMS6gIBwaxPoUgVMgQMObFICjo76S31w2IAIHCM9IVSRyqhCman1Wc55sOFZZCiAPDBw4ckCOXEYM0ChN1wzetYAARDxUwzGEKQ4R9KpaCIUPIoGOIsV8MKYZ6e4XopRJ2iTIiZJAm8FJYYJCyRKXwCAwXhoeH9+wxR0ZJNBIpXCqIIbqVZEdLS0egUMKBkQsY4fAOIUn17zExcEghAwp3gcoy4uRJx0h3JJNSuL5IQgZ5tj9RACEsOBxDgWHxEAy1tbVSEMewMztGPFtbnUvkcPhihArVUIo4jDHPiFCDbLabM3e7SvjuhIEYI+YYKmIUhQuMMDIEg8IjBgcHzTG9d+/eTKa93RiCNOJQurO1ilfgIHZ/VI4owyiX4zOmEIMuGBikIJyjzIhk45zVJQnCG1C4oDAGiYbhcd3QXM5TvUCVkGKQ/DDYOthGcLQbI+hZLrW61ypGqGAKNMWAFI0JknMKwgUIzTCHFBqsnhFR6znQ8jxC1XCPRcUGJ8cn7ci0f+BUprmAG5Aa16qEDAqQVu8g3gIDC3e6XQxT+LOr1F7BIRwAg4etGHaFqqQlbskSHDBQJL2AIEYREH4mYkihftbS0eHOwdk8m/jTewMDIUC8peDo7GyF4eMgtI+0t/P/iZAR5dRiDJCmeikIvzdGcBVJBLAbUWzUNGYKO+JdF1OEBs/QpNERa4iBoLEkq0n54cPgvDvcwkkINyQIAqWkHwXqYYalJYMIIIOxfJ9K6g4xMimHUi9FsYiCatWGl+G63ERHKLYXiWNEIJQTE6IsOH9eDA0MVSLGpThTkFMPSS63g5+nlEk6EwRihhNmKB0+fLhUyjsGzXYKAGaYI8ZIKvbMYuRHrRT1NFNBAaOWEWdRYXZgMMRVBcfZsZsovMAMQgjgg8LXwhCcyxFcJi/2tdl/yYULzBLeIISCQcnnTZFpl8EQSptlbm8mRzEgYMjlGPr1TRjODg3J4DsgkmrKokd2NR4hqKUMC1evrq8P/XQnkk5DUPYpjInA8M03ZUYDwLQQQRxi8rMn97sQeIQUwYAIFMvGKJgiY23ip8qAoJW0tWXUpxyC3+kxNkSEGB2nnVQrIQE5IIYPp8Kw8Keyvv5TJB3zCjOoFBIonkGf0uI2zZPUEywPJ09N7ll9kneI/ypKHhEWQwolIQaFMETBK8SgELkMJZKjKAKG99+/cmVhgW4ogktGqwEzEBBOsR4qnkOEjDoUvhbWpzAok8N3/3nSWa4FcYrDEJTAoFq00ZQECM8wRWfBFDBUiUxmeprDqBfDdnz8KoR+y8KSpe3AHoPAsCcFlejv/+orc0RisRBhzyaP+JI4xknWeg0t6Q6KEYQHlBjDnzz4Z3VPyPAKc+TfyuclEIKug4IwWFGovSg6OwudbdPTUmhM2D/C8ON+AcTlc+cuX77cn19oJX5Jo4CQQgjHiKRDRDCwDQHDKXb/zDpJy+a0ZrYqJXgiXLj94OCDlS6qYo6gSwnyAzFCK3GjOyEFsQaDIF4RIKaYWxRD9INQYPTn85pBBwPHEmkFcRkEkUIMm+ysEAGCmILYwtsNDcUINse/O3n7wdGjqwWVRRLHcHP2DzR9iW+6g26tEFSBdVGgaBOiFQVdyvenKXMRfc4qcfr0aRiEqkpBHIID8ihgWFAQIWQIe1OoWPsZBWluqEy7rUGlGcT4DsUnpWorDA7NGOWF4JIPPZ0vrTa0LKLBYkihTJni4v0nm+eksEwx7AsF2ggCBRGDangFQZFH0V9WVNCqyga9T9iNQQIhQsWaauEYKb9t5+h36t7RfPj50YMHj9xti8U0unY9PKUlSPlSPFqVYqJoj3yW2rrrYfcZFBfF9PLq6pPNPimCFEKFGCBCBZsvz8ARKKLaiBtiTQgMYS59c35N7zmCYqQM4TYXJ3czk/z+ycHfPrx9otteCLy7y3YXwSMxkWB+CpaxeprCMITvP6raHhSF1dWVvzcftT2FoBQ0EYXlqVoMD7OJ7CKuXzE0vIIJXwgpLilf6itQrIHA4EIxBgaiHO33q0yIv0hxZGWugYETTCnlHfcOt08l8SSp6hbAF8M7UJRWV1aWN1wpTnTy5YvxBYqAwWOKcdHqSoygS9ETd4kpwxTz89qD1+hVghmejlPM1syWFcQpsKGTgmKUhvzwtz0GkuCVWNzt7fxCaQcAaiJNNZ1KfW8KRGn50ebjiyhOEI0LU+Sl8AgUeli45jtDoiujmcfP3xEMM/vZ9JniGQOZJftrOIAfx47Nz7NjTx1zCvLHkYO/wVi5Mi9GixQKBm1u9BIMRJSw8qYYQlhsbGgIlVZOlJYfb270TaOYwgBiCkYhZNChQCwt0UmrSZeKTX910RxuipkZKa5fu3br1pZLW+2Pvi7dunXr2jUZygHhIkYdrJpupziyPGqKcNnrtiAoQCi8IaAYhogTHDbCS8snSn19G5uP5378EYWPnrU8bcUgIJi+mTQpsAvFBlDNuKPHDhWBRO7cvDkxMnLdFNu2bNm6desWAgHD9evX9+8HqS/9RYImYxDtd5u+QwHjbmE+VCDwiVexl3dvfMXolqHJIkXGIx5vgEDxq6qAgbLY7G0zAhFiqZ1mq77xuPZL2XLsjV8xcqenZ2Lk+M6dhw69uv31bTi2bXOEQ4eu7xwZGZmZmCE4RmbEWFxcbBpTsMzMLP511BWj9B6LlKhW2Ci6+VMFJ0uohUcg1IbZKXp7GxNzy0Kcu7fxqAACxUUrxByIdlv4LpB+DKy/WSRyrgqepwPaNCucGoNLpKen58yZ48dfe/mVF998Y/v27bf4fgPCTnL8+MRNMqGMTEzc7FlUzloWF+/cueMVekzNz9M2eori+769KUDhGTJEUXALOPS90S+WS4f7zp3+fqNvXIq5ixaKMN6uvcVeW7Yq2gs1Yoj6dyRAUNBdTTBGUHz89ZkzL7zw0kuvvfzim8oh8gqCMwQjudkjB39Z/PRTXogOKW+TnxZ/lcIeU6M0jLiZzRSNuUYCI+qLUaH9qJWRWzH6xf3lvtP37n2/+fjKOBGCMQ1jfHx0lKV5kR9Xi6LYvtRNCISuPGbRqUCY4l+i7D2mzSqM43jLNUBp0r/AQiBBU5A0IDRLRlwIVfYHsxpvrX8Zr9UsGkUXWWStUKagdKJpAhMEJDa4VDIjYMoWdQgZbhrmBZxcVgyKhkyig8gS0cT4fZ63sF8G2wKU83mfc55z3rcdHR3j45mZmdn8SS/eTW569vh4B2mSiIQ0NQmip6fn90H5JM/af04qjqwPHzvWQ2YIGKqi9/9MhKOPP64OfbQqim8l70YSPyS2BLE5DEENmhFVEBDkTX3PgbG+IS3lEwltRvLEPQrgK++8YVIEyUpNzQJiRP6XmpbW0OAjJ4lIOpp80+3He2abm4PBZk04/MHbScXcD8HZQQ1jEMbRY8btzqNHYahCAkJm4oUvJxOJxObm2bM0WXm9kZbhYQjDw8MjwaTiTa25EDBIL8FwFwh1JCUANKaGho6OrCyGzaiBGEkFICn1TYemJQrhP8ePzzYHRzQRMhqZ02I8/9qlxHJzEB2K2Z6eR469i+TNHiKgpELXta6nLxf/vp7AcJYmG/xdXnFYA2Ik2Dw7a7yp8uWXX8qT8G8FwbgZPq2f0DgJECOneZLj8zHaNDGklZSkJdNgsVhE4ZseM9LefvKkb1chjD8jy5OTk5HI5b0pFejs7NQKzTIAcoy5Jwpl0G13Ed9xPUaphCD+/nsz8jsKEAFiKEDsKTTffmtsaSDo/pqHVWI0T4Ki1Gw2l1o0JWklFgXIHz6mx2YnyOzs/Px8+7TP164zShSC2JmcjKEgMqUSk6MkTI63t7eLg5FQFhjMqSdfvU36K62NsoZ/TSS2NqUS25NTU6pYTiooBQh+Dx83FBdOnzb2NN0AGs/JnySimz2g29TmLihwWwvMpTaJxVZqxNJQWmqeHpu/+AEZHJxRxvTeuhDFzs7O1fO//gSCGfXapfWdTgIjHtIZCGX3zTYpxquKePeRR0AEEgEQm9t//70VnpoKo4ioAgQKrgK/qa2tzedrkoC4cIGd68C5RiIQQj26ux8GQFB4UBRY7ZRDamK3mws08pc7NHZx4dq1awsLC3Se+bGxUGgqHGbO/M6vnZwEgeIfKcZrz2sxIiii8RC/nkxPh4Do5JJiCOIoiPb2+HKCFquIzdG2qTiKoKFYHo5EuA5j+gL6SRkg+kCoYi8HNAjEZyjsjF4NVqs1xWQyud0pHqfTMzZx8dq1M9f6F9bWUMyG4/E4CmE0o7gK4vwOCq3FkUuJHWWgYAB0N67mNA5VHBUEcwsFiBcGQGxub29P+nwhFBTDUCyLIspluJGGpo4ONi49XpDCwlsbM/JVAOsANtIoCrOZ0dvtBYbA6TJS5vdHJxaunTlypn9obe3HmZ7ZcFQUYZZj8+jo0nkCZP0nKYYw1hOTOgothiKUYRSDqKL9eCQRALG4dXZ7eyve4GujvjAohij4cVWUSmwNBAR7AacLVbApZ2Tk5+cZihPszYJQBSUgaqiocLjKkvG3dl75+cyRI2c+Grrvxx9nBpu50CxfZjLzanRpCQeKX3cVTKmd5V3GbmRSgUAB4qgoOgNUYnGxV0pxni7f5Gs/PjsrDKIIfpwLiwKDZI+RnyFBkce+nKeSJMPkTNHxkxQMpFoJOWV+FKsrojgzdN/79977RZARwohPkXicLy/FzqP4Rxg6pa5vBXQk4TArKBkUuryJTqjRQODDXkWc3d5qk/HtMmQDCtIbFEF7IRDUksb39aUf0rHnUwnN3rxCZ3I5AVSYjDiJQwwSVVw6AqP/LZ5kiUKbkFzqkNflz8mp2ldbu6OKl1jeTCltlhHaDBCVqOJdVdwtiuPLihjYYrNgPslFHm86STNjHyLS31hVdHlSSszSaGx4OsYz03PJoUMAkGQQnVKiyDeVVUsqTCkpUhBR7C8rz6mqgnFDcf9jDz7dwsWajCypwtfmcT2A4vZ9tbIwXnr+pddQzF0PwCDBoGxd7Wil5373XbISKEaMSvSeZXVH2GxR9PU1aV8+TnhlWQd6/LFIz3Rr7GbKklqTrg7qgUMmVvEJzYHifJPLtb9sf7XTxMQCIg4WBgoYorgMY6P/9ae/f6plZDkyGVtKrl43DFHsi63/RDGYUa+hSPxAdvcu2e9P0u7ZrmlQz4kiGPhwwEAsbk76GCyK9BN6coYi3y1TR89xlSU2s7nA7ZG43ebShrTxbEMBQ8tx4j2JOIpFQUNCoTF6lMyoqpzWPUWXPOlrGWa7jsWWWv1eXtQMo7zq9lgs9qsqZN+7dP26KD4dbmGf7GF/a3rxgkQVghgcDgjiw0XmU28oCwUn0HTuYjR9mnQGWZwOQ6uBwulkyfIb07IohjhEAaKYWwWiDpPDUa2KG1EGgZFUPJRUsEXEYq1+F33N7fY4y1pbl5ZQwDCW9zoMFJ+i6Dn2rhwcugm3iMZu0QOiF0QviEV/to40FcWBvXBZuVnLyDuUm65ftpjdXFgQ7oLShtTMmmwcLA0cTKf3viJ/vYhfFC6JQx0UQx2i8NOFUBw5cmnjIRiqEEZra5mXInORXHwH0n/2FHMoBNHyBYjvvuWgpie309wHysoYCchtEXd35Py4jFNrUZzfKCnkI4McLhTGodxcvp4my9tN2NQsaVmZOLINSTGl+Gp+PsmQdaBBoStcw9qQ+DuvsOvdUCwzo6QYZS6nhzi9XhyRXcVrhuIHSiEKRXxOhPE4K3xQEb0DNNmzVxsYSw13NZnZucUZhbcYqdMcPpzBhnAIRWqazexmuaKw2mFUGncOmTUUhVLMExjMKobsoBBJhZXwI7rKiTd65edrlzZQvIyiZTjS2SrJySlzeYWBgsWjy9soRlLxxSClOH0aBM8hVMEKf0TmE4gtEIsemeHp6dn8haKu6OaiwsJbbpYUFdUdzsvjWufWZDGjCnRGMTCOSLaStEpJamp91ngfpfjll19g4JDdGgLRUuh3F1hTsBDPmBxBUBgLI2IoqlCUeZ3eXQVT6sbCCNCiULxJKbpBqKL79AUQ9CcQxnxaYvA0/mIN9/t1t9QVHq4ruukmQ5EvEyo9S7sUC4NtwG4XhU1uHQiOtCYQEi2HyYSCOBxOVShDi2jmJUKzF4f2FMFg5yiI22+vQuHyamSD12KA0F4b0Dbb88h3F7rPNRZ9/XXR143nut/jsUPz8isDIAY2dVEw8huHiUN5GcyiDBgYQGTkMdtqMittZjvHbRQVKXLmtqGAwAefGqbnf7l48WKSYbKmVFQrw1lRoQtcDuriKTAUC/2G4ukvBpujfn8OipzyMrqzwYhHR0dXDIVOqcCI7hWPfHvhQGNdXVFdHWfoE++92NTOe0O9iwMfbkl/iufmZRQWHi7kgyVA81STOOoKC1na6TX1lZVplEJPdxWiKLVZCA4+KEqpj/O2Rhkmsz3FqEa1EcoH3+hXzugEC6N/o+uhz15HMRv3agtmWTgMhKyN6OjqHAoYqpDjx1T7yaa+E3mHSYY+EnqxKfzKyx/z3LiXm6OzkydffO8Ai4HcUphRzPpgehlhG6AMWWk2u10nBp+0Fixt1gQuMwUiVib7zxKDYeLbnQ41PGBkf7V0XQ4i7OAx9r2u/v7+119XBacnGOVSCuJ1Jld4dGVPsb5jHLTYg9MZWT7Xta+PZ0KhkW9e+XjgY920tyJcvRdPNMoyKKrLYNgkWwInvUZ2bbdHuqSTSS7TnOvKyq6sFAYIawrxRK9c2WP8YrKZUTtdgigXg8ThcDBcDkkHr+4qePI4G/ayH5ajUIb2BG233k6KkVQklvx+r6fNxx7FVsueoE+1Gkb1/ZJFub3bTHR98MHMV3+99/nNN91cV5hPL0rVxqOPklItZjZs1luyixgnPG2z9VmpJTYGW1EBjPa5srKiChgmQ1ehteATBkIhBHHnnSiUgUImlCA05ewm2pw9JirpX9nbMRJXW1vFUSDPVWjvqXqwjo+8zFtwvYn1/7Y3r/O2S9fCzLG/zn1Of83Iy82Uq28rIVxvC1PDC2EpRm6XNVhdkWJFUVlfX59awvTXiGI1qSAmiwWFTD4iCiYUEUXtQVGs7iqC4TgIjru89r7bq8rLZL93EpfLvzqnirffnru+dfW8cUixm0tZkvqAxd358isgAl2XRTE3N3e569TM0X/PfV54az5LmUu8q0izuZ1lQuBGEkZtLQ3xARa33ZKaVS9aq4ySMXqjE0ypK0QVJUkFU1DKwTfwL24yyquYUAdjq6s/nxLFs18Ew/4yZl15FQhenSVOd07ekLSu/KT7niieueNqLEcLpbHS8/zLKAYCD23Mrf/33/qcMDbWfvvr33MHinU+sWhhGPuA2+VfwgDivCj2SV+vNlnNaVkgmFEmnfou7xgKIxNSC5suF4rBl/k6P2GV9a6M2lhs9YOFoaH+U6e+aI67dN2U64F8n/RbWRssof3lVas8RFDFuihqq1AkTzEOU4ELBO+ovNC1cWnuP0pBNjaGfvztLw4PHQ3GoxdRVNZn1qNoVYWcnltjgsjRa2JnuokiRYZZ7fCExiYmEBA+maQnG+cnKvVAubgLdNt3lDPaWGxicG1t6JQsiyknxSTCo0wHpdpEUAd31lG89DZT6r8/nrmztqqcA7+xhsocKaPDLwvis34UicTly5c3CI8kZuQZVyjk8aTYxVBZX1NTb/H4VYHBr4dNo7Xvd5js1Msm+4KxH3jGogg0KErlxKF33Q5jaVdY2fWQmfbL4Tw6MTMjCumzzmomFDZBsGYO1u7TyPq5g4cIKHRhoGC+iaGKlO/3Rz5D8eFnr/f3n7mcCKx8+ulDyji1cHGCRKNep9vG4hVEid2JQkohvc6LQ2/Yyl0O2q1uFCgkdEcevPLDUT7GTKWW5M2h1eTQ9oSA6LRyeijc/Mza2qlTHwyGvSh0NhmIO8RB+Pcdd9yhT9cMxR13HtxXlSOG27XJRFpE8cLr9w8NnekKLEeCLS1dwuiiVa6uXhGGB0WNImj6UgxBxOnhctspL1LmVAWzBoXMKRih0NhYVOIN/c+12Ya2VUZx/Obem2Y3zc2S1JqktyZtUpMmlJR0FFpaS9s0HxYEqcH6SfzkB+mEWrEy3+3whW7WoeikFls2nc7hoBtoWXXzbasb0wlzDp3KNi3iRIoIivhBf+e5qaIHmd2WpfeXc57z8j9PhcISqdlIwUHW4SB5xD9Y0Mlmx/Y8AMV3F2oU5CjiR0EM87QKQmGgrmFQ/AAFwYZ1Y8T1gVe3cSy2s6EfXVycvfvZpaWHHtlG3ps9/8332KVLM1Ck8ITXOyLPgAdwARB0BhvT838pYJCQmv4A+dHtIKDotHzKDOo+3ZPquAJZhz6KoX1qz6m1E99duLD/zOFpvdCD5SUFu7aBAYUSEVRIfT1MqAnEAH9L0B3fBsUb27k3MDoqFHcszTz7yLbX2BDDgAnFkKKge0p5hiijYpTOacpf+8bpEgowoACiIOPfNGr/tDuWazS7lt8W83rJehgZTWV5pBTxxSmcgVB77oMxh46rR1USntz1woCEl/ri+38ofnQTiwtb/vHVp96ReAICim1Q3DHz7MFHXtuGJ8T+uLRv341OyiCipAcMO1qHam2mt7KAgEn1PJLqgAhLPu1SnhgSCpoCVEQeVePBe+0YLTIDL+KIzeBuSRliDZAlpoRiTWTaB/Zs9egdJJ48z1f7sLHuWtyQa2sUP/xIHNdLohYflY7PPrX94bvfeaZG8eqz0swfRIiHouaKx4Y8pjHi841YnakAFDQ2Q56t1ghUUgQxUi31m14KDs7FFuUpVB8wgDU7NYvJN4rcxkSea8bqagIEUeVxmNknJ0+tffHdibVTk0dMj04ZUS7OE1pkKwUgjXqHvu/8t1BgPxyvd604UMIuzW/jztrNLsX8yqszKKdLMyhWFy9hPx4HAjEiLBVPNXtBmTt1J2CMYILB7yVDedRLqBlNhS0cmp2yGtpDi9YJba9moELI7Ojv9UebpVXOJf0W3T0lXXqwIwsLv66tfbFG95a0/VZAde26JGNSmstTkMMUGLu8QfFVO6xCIdnsx9l5bqLgir01iiURHfbtZLsDxnFy0VvEdZCC4dY0hraurozuoQTCAJdH9RW8wOy0sJGR1BBDDQI1Y8wTU4iLR3orFSgsH32WGQh7rBi6Ooo0T2tw1MOcbsPbf+zP39bW1k4tvHs63dYc9VuWEu6oMR1SxutJzcDiurd3S0ghhHx/h67zd3lICLRZ7g8SUNwrlMN968G3UE8kR565f4btwUeqBabzDkhpDmzUtGCtr5JzQChhUKrtKYd367Raeex/6OVzjDEoWNE6LYUk5FPNYiboi8rIItqDYajdmOmPvfvunziDpud0KJRuqxOhiJODxkJezrTX56sZqbxwHT5fo/jmjiFhlJ6yp/5VbnISUEAoiu0Hb3Ep2INsUNyxRYPChEJhFNSYjbmVuqBL0XYhLCgqlSNjh8+8rFZc527fMzkn867WabAeNjwaH2yP+lRFy+L/mGF5Y82nT//5q+gMt0ERT3BqmGaE1PS43ufbME9C/Ng3QoF8dX4J9QjLkh2WHrwbE4hX9kpAbb9/euvQjcjuhMTSjFDQaWzpAENcH1YWSDGVQlGrD021Jsvi/DOzVPrnJp9gKS17ujPnoEAIGtR8QHh9Wa292Ed4aI54TyQTGPx2rC0UeR1nQLGrmdksweEXoZQjIt7A3ZhOQGDO5X8oXOUehw49KxC33gxEjeIqaWVaNiCY2uTAAYbucpNxSLlSN1wOVSMUHL4QHcprJ9FnPzunfPHxy/iCwXgwoREdcJgOGGTIHhlJRISzgEjm0pGWlgbljMmF2CCzmZx+jIxMFFIfOX2usYi6uLtGsVOtBQNE6k4YsBrFofm7H97hnXtyTCje3/HWTigw8YaojZI6ZdK1XfVA3lsYai6CgmwkU3D/wmcPvLx/2yPoqDugkAFeI3ZQri3T06EyDi1t2Ccl0O+NCkRjY8Ppdxcm90wd8dYl4hhHnAyAcAc+n9qIQT7jVIDx9if37n5cKGbwDkna9I3tX4Hh8+13ua44NHv3pye9c1Mn2Q7z85rvv8VCSjDQrzF+EnUHqsPqLgSRKCBqKPrXUiqlVhBAJ57/h+LMnie9BFRCiuAYKw4Lb0g3yHzosWxZD+RybXEoWiKnJ3ZNTm21vDgjDQV6ERScDOqMElRFqTRM92DsVhQdGU3mGuPM7AoQG8fi0KHZ7UdPzgnF1avvP0FT7nJwwPdhZE9+WPYlVwJiknUdEtiAgIJOS1H0n739hfe4b/HQ/TugiCIAUe+l2j9pSNoBJKMRCsJHARxMhxpaGkKJiV27jvj8IqcKRQJfJJU2SX1BxGgWVVWojlz+h4LWuGMoe3j/LPfmP18hzY7iCUUxVYECZ/Cpy8US4XhUIJZmlqiEnx59DlGRgTydcDlqGE3CwYnxKgGu/3kwXpZVz46pOfUnGtUcDmer5efAUmIkngkeJMcckiN31+LNsaRYLAeE5KnmmNcVu+26NL+Xw4I155qv7L53NxjnZ5h3mWtuuTg7y/3/z5/agFjc9unVuYn+udWzXChYXUDon5uaZvssjmDX9hAX/KF48c3buDeHRohe6/Wpeu6R4wEGKUqeeaJ/FYyrLKzfn5pTYBrpGwzqm5QJ3EE8Gz7bleraEuk0NSIpinAOT3AhL5So81LBNT1rgGIPRhoaIg2kALmn9+snGxR5mWxmZuf5eRIJKBAwUtTDJ/vb1B04LhP0T+QgmmJHKEPbzrcpZELx9H2ffXjbbSi8aT6vpJ+BQRkJ2FDlgmDv59+ffelpwvKkZAOSFHdyWNIN8eiWQengdMjBNPx+EpdNDNGQeEnGfMl9PKwt6svKPFVwAuQQMxri/F+7adO1jYAsrEOhIkoNBRfX58UVtz4zOr8sEKNfPHTw5EQijQJ9TNa7zW2JCbwx5d6Y2XGGn6M4evQFbo6gt4vczhGM2T7GBdEDwwFTUdgIiIripBg5jZASCrrbIbpwUEmwZjAjFgyImZY3KW/jCfiShBPBSgtiOZkexA9duo6saScaGje1trYKR8OxC9+6FGpmP3B5+adbZwmo0UPLLsVrjxxdTaRDkYZIPDE4kWsmDCWo2OzLBlBur1y9ikcQq1/68LZjp+MJ+QRNJS1AstXslCgmg/GPXIqzq3NEVN3goMappN1QU4bPSjk6fQNRnVGmBwycA5RhI87Ljsf2BzL19T2O6avU5ZI+f4w8hi9cZ5y+AgVbwJ1OR/1A+dL6/OwsSWr+0CEFAcXBo6swNJL3iBYaNv6DAl98wF6SNntq+v0lFrlfPXvmJQ7HBJqtGt2Qy0ERkE6frP0qu/AFRljOKVckNFtaCsMEAu5ggWfmk3RX2QP1eiDl8LuMxxcjMakaEdB62nXDjg1y0hM08nXNaQ6GBFQofWW3ULy2w9SL6AnL82B8voJmoBj2fnHi6HPPk7uhkOMlWjlrDCjEWGgjho5N33LHl9y7mtnx2erqkyatOEOnrsPhkcUYCqHlpyh6udwil4qwSo3ClsUszuBghHXlAQeU+vLw+HC5PWukgrR8WsBv+w0JMt5X16Sk1CUiLQ2JpM/yx+AgSAZzuXNCsfzaE6beNzz+zTIQK+dBcCH2Lj7y6UsT+ILs3QCF7VeHj0fnGhG67ghTkWUOtT96gNtjO58Ym95S1TwBJrMuhiQdBsEwVR/CWlYI5CpLpUIJIaLUzUfGO9rAJgZrRkPRDjJ9DGrlvMOB1/LtmpMN0DD2aGHijiDTspb3zkQoXmc5uocv4w0RHst3+JPd90DxWECvL/2xLr5YmV3coBhVFHEwsEgaCml+oJDLiVl6Wjj4iBhQ2dzue2zM6WJyUUMyoZEXYQ2nBBSG3Y8BcewYFKpeEHnS1frIUGaQqSAjGKTcjuJAn+sDU0cZ4b36SuW8ZiRj/mxHJmj6vGQLf1bjnPuiiUjoTm+ns++8UOx/i+G4eHFZRdSJLzYgONyfnk3IvWMpQvT4ZNEUtVbdT/S4ogVTd4+Wout9bMw0pUggyyJaMnQJiDyZYEhju3FBKgqE8gUn36/EnEAw48r+msew1CcOOHxZDYr2Yml8uLsrTLcRbM93BT2pEa/XR4HxmP66wVA82qn3PPoNAbW8f5/u8dx4eXkeihO/fVfzxXeSos7SuUn9p6blYhKihDEiQVa2VzJYy2SXjQ7eWZnr9RvSFzsa7akuaqlwbNFpMwOqPd8wqppQyKo2lvSl/gpLA4Kh/tV3BQNQOIYfVUQqYSCr9/SVJcTQG+q7y91VXfr/lAW+ZdE4Dg7aqULxgFDM77/FMf1jF5Qrfv1z1IXA6D9WqaXMk/KtKQUB3lgWF1Q2lA3iJ0xT6TG9bSSKRMxCe0UTA4713lCBQspz6YQer0civ1HbWumPxmq+IMJzuaT1119/BQvkWDGE/WpBa+/ryxeaAgGKHMcimO9z/A5qaQfpZ7zU11WoFruLhYCaCc1e2zY8eqH94idC8VjWsk8tLi/Oz15599fFDYjFlYevjrkbI1kz0QE0aRpzYqfPQhGo1qPwB4HwZDspQqG2mC8sOz0+TgFNDW0hqqBwHDi1YpH0UfXJO8nBqNOGO4xk0mtCIdmoKBSM/flChtcNl0i2ni3MHRk9603HY7apZ1yKapUIGy8VNa1apQ02MXypKF7+AO+c427Ya+un4r+JK5SIQ/9xv+bJitJaaOr0dTZpoisx5mXDwS50TARAjZmLYddjtyVyrPgqI02FJsMnHbkBMjKyRptnpizba+jl8SJSHMbkVNF+LneYZCirN2cbWj7P+SYAM1lDHxj/GRvvzhfLpT7dyjU0RtJtPp3rFX3lcrGr2j3+8+8/D5eJM8Rzjj3LLOftda6EnZjy2v4ry4uL61cWYmtA7FUU6ysPL2WQsJXyWax2EUMZdWVADxaqqKbdqLHVfEeArG9xG6Q53tISiqZkieR1NzUemS2NWNLoTNoGHyefhTJItJ/R6clovrZ4m90kSxY2LBkna2WLpNpxMErd5eEBTy7U0sDbxpy8qIElNMGS/CUvGaeuDAwUMw51/38Up3L+tUOjTEiK4u6Hv0ROGCgNY3xTViW6RySIQqaqamyxSy9oZqwtZ/ujiVBDY+vm1pZouICFe70jI9F4451NTbFIpJnk5uhm0uxqSqWcoDTuWqm7NFzkz+KkcCOoSyCV8vnuHk+PqOHjGGpsu5WgVtFntPj7xt1H51dMSHlBmdegFXYfuMzDn5hM5nZBsX5hITZ54tBefpBvL9UCufxAPZlBUaCqM1fyYUoN1VmJYNUgU5E31BJqa06EWq7d1Lr5mk1xkgbJpNDZO9h63fWbK/lwunXzpoZIxIvPdMcf8xW6q51eTc+UCJuwjS9ifnSmnoHh4e5iuZzRiyLC9iG24hsrl2hOS9vXNjQgDz0MhaibZQECpuT6pEYRi01ewBUf73lycm30lRtuAEMojg/AgBvALSIuVgupStS2JOfIKoiU57d7o1BISWlQGK2N8bpwkZcXRiKtUEUq4cqmzfLVtc3+gO4k04lopY57g1pfqZ7cz2GiowrgjAHKQn1fn5YN6uS5bE9fsWDY0YR04Ne2bgrZ5Kx8t5wGNrH1IKuwc38tH7i4vji6NmkfOXx5cfHy178sCcVNN4Exur7yxnFgefP2gqzhRR7w1g3mSL25qFeuoZGvKSSRSEQGzEhLreFPjBS6dFzUunkzTWfjoEw017aKQ9IostxuiCds6+8mriTElSqKVmpOJZWq1Pwq1TXklZ1UaBOSJpIy2qR/omBURBrdiRtdxAYRF7pQwQEUVFyIIogTKA4LcUQFEVGc0Y3Db3EAZxEVJ1ScwPPiWHw+mfvdd+8959zzusNNayMhjlerRQh5UUHD1ZihX+vARwcdKuiPnW00jY1PxGUXGLfFLkvBzia/2cO2To/7Owws8NJ1FBeIl9959x3fvP/dt0/f9BWiwF/A3fUxoviCFdMOJ8JuEDTZLwflihDG5LDr8jhfj5a4m7LlY6GoXzzloyNWMe46RxzhOI4bx6mqYhIwcKnYVjsmtODGW/DOB4s235tyOqgGWgOw11MKDRKXm2yFUFRjSc087I0L/YPRVRnN2ZInmzU4/JuNzTFKipX7lK+8cXD48KeXcbsPH3x88NLTv9z37KenfoY/Dz32ho+ve/PBL+bI2DyUI6Rdjmf6YLCk2Ho2cJjsIiB2BOKhYNiF7QYu+uUs9VykgUXhpqnLnjWQmdR245m6YZBlWeXCwqpCocCV7nWFGc1BgZtIRWEXST7z9aDwxa0tzXOyXFrNVnbmmXJ7NMUpam/CxFUPeNYCLULAj+p+9DKL4vTK4MqDjz+6Xdvt3nmAKI465ZQjP37r4gcP7QOcfz7uBLmAPx/HgdAcgPT9JRspMUrSmSzPCOYPL3M2cDmG5xmZbWeOwe4fsYHlqwgRz9iWsaGahSTbmZFSZcqleY6RqtoS9UqtxydBJ5QCTUlM1TJdDxRBsP06NEFeP24YDiLVLkfj+Xw8WjM6lEmrGgQa5LmM1RDrh48Pf/Xps1X9zIODl18heuvOgzvuYt9wc/THT178NKBpDo6Z90W9wAyfa/UmhDT4ug0Xr9TlQJJkknoei+KII1gYGVs3Fn/EhuNsGJaJGHCD3cocbyYDNW150F5Z3IbhpVGeyp1K/7j5uKNzm3qKXbCILC1fcVOMQlLYKUhOtUmvrUh5Mf3j+z+wlC5UVrK2FFI3rtbht8srat7+EaJ4bHDtRQcHP7h2pD2LKE5hX/3w8ZO3PrQ97rW25gABpHpNPiLAZIKLySMwclIuAuKh3hEEuxCGg3/rm3jUi4kHkFU3nBQDJta/tNVZONnZ7xdcGTtOSldRJLZ4JMSUJWIg2qgy6nceOeYp09L7vXpOY9sKWpDoVa32x++/I445LxUEyVfRaF6kCHqBcihueunwV8/f2bjp+YOPfrOtKDn/07+iOPeON299Qax1q4WyDalRn7muGWntSr834aH2kBNmNJZ+bKuI4e8gDE81Nv4OB00yk5bUjGeu42Rq5iAqaseLEFJoD2dJvmvLpT+zPDePLNUa1IaSZ1t5Eswsl8zszM2VQezatprmzKDN/fEf33///R/7e/WlpboAYDa6aSB/QIx8E8vFw1vXHBy8cf4xgaRdiyjOwTeinHzLew9e1hhOO7GJz9B06rpWHkhwwDpM3AtMJJZlEtt/1wxbeuammWerDouCgaxNoplpyz5N8QLkCI9Gker5Id/kkiAPkiiijA8IuG2xaIbLQW2ndkKUumy4hEFYxGYOv5PmupCYZjn++Y8/ft6HcGz7S6ClvxDD8aGub9IoOB9R/HT7Cbfd89LLNy91jUVx+PhzTjnn5Ove+4WdY2766xkJ3Zay4bvQJUlooKIqIvNLc4sBaMZKCplwZ9KKkjRDSA5AVQXpomn89iJXWe+z12Re5sp8xeaGFYJAgaK0SGCeUdmfSeVgfGjCN3CridOU3nZvW5KpZ+AlBfU8Io73fwbW7PWG/Up/1BHCnZ+RnZ8PYeq4jEXx24t3H3x0O6owSpKX7zjM/p748FvvPc2ocqqYHhYTY65CGLSQi0ABQlT2ag0IWRNNgT2HhHJQNimR+DBJkQvDJCqDV9d0Ddb7rG/Yfw6RTReTTZMjLInqctQv4xjc46qMdOxCqEt6ieNnQfZFKM86zY7YSHUxchwAMyTToa/nzUBpl1qFa3Jff//9739dP7+LKH644u6X3ridEnZK+APLxTqKZ5b13nFjkZWDt1qUMzsleZQjUl0v/LAXyuBsFVyXWmBn8ALbe0tarFTHjcr20kM+4oWcbfzbNQYQV16UUV5EnGowTNbxA8ZbGEADA09nGFKEup4nilLnhSCIrZziPYWg5a7qBXy34svlIvZIqVvWojlCKv4O4/t3vvrq+V9++fClN05ng2IZAHp/QhSgiwsI1bnaLgVsumhE03WhM/7m7Uiq6pQxxbqiVORKjj2Ei7Ky3bzFpnydeJlVEOOIfy5HzcAetq/A2+OinGlVRg1RofQmmmVilwLJ3zw032VHSTmmrsIjuWsYVBSBkJ6tV+p+6mSZ29zhSUaW4aE/cH3PQvn+l8NfHbz3yUsfPdwdLZg8uung8GfnnHPux29df6OdAuY4KTUMu4iYaF1rGpQ6G1wQCrUZ3jFiSOXFQvb+2nMH6lBrVCNZ8F20wV8P/t3+KdSKvAgo5YieZ4667hc1abd9W+srUE12Z77fDYjtok4pYXECopESQt3MQhtT1fGU+c/zMk3JquR2IFchkn7++Z3DXx1+//2XPjq/yUu2nVfPvvvjr3465+Q7Pr/kKahJJsMC4qYE48M/ks9Yaw0AhxLDJfXQ2pkVyZGp/sUayIYl1xtVqapR1fgniDVIAcRUlVAkhBM2O77tATKRD5MgqURQctlU1RRWfxLZKES8PJKJzk3qCTtfguzPtWqzqYjT/eMWaQb0TiP9BC2GeiA/fPrTVwcoqPOrjYWlknDnXRbFT7d8fv3N8oyNi36pU5sGS2nQrA98mwEr+pJATncCM/KpC8lGUR/oc2edChfJryudkUiRNoeFwNBJhfQi6HXwOaicq00aJXUd1J8LepDLHNgftuG3gSeVlrz+uIib7tRaE3A7L9uu4ZARxhwuyZVWVQNpQDCoyW4H9RPbv/0VxcvaoB/6ZFZeeyGi+Omrb378DjP8gKRmUhciEmAEmNRg0kVQEsuwArMI/p2m1MUAWTITjYGpsy4bYKwFKlJqE438pUwcpgtRG2YUrHEAVMLBGdFNbDhDXxlOx5akbY139pqLAnil1Ka1OjU707bCV4XuuIZBJjeV2v7Xh4alhyTlHAYY4hzhFCVMja3u7suf/vTTSx8+frsc7jVldK/328dArcNfvvfcpDvs6q4atcVEFvq8ANUiVATiRf31zFUTYaOEUFhRUN/ut/9pC7b1rOSsSNdl20Dm1kyRuRmqD+NnhvqZBVxO0Wqmyt6TUT+Jc6owOvi6p9tGipXVpqJJg4JGUdDp9YNC0GkhjHrdE4iDd0gtUdRi4whn1edwAN7duvLTnz5FFJc1B4MVgMBcXoEovjr81vsX5IHY3YJQSKpJIjTECIxPpYpYxOXecVDs+z0lgEeFq94b8gs/PeLfC+3ugmSKAM3E9nudEBALmGfDSBTbLTgpZm2yBjCVxNTM9e5x00M/H9qN7DxPY63e6gSpC70IDVoZNctmZSBpEToV7cH4N0Id4aPTPEoETeld+vJZn3747sMnTSsz27NmZftKFsWpr79zUkXsDI+riZIYipqfyJhAUSpBlKqWxk/2xofmXAnTNJBLfo9frGzn/1GwQc/yg1T9R1gBg03CMM6ziZ1mXGas07QGNXAFqmc+36r0xpsS9EEAyRH4TAAT6Cgq4VfdxuO+lkRBGXgOGB+LN9ncwnAvwlwV4pfCXnr38WcxSi2WZpprizNZFHe8/sFJGG4xctfg3nDtCNAHq7ZZiV0guOuPxrWd/XmtVxst4hU8jGZJ2Ef+HYUb0MxLKeTuXxSSgh6dNAD0eGBsG+MilLnN6JRxehxnRByNx3xb0Kpb28WGAyhDVbhIX+qCYmi9ww1DLdAaLai4RVuRpatkz3HYPrga3+OK6PyP0NsPn+/Ly8UKuk+ivx0G9j7x69VJUm2tPWCuN53yUVoIqNYRdJSZC/x4fx+t1hfC3p4SJWx6StGnrHL+rigLm+7hIYaHq5llphaUoQdJAsQ0SMB5qcIpBDBr0GbVtMSqL4jVNs/VdepseK6D2F3nCJXS1TKiuqJDhsIpEatVQY+lvefefvsFpi7tolEDNVn+6S99+OFHL2sw9la+oAAKHv2KRfH5NUQ13EIQsQXsN2Lbuh74dU6zPQwKWjMc7aGvtCLX6wK8m0HuOn91NdbIsNgrIltlQa1GIykmtm2lGXvatYjH0sNBjiVatZjlViFKlrcUIpqj6ZqKSdMNNVVZ16hOJCqlH7GRL47l7fF9h2qK1qnrOn3x7bdfNAyQDKcFvuXZx7z6/vtvXIutA4cUgEbj3p/Q3K99fiUSDnQPAnMW7nF8f9IXBQUMXiSv3Ata8nvHjZq6LIV1XWv0KiZiSMFi+GQTGhFvzePMAKAX9VFzwJegs8xYHyeu/zO4Ya/G8FNXAhpUFrMKrNrdvWkliqJ8DROMk+BzaZXuXjUK4KS3W7VubxNOEAbVpevd/8yNNjssk2W/MFXvvIc/ePeNp6A7M1pYSFL2wG8/fXXHa++fz+rf8tKiPhyGgoZi02G49vfq1/50+NOn1MV8Ptzrj6aHpotiBuaOiJvnrHlmcMTNNEMPQgwmRaBXy5hEwAYMfTbLJBtgDU4aaNzOVg5CcdZ+k9SHj7t0He8v9E1lC6lbm2nThCpaYRFdK5SW0moVymTaPeG8pNLCsZk4My0kPSNXfPDuy68YWTz84/uzM+jndRS/fnLBjLhmoMH7BNKYJHUhQuLOsBWr9/52+zHheLSiC77R5EehZKpBRQSqUMeTS0mWZQKdESQUQaRIcJ5ibxyLQFSxyTpl0Iu+kJvjnROYpDFd5DGqwNEfpAZaAvNtJHItRY7N6nZtOMhnJjUdjCZEE3FGicWLW3wC+atQqsjOGv/s8x9/+HaU0u4f3//+xwLbxKJ44tdPTh8Miti2MWuhI4RhTacA8SS27KfwZTYWESvEiHeHvNDR9fayMu7Vq9UEGIdGlGepoVINLWU5RuqxCcpQDSt1VAP3sdcoKU6bRQq3raQe0Tt1n5CibPI876+xE7OeayW6gk+wSQnv2o8tF3BcNKbHTWEV16XCinc3EwgcGhBoOtVdnn5+YRbJVftM5J4GbLv37yj8pRRh3o1OwLHI/BCf0Lzsbs8YhJsp2hQGq1DHkQMXVTerhVBpClqrlWcZBaMYjotEU7zbJhR9nREqF8wcUJ2MIBpX5QiAO0dH+2DpSQsaXKqGo1ErgHSGSonzYFCtcnpmLme5KK1nbFXVN6c7vSq8qbVMTXQ5ZXNY1On7MiSrFSf6kI0cXzfVzHVPXEdxNuxYKQmiE8bdenfeTSg8qPpeXyfgY4/lEANTstuvTZeqC2WGROHHcjLDKNbiFMshsAVQiITghwaxw6JgXbHORaZC7FgyzyuVjpRDAkISao29BUKgwcymu61kd6dD4acW+ADMCGW73t0ZTrZ0FYw9g0Y3A9kGlRvIuiaj6YukeGSOKPY7Jkrhldsffvz9X9/VOl0+IfEj053NjqZsguD42IPJaqbrA38IHF+WcA4wbXoOLnN3OhyOp6PSc+wILeIyr4V5aQZwA8MoUvDfpGG43BqurOY4hI+WDCBvrRhUJFZzKzNgWxMNK6MEA4rHBsjAjFeR3oIfKBBrCTMsIKZqSBWYGuYJWNqUf/GMY/zipP35NrfbgG/TnbaqYe+L+x6Jqo2t8f5YgGFHdXhpfKhbflhGZjzoN1cUzkGuS01e0fVkWZZLcaupjIb9UJdxcqawtCMlKTNaVaRghTNmcz0SZSwlHmemBFQRDkMzW9amLQKosmIas2NE0wMEGC4mXstam79xO4ygWtKcejBkJEWUSCRpvrnsTQI53K4rmrZ12vmPhNtbioliywNZbOzqnkuTTne3MtqqR1qBdfjbtYqS24EuC5vbYb873FuaS5+Z5Ug1ouh0NCgTAnMBvBOHvOiTnJ+H4Mekogx4IYIWEhvNwF67JRgGI64oLCtpgzt9d9nRKNP1BnLMzqOTahVNUGiUaS4XrAEjkPmNdpIz8oebRvV6KIoykYY7vQpwMBAw60RlKFJPtWLLTDqThmQaYJxAGvRH9eSRQFWt+ngOEIqjHJbmCAc4YUHlEkhN2Myao7PzjMK7BethmQnOl7RqpR7WJHb6Au6AYDNTfwEzMWeGrktsYJRWVfykGpZ4mnlBf3lYLo3AZEmcyIW41T1Bq1R8oICpJ5YpCYVlHLGRyxDes9iK240O1+iOd2PEB8lGcaYQWUAQywdDKdxuQf1AEmXbikFXSYQmrG72IGF7QqUvRyLPTfgAitJdo58b++3NnuhhK9EsYrmK0bNSUOUqlZoAvwy7aK9g568wzwkCzB+AFpy9PwEA3KaEiWPE+AAAAABJRU5ErkJggg==\",\"imageUrl\":null,\"color\":\"#fff\",\"overlay\":{\"enabled\":true,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"barColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":0,\"to\":20,\"color\":\"#DE2343\"},{\"from\":20,\"to\":40,\"color\":\"#F77410\"},{\"from\":40,\"to\":60,\"color\":\"#4369DD\"},{\"from\":60,\"to\":100,\"color\":\"#224AC2\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"barBackground\":\"rgba(0, 0, 0, 0.04)\"},\"title\":\"Soil Moisture\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"units\":\"%\",\"decimals\":0,\"useDashboardTimewindow\":true,\"showLegend\":false,\"widgetStyle\":{},\"actions\":{},\"configMode\":\"basic\",\"displayTimewindow\":true,\"margin\":\"0px\",\"borderRadius\":\"0px\",\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"showTitleIcon\":false,\"titleTooltip\":\"\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"titleIcon\":\"mdi:water-percent\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"iconSize\":\"18px\",\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"14px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1\"},\"color\":null},\"titleColor\":\"rgba(0, 0, 0, 0.87)\"}" + }, + "externalId": null, + "tags": [ + "progress", + "weather", + "environment", + "soil", + "moisture" + ] +} \ No newline at end of file From 9ca568d0700daab0b77ee1727b33abbdca670589 Mon Sep 17 00:00:00 2001 From: ViacheslavKlimov Date: Tue, 24 Oct 2023 13:23:14 +0300 Subject: [PATCH 33/43] Improvements for queue-related tests --- .../controller/TenantControllerTest.java | 2 +- .../TbRuleEngineQueueConsumerManagerTest.java | 21 ++++++------------- 2 files changed, 7 insertions(+), 16 deletions(-) diff --git a/application/src/test/java/org/thingsboard/server/controller/TenantControllerTest.java b/application/src/test/java/org/thingsboard/server/controller/TenantControllerTest.java index d1aefc097f..27a9872ba5 100644 --- a/application/src/test/java/org/thingsboard/server/controller/TenantControllerTest.java +++ b/application/src/test/java/org/thingsboard/server/controller/TenantControllerTest.java @@ -687,7 +687,7 @@ public class TenantControllerTest extends AbstractControllerTest { submittedMsgs.add(tbMsg.getId()); Thread.sleep(timeLeft / msgs); } - await().atMost(5, TimeUnit.SECONDS).untilAsserted(() -> { + await().atMost(15, TimeUnit.SECONDS).untilAsserted(() -> { verify(queueAdmin, times(1)).deleteTopic(eq(isolatedTopic)); }); diff --git a/application/src/test/java/org/thingsboard/server/service/queue/ruleengine/TbRuleEngineQueueConsumerManagerTest.java b/application/src/test/java/org/thingsboard/server/service/queue/ruleengine/TbRuleEngineQueueConsumerManagerTest.java index 38582d0fce..05eacc68e3 100644 --- a/application/src/test/java/org/thingsboard/server/service/queue/ruleengine/TbRuleEngineQueueConsumerManagerTest.java +++ b/application/src/test/java/org/thingsboard/server/service/queue/ruleengine/TbRuleEngineQueueConsumerManagerTest.java @@ -456,8 +456,7 @@ public class TbRuleEngineQueueConsumerManagerTest { clearInvocations(actorContext); verify(consumer1, never()).unsubscribe(); verify(consumer2, never()).unsubscribe(); - int msgCount1 = consumer1.msgCount; - int msgCount2 = consumer2.msgCount; + int msgCount = totalConsumedMsgs.get(); await().atLeast(4, TimeUnit.SECONDS) // based on topicDeletionDelayInSec .atMost(7, TimeUnit.SECONDS) @@ -471,10 +470,8 @@ public class TbRuleEngineQueueConsumerManagerTest { verify(consumer1).unsubscribe(); verify(consumer2).unsubscribe(); - int movedMsgs1 = consumer1.msgCount - msgCount1; - int movedMsgs2 = consumer2.msgCount - msgCount2; - int totalMovedMsgs = movedMsgs1 + movedMsgs2; - assertThat(totalMovedMsgs).isGreaterThan(10); + int totalMovedMsgs = totalConsumedMsgs.get() - msgCount; + assertThat(totalMovedMsgs).isNotZero(); verify(ruleEngineMsgProducer, atLeast(totalMovedMsgs)).send(any(), any(), any()); verify(actorContext, never()).tell(any()); generateQueueMsgs = false; @@ -499,7 +496,7 @@ public class TbRuleEngineQueueConsumerManagerTest { }); clearInvocations(actorContext); verify(consumer, never()).unsubscribe(); - int msgCount = consumer.msgCount; + int msgCount = totalConsumedMsgs.get(); await().atLeast(4, TimeUnit.SECONDS) .atMost(7, TimeUnit.SECONDS) @@ -512,7 +509,8 @@ public class TbRuleEngineQueueConsumerManagerTest { }); verify(consumer).unsubscribe(); - int movedMsgs = consumer.msgCount - msgCount; + int movedMsgs = totalConsumedMsgs.get() - msgCount; + assertThat(movedMsgs).isNotZero(); verify(ruleEngineMsgProducer, atLeast(movedMsgs)).send(any(), any(), any()); verify(actorContext, never()).tell(any()); generateQueueMsgs = false; @@ -607,11 +605,6 @@ public class TbRuleEngineQueueConsumerManagerTest { }); } - /* - * 2023-10-15 18:34:06,090 [main] INFO o.t.s.s.q.r.TbRuleEngineQueueConsumerManagerTest - Generated new partitions: [0, 1, 2, 3, 4, 5, 6, 8, 9, 11, 12, 13, 15, 16, 17, 18, 19] -2023-10-15 18:34:06,090 [main] INFO o.t.s.s.q.r.TbRuleEngineQueueConsumerManagerTest - Generated new config: consumerPerPartition=false, pollInterval=299, processingStrategy=RETRY_FAILED - * */ - private void verifySubscribedAndLaunched(TestConsumer consumer, Set expectedPartitions) { await().atMost(2, TimeUnit.SECONDS) .until(() -> consumer.subscribed && consumer.getPartitions().equals(expectedPartitions) && consumer.pollingStarted); @@ -701,7 +694,6 @@ public class TbRuleEngineQueueConsumerManagerTest { private boolean pollingStarted; private TbMsg testMsg; - private int msgCount; public TestConsumer(String topic) { super(topic); @@ -746,7 +738,6 @@ public class TbRuleEngineQueueConsumerManagerTest { if (!subscribed) { throw new IllegalStateException("Cannot commit because not subscribed"); } - msgCount++; log.debug("doCommit() totalConsumedMsgs = {}", totalConsumedMsgs.incrementAndGet()); } From 0448b5728909b537e0823f8122568d3f13957a44 Mon Sep 17 00:00:00 2001 From: Igor Kulikov Date: Tue, 24 Oct 2023 15:27:01 +0300 Subject: [PATCH 34/43] UI: Outdoor Environment: Noise level widgets. --- .../widget_bundles/outdoor_environment.json | 10 +++++- .../ground_temperature_chart_card.json | 2 +- ...emperature_chart_card_with_background.json | 2 +- .../horizontal_noise_level_card.json | 28 +++++++++++++++++ ...ntal_noise_level_card_with_background.json | 28 +++++++++++++++++ .../widget_types/humidity_chart_card.json | 2 +- .../humidity_chart_card_with_background.json | 2 +- .../system/widget_types/noise_level_card.json | 28 +++++++++++++++++ .../noise_level_card_with_background.json | 28 +++++++++++++++++ .../widget_types/noise_level_chart_card.json | 31 +++++++++++++++++++ ...oise_level_chart_card_with_background.json | 31 +++++++++++++++++++ .../widget_types/pressure_chart_card.json | 2 +- .../pressure_chart_card_with_background.json | 2 +- .../simple_noise_level_chart_card.json | 31 +++++++++++++++++++ ...oise_level_chart_card_with_background.json | 31 +++++++++++++++++++ ...l_moisture_chart_card_with_background.json | 2 +- .../widget_types/temperature_chart_card.json | 2 +- ...emperature_chart_card_with_background.json | 2 +- .../widget_types/value_and_chart_card.json | 2 +- 19 files changed, 255 insertions(+), 11 deletions(-) create mode 100644 application/src/main/data/json/system/widget_types/horizontal_noise_level_card.json create mode 100644 application/src/main/data/json/system/widget_types/horizontal_noise_level_card_with_background.json create mode 100644 application/src/main/data/json/system/widget_types/noise_level_card.json create mode 100644 application/src/main/data/json/system/widget_types/noise_level_card_with_background.json create mode 100644 application/src/main/data/json/system/widget_types/noise_level_chart_card.json create mode 100644 application/src/main/data/json/system/widget_types/noise_level_chart_card_with_background.json create mode 100644 application/src/main/data/json/system/widget_types/simple_noise_level_chart_card.json create mode 100644 application/src/main/data/json/system/widget_types/simple_noise_level_chart_card_with_background.json diff --git a/application/src/main/data/json/system/widget_bundles/outdoor_environment.json b/application/src/main/data/json/system/widget_bundles/outdoor_environment.json index 2c3d0b8919..cc3b703fa3 100644 --- a/application/src/main/data/json/system/widget_bundles/outdoor_environment.json +++ b/application/src/main/data/json/system/widget_bundles/outdoor_environment.json @@ -103,6 +103,14 @@ "simple_soil_moisture_chart_card", "simple_soil_moisture_chart_card_with_background", "soil_moisture_progress_bar", - "soil_moisture_progress_bar_with_background" + "soil_moisture_progress_bar_with_background", + "noise_level_card", + "noise_level_card_with_background", + "horizontal_noise_level_card", + "horizontal_noise_level_card_with_background", + "noise_level_chart_card", + "noise_level_chart_card_with_background", + "simple_noise_level_chart_card", + "simple_noise_level_chart_card_with_background" ] } \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/ground_temperature_chart_card.json b/application/src/main/data/json/system/widget_types/ground_temperature_chart_card.json index 2f829baf42..93c92941b2 100644 --- a/application/src/main/data/json/system/widget_types/ground_temperature_chart_card.json +++ b/application/src/main/data/json/system/widget_types/ground_temperature_chart_card.json @@ -20,7 +20,7 @@ "latestDataKeySettingsDirective": "tb-aggregated-value-card-key-settings", "hasBasicMode": true, "basicModeDirective": "tb-aggregated-value-card-basic-config", - "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"Main building\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Ground temperature\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{\"showLines\":true,\"fillLines\":true,\"showPoints\":false},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 40 - 20;\\nif (value < -60) {\\n\\tvalue = -60;\\n} else if (value > 60) {\\n\\tvalue = 60;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"°C\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"#4caf50\",\"settings\":{\"position\":\"center\",\"font\":{\"size\":52,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"1\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":-20,\"color\":\"#234CC7\"},{\"from\":-20,\"to\":0,\"color\":\"#305AD7\"},{\"from\":0,\"to\":10,\"color\":\"#7191EF\"},{\"from\":10,\"to\":20,\"color\":\"#FFA600\"},{\"from\":20,\"to\":30,\"color\":\"#F36900\"},{\"from\":30,\"to\":40,\"color\":\"#F04022\"},{\"from\":40,\"to\":null,\"color\":\"#D81838\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.9408410830697858,\"funcBody\":\"var value = prevValue + Math.random() * 40 - 20;\\nif (value < -60) {\\n\\tvalue = -60;\\n} else if (value > 60) {\\n\\tvalue = 60;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"°C\",\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta percent\",\"color\":\"#f44336\",\"settings\":{\"position\":\"rightTop\",\"font\":{\"size\":14,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"20px\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[{\"from\":null,\"to\":0,\"color\":\"#198038\"},{\"from\":0,\"to\":0,\"color\":\"rgba(0, 0, 0, 0.87)\"},{\"from\":0,\"to\":null,\"color\":\"#D12730\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":true},\"_hash\":0.06392321853157967,\"funcBody\":\"var value = prevValue + Math.random() * 6 - 3;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < -25) {\\n\\tvalue = -25;\\n} else if (value > 25) {\\n\\tvalue = 25;\\n} \\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta absolute\",\"color\":\"#607d8b\",\"settings\":{\"position\":\"rightBottom\",\"font\":{\"size\":11,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.44695098620509865,\"funcBody\":\"var value = prevValue + Math.random() * 4 - 2;\\nif (value < -6) {\\n\\tvalue = -6;\\n} else if (value > 6) {\\n\\tvalue = 6;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"°C\",\"decimals\":1,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1691927717318,\"endTimeMs\":1692014117318},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"stack\":false,\"fontSize\":10,\"fontColor\":\"#545454\",\"showTooltip\":true,\"tooltipIndividual\":false,\"tooltipCumulative\":false,\"hideZeros\":false,\"grid\":{\"verticalLines\":true,\"horizontalLines\":true,\"outlineWidth\":1,\"color\":\"#545454\",\"backgroundColor\":null,\"tickColor\":\"#DDDDDD\"},\"xaxis\":{\"title\":null,\"showLabels\":true,\"color\":\"#545454\"},\"yaxis\":{\"min\":null,\"max\":null,\"title\":null,\"showLabels\":true,\"color\":\"#545454\",\"tickSize\":null,\"tickDecimals\":0,\"ticksFormatter\":\"\"},\"shadowSize\":4,\"smoothLines\":false,\"comparisonEnabled\":false,\"xaxisSecond\":{\"axisPosition\":\"top\",\"title\":null,\"showLabels\":true},\"showLegend\":true,\"legendConfig\":{\"direction\":\"column\",\"position\":\"bottom\",\"sortDataKeys\":false,\"showMin\":false,\"showMax\":false,\"showAvg\":true,\"showTotal\":false,\"showLatest\":false},\"customLegendEnabled\":false,\"showSubtitle\":true,\"subtitle\":\"${entityName}\",\"subtitleFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"subtitleColor\":\"rgba(0, 0, 0, 0.38)\",\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"dateColor\":\"rgba(0, 0, 0, 0.38)\",\"showChart\":true,\"chartColor\":\"rgba(0, 0, 0, 0.87)\",\"background\":{\"type\":\"color\",\"color\":\"#fff\",\"overlay\":{\"enabled\":false,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Ground temperature\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"device_thermostat\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"24px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":false,\"displayTimewindow\":true,\"decimals\":0,\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"24px\",\"icon\":null,\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":false},\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null}" + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"Main building\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Ground temperature\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{\"showLines\":true,\"fillLines\":true,\"showPoints\":false},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 40 - 20;\\nif (value < -60) {\\n\\tvalue = -60;\\n} else if (value > 60) {\\n\\tvalue = 60;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"°C\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"#4caf50\",\"settings\":{\"position\":\"center\",\"font\":{\"size\":52,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"1\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":-20,\"color\":\"#234CC7\"},{\"from\":-20,\"to\":0,\"color\":\"#305AD7\"},{\"from\":0,\"to\":10,\"color\":\"#7191EF\"},{\"from\":10,\"to\":20,\"color\":\"#FFA600\"},{\"from\":20,\"to\":30,\"color\":\"#F36900\"},{\"from\":30,\"to\":40,\"color\":\"#F04022\"},{\"from\":40,\"to\":null,\"color\":\"#D81838\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.9408410830697858,\"funcBody\":\"var value = prevValue + Math.random() * 40 - 20;\\nif (value < -60) {\\n\\tvalue = -60;\\n} else if (value > 60) {\\n\\tvalue = 60;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"°C\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta percent\",\"color\":\"#f44336\",\"settings\":{\"position\":\"rightTop\",\"font\":{\"size\":14,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"20px\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[{\"from\":null,\"to\":0,\"color\":\"#198038\"},{\"from\":0,\"to\":0,\"color\":\"rgba(0, 0, 0, 0.87)\"},{\"from\":0,\"to\":null,\"color\":\"#D12730\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":true},\"_hash\":0.06392321853157967,\"funcBody\":\"var value = prevValue + Math.random() * 6 - 3;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < -25) {\\n\\tvalue = -25;\\n} else if (value > 25) {\\n\\tvalue = 25;\\n} \\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta absolute\",\"color\":\"#607d8b\",\"settings\":{\"position\":\"rightBottom\",\"font\":{\"size\":11,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.44695098620509865,\"funcBody\":\"var value = prevValue + Math.random() * 4 - 2;\\nif (value < -6) {\\n\\tvalue = -6;\\n} else if (value > 6) {\\n\\tvalue = 6;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"°C\",\"decimals\":1,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1691927717318,\"endTimeMs\":1692014117318},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"stack\":false,\"fontSize\":10,\"fontColor\":\"#545454\",\"showTooltip\":true,\"tooltipIndividual\":false,\"tooltipCumulative\":false,\"hideZeros\":false,\"grid\":{\"verticalLines\":true,\"horizontalLines\":true,\"outlineWidth\":1,\"color\":\"#545454\",\"backgroundColor\":null,\"tickColor\":\"#DDDDDD\"},\"xaxis\":{\"title\":null,\"showLabels\":true,\"color\":\"#545454\"},\"yaxis\":{\"min\":null,\"max\":null,\"title\":null,\"showLabels\":true,\"color\":\"#545454\",\"tickSize\":null,\"tickDecimals\":0,\"ticksFormatter\":\"\"},\"shadowSize\":4,\"smoothLines\":false,\"comparisonEnabled\":false,\"xaxisSecond\":{\"axisPosition\":\"top\",\"title\":null,\"showLabels\":true},\"showLegend\":true,\"legendConfig\":{\"direction\":\"column\",\"position\":\"bottom\",\"sortDataKeys\":false,\"showMin\":false,\"showMax\":false,\"showAvg\":true,\"showTotal\":false,\"showLatest\":false},\"customLegendEnabled\":false,\"showSubtitle\":true,\"subtitle\":\"${entityName}\",\"subtitleFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"subtitleColor\":\"rgba(0, 0, 0, 0.38)\",\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"dateColor\":\"rgba(0, 0, 0, 0.38)\",\"showChart\":true,\"chartColor\":\"rgba(0, 0, 0, 0.87)\",\"background\":{\"type\":\"color\",\"color\":\"#fff\",\"overlay\":{\"enabled\":false,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Ground temperature\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"device_thermostat\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"24px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":false,\"displayTimewindow\":true,\"decimals\":0,\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"24px\",\"icon\":null,\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":false},\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null}" }, "externalId": null, "tags": [ diff --git a/application/src/main/data/json/system/widget_types/ground_temperature_chart_card_with_background.json b/application/src/main/data/json/system/widget_types/ground_temperature_chart_card_with_background.json index 933461c9d8..33ba24a526 100644 --- a/application/src/main/data/json/system/widget_types/ground_temperature_chart_card_with_background.json +++ b/application/src/main/data/json/system/widget_types/ground_temperature_chart_card_with_background.json @@ -20,7 +20,7 @@ "latestDataKeySettingsDirective": "tb-aggregated-value-card-key-settings", "hasBasicMode": true, "basicModeDirective": "tb-aggregated-value-card-basic-config", - "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"Main building\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Ground temperature\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{\"showLines\":true,\"fillLines\":true,\"showPoints\":false},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 40 - 20;\\nif (value < -60) {\\n\\tvalue = -60;\\n} else if (value > 60) {\\n\\tvalue = 60;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"°C\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"#4caf50\",\"settings\":{\"position\":\"center\",\"font\":{\"size\":52,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"1\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":-20,\"color\":\"#224AC2\"},{\"from\":-20,\"to\":0,\"color\":\"#2B54CE\"},{\"from\":0,\"to\":10,\"color\":\"#6083EC\"},{\"from\":10,\"to\":20,\"color\":\"#F89E0D\"},{\"from\":20,\"to\":30,\"color\":\"#F77410\"},{\"from\":30,\"to\":40,\"color\":\"#F04022\"},{\"from\":40,\"to\":null,\"color\":\"#DE2343\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.9408410830697858,\"funcBody\":\"var value = prevValue + Math.random() * 40 - 20;\\nif (value < -60) {\\n\\tvalue = -60;\\n} else if (value > 60) {\\n\\tvalue = 60;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"°C\",\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta percent\",\"color\":\"#f44336\",\"settings\":{\"position\":\"rightTop\",\"font\":{\"size\":14,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"20px\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[{\"from\":null,\"to\":0,\"color\":\"#198038\"},{\"from\":0,\"to\":0,\"color\":\"rgba(0, 0, 0, 0.87)\"},{\"from\":0,\"to\":null,\"color\":\"#D12730\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":true},\"_hash\":0.06392321853157967,\"funcBody\":\"var value = prevValue + Math.random() * 6 - 3;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < -25) {\\n\\tvalue = -25;\\n} else if (value > 25) {\\n\\tvalue = 25;\\n} \\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta absolute\",\"color\":\"#607d8b\",\"settings\":{\"position\":\"rightBottom\",\"font\":{\"size\":11,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.44695098620509865,\"funcBody\":\"var value = prevValue + Math.random() * 4 - 2;\\nif (value < -6) {\\n\\tvalue = -6;\\n} else if (value > 6) {\\n\\tvalue = 6;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"°C\",\"decimals\":1,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1691927717318,\"endTimeMs\":1692014117318},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"stack\":false,\"fontSize\":10,\"fontColor\":\"#545454\",\"showTooltip\":true,\"tooltipIndividual\":false,\"tooltipCumulative\":false,\"hideZeros\":false,\"grid\":{\"verticalLines\":true,\"horizontalLines\":true,\"outlineWidth\":1,\"color\":\"#545454\",\"backgroundColor\":null,\"tickColor\":\"#DDDDDD\"},\"xaxis\":{\"title\":null,\"showLabels\":true,\"color\":\"#545454\"},\"yaxis\":{\"min\":null,\"max\":null,\"title\":null,\"showLabels\":true,\"color\":\"#545454\",\"tickSize\":null,\"tickDecimals\":0,\"ticksFormatter\":\"\"},\"shadowSize\":4,\"smoothLines\":false,\"comparisonEnabled\":false,\"xaxisSecond\":{\"axisPosition\":\"top\",\"title\":null,\"showLabels\":true},\"showLegend\":true,\"legendConfig\":{\"direction\":\"column\",\"position\":\"bottom\",\"sortDataKeys\":false,\"showMin\":false,\"showMax\":false,\"showAvg\":true,\"showTotal\":false,\"showLatest\":false},\"customLegendEnabled\":false,\"showSubtitle\":true,\"subtitle\":\"${entityName}\",\"subtitleFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"subtitleColor\":\"rgba(0, 0, 0, 0.38)\",\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"dateColor\":\"rgba(0, 0, 0, 0.38)\",\"showChart\":true,\"chartColor\":\"rgba(0, 0, 0, 0.87)\",\"background\":{\"type\":\"image\",\"imageBase64\":\"data:image/png;base64,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\",\"imageUrl\":null,\"color\":\"#fff\",\"overlay\":{\"enabled\":true,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Ground temperature\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"device_thermostat\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"24px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":false,\"displayTimewindow\":true,\"decimals\":0,\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"24px\",\"icon\":null,\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":false},\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null}" + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"Main building\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Ground temperature\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{\"showLines\":true,\"fillLines\":true,\"showPoints\":false},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 40 - 20;\\nif (value < -60) {\\n\\tvalue = -60;\\n} else if (value > 60) {\\n\\tvalue = 60;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"°C\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"#4caf50\",\"settings\":{\"position\":\"center\",\"font\":{\"size\":52,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"1\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":-20,\"color\":\"#224AC2\"},{\"from\":-20,\"to\":0,\"color\":\"#2B54CE\"},{\"from\":0,\"to\":10,\"color\":\"#6083EC\"},{\"from\":10,\"to\":20,\"color\":\"#F89E0D\"},{\"from\":20,\"to\":30,\"color\":\"#F77410\"},{\"from\":30,\"to\":40,\"color\":\"#F04022\"},{\"from\":40,\"to\":null,\"color\":\"#DE2343\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.9408410830697858,\"funcBody\":\"var value = prevValue + Math.random() * 40 - 20;\\nif (value < -60) {\\n\\tvalue = -60;\\n} else if (value > 60) {\\n\\tvalue = 60;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"°C\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta percent\",\"color\":\"#f44336\",\"settings\":{\"position\":\"rightTop\",\"font\":{\"size\":14,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"20px\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[{\"from\":null,\"to\":0,\"color\":\"#198038\"},{\"from\":0,\"to\":0,\"color\":\"rgba(0, 0, 0, 0.87)\"},{\"from\":0,\"to\":null,\"color\":\"#D12730\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":true},\"_hash\":0.06392321853157967,\"funcBody\":\"var value = prevValue + Math.random() * 6 - 3;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < -25) {\\n\\tvalue = -25;\\n} else if (value > 25) {\\n\\tvalue = 25;\\n} \\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta absolute\",\"color\":\"#607d8b\",\"settings\":{\"position\":\"rightBottom\",\"font\":{\"size\":11,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.44695098620509865,\"funcBody\":\"var value = prevValue + Math.random() * 4 - 2;\\nif (value < -6) {\\n\\tvalue = -6;\\n} else if (value > 6) {\\n\\tvalue = 6;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"°C\",\"decimals\":1,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1691927717318,\"endTimeMs\":1692014117318},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"stack\":false,\"fontSize\":10,\"fontColor\":\"#545454\",\"showTooltip\":true,\"tooltipIndividual\":false,\"tooltipCumulative\":false,\"hideZeros\":false,\"grid\":{\"verticalLines\":true,\"horizontalLines\":true,\"outlineWidth\":1,\"color\":\"#545454\",\"backgroundColor\":null,\"tickColor\":\"#DDDDDD\"},\"xaxis\":{\"title\":null,\"showLabels\":true,\"color\":\"#545454\"},\"yaxis\":{\"min\":null,\"max\":null,\"title\":null,\"showLabels\":true,\"color\":\"#545454\",\"tickSize\":null,\"tickDecimals\":0,\"ticksFormatter\":\"\"},\"shadowSize\":4,\"smoothLines\":false,\"comparisonEnabled\":false,\"xaxisSecond\":{\"axisPosition\":\"top\",\"title\":null,\"showLabels\":true},\"showLegend\":true,\"legendConfig\":{\"direction\":\"column\",\"position\":\"bottom\",\"sortDataKeys\":false,\"showMin\":false,\"showMax\":false,\"showAvg\":true,\"showTotal\":false,\"showLatest\":false},\"customLegendEnabled\":false,\"showSubtitle\":true,\"subtitle\":\"${entityName}\",\"subtitleFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"subtitleColor\":\"rgba(0, 0, 0, 0.38)\",\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"dateColor\":\"rgba(0, 0, 0, 0.38)\",\"showChart\":true,\"chartColor\":\"rgba(0, 0, 0, 0.87)\",\"background\":{\"type\":\"image\",\"imageBase64\":\"data:image/png;base64,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\",\"imageUrl\":null,\"color\":\"#fff\",\"overlay\":{\"enabled\":true,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Ground temperature\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"device_thermostat\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"24px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":false,\"displayTimewindow\":true,\"decimals\":0,\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"24px\",\"icon\":null,\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":false},\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null}" }, "externalId": null, "tags": [ diff --git a/application/src/main/data/json/system/widget_types/horizontal_noise_level_card.json b/application/src/main/data/json/system/widget_types/horizontal_noise_level_card.json new file mode 100644 index 0000000000..a32b3ff059 --- /dev/null +++ b/application/src/main/data/json/system/widget_types/horizontal_noise_level_card.json @@ -0,0 +1,28 @@ +{ + "fqn": "horizontal_noise_level_card", + "name": "Horizontal noise level card", + "deprecated": false, + "image": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAMgAAACgCAMAAAB+IdObAAAAnFBMVEUAAADf39/f39/g4ODg4ODf39/////k5OSAwyzg4ODP6a/f8MqQy0bIyMhYWFig0mDOzs67u7v09PTx8fHv9+X5+fn3+/LV1dXb29vi4uLCwsK2trav2Xt0dHTn5+e43Yi/4ZWIxznQ6a+rq6tmZmaYzlNKSkrH5aPn9NiCgoKQkJDt7e3X7L2enp7Y7L2w2Xuo1m48PDytra0hISE2LSZJAAAABnRSTlMAIEDfv1C6kOEmAAADL0lEQVR42u3ai1LaQBiGYar294fshs05hCQEEo6e2/u/t+4unVSoVaiMRuZ71GXdOGNeFobMQA8AAAAAAAAAAAAAAAAAAAAAAAAAAADgI3378mzGxeX1Vze6/K47riP68vzri96VT2cguur16Sz0EdIxCOkahHQNQroGIV1zUEidUOKRcTeiVrKm59YjOspnhLgu1QWRPlMZ0CggCvQPSVcvmWlgD7knC3GW1X3czmjHkB0KZ9r96pCQSe7shtzVxWjRLIJCboon6ekFG7IoFmYcucUiOFnIA2vCnGdlZ+F+yIAtEb4dIniwE+ItNoW3pnVtQrygWd896RC9XLuJ/pL61jtVyICFs6pYEIVmNuHh3yHz2Ww5Z3F8iJQ/i3pNhVfIRDZ1s5HShugDwcatE71JJ9uRXNzqccohTXhCFE85pq343tmG2LaYOXwtJHacF0KoKYKnxqVC3jWul7jNxoQErn60BT9HtG5cE3JC5vSHbJLmvCJrMGUW8zaEmFevhQyY25A9QTvaYff2hOIwNJth7/3taITMk1nONmQemj95pINCPo/DzEPaD1lyrsftjljz+KAQ+xj7HGE1EVzthzzycufJnrOIDwnRE0GfJp5yuBcy5EEbMvy90OmQ21lMZJ/oOQ+ePdnz/ZCcq2NDfHqBf7O/4NMpzO0OCD0u+dG+mJC1tKcv2pBQ8O2xIWMbo79vUrKiiKK+Mgt9ioiorEuK0nR7QC+8J2nJ04dqaP55LPihEly1jzazbkOmef44feMF0clze4miJ5NnIUmiUimVnmWUpZkXjTOVJFJ5N8qLiFTpe15KvrIHlPTo/w0E6zON9Sw0s/YsVvq34Z9LFDGJj71otCFq7EtVqm1ImaR6rtfKVGXShvTTVIfIcSl9nZv59A5hGLcvKfHO+juvfn+oNFPjRGa+2RHlpdnYH0ul1268UioyIZHZkdL7YQ4kWUYfzIYcLS3p3xKZ0gE6ERJFrx306RCdCOkihHQNQroGIV2DkK7p967O4G12Iv9Kf2DgDN5oj/QHBnrfL0fXX93lxTl9qAYAAAAAAAAAAAAAAAAAAAAAAAAAAADgg/wCTYn9BVfiGNYAAAAASUVORK5CYII=", + "description": "Displays a latest noise level telemetry data in a horizontal layout.", + "descriptor": { + "type": "latest", + "sizeX": 5, + "sizeY": 1, + "resources": [], + "templateHtml": "\n", + "templateCss": "", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueCardWidget.onDataUpdated();\n};\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n horizontal: true,\n previewWidth: '420px',\n previewHeight: '90px',\n embedTitlePanel: true,\n defaultDataKeysFunction: function() {\n return [{ name: 'noise', label: 'Noise level', type: 'timeseries' }];\n }\n };\n};\n\nself.onDestroy = function() {\n};\n", + "settingsSchema": "", + "dataKeySettingsSchema": "", + "settingsDirective": "tb-value-card-widget-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"function\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Noise level\",\"color\":\"#2196f3\",\"settings\":{},\"_hash\":0.2392660816082064,\"funcBody\":\"var value;\\nif (!prevValue) {\\n value = Math.random() * 120;\\n} else {\\n value = prevValue + Math.random() * 40 - 20;\\n}\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 120) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]}}],\"timewindow\":{\"realtime\":{\"timewindowMs\":60000}},\"showTitle\":false,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"padding\":\"0px\",\"settings\":{\"labelPosition\":\"top\",\"layout\":\"horizontal\",\"showLabel\":true,\"labelFont\":{\"family\":\"Roboto\",\"size\":16,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"labelColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showIcon\":true,\"iconSize\":40,\"iconSizeUnit\":\"px\",\"icon\":\"bar_chart\",\"iconColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":50,\"color\":\"#80C32C\"},{\"from\":50,\"to\":70,\"color\":\"#FFA600\"},{\"from\":70,\"to\":90,\"color\":\"#F36900\"},{\"from\":90,\"to\":null,\"color\":\"#D81838\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"valueFont\":{\"size\":36,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\",\"rangeList\":[{\"from\":null,\"to\":50,\"color\":\"#80C32C\"},{\"from\":50,\"to\":70,\"color\":\"#FFA600\"},{\"from\":70,\"to\":90,\"color\":\"#F36900\"},{\"from\":90,\"to\":null,\"color\":\"#D81838\"}]},\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"dateColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"color\",\"color\":\"#fff\",\"overlay\":{\"enabled\":false,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Horizontal noise level card\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"units\":\"dB\",\"decimals\":0,\"useDashboardTimewindow\":true,\"showLegend\":false,\"widgetStyle\":{},\"actions\":{},\"configMode\":\"basic\",\"displayTimewindow\":true,\"margin\":\"0px\",\"borderRadius\":\"0px\",\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"showTitleIcon\":false,\"titleTooltip\":\"\",\"titleFont\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1.6\"},\"titleIcon\":\"\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"iconSize\":\"14px\",\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"14px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1\"},\"color\":null}}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "noise" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/horizontal_noise_level_card_with_background.json b/application/src/main/data/json/system/widget_types/horizontal_noise_level_card_with_background.json new file mode 100644 index 0000000000..02ddfe3a58 --- /dev/null +++ b/application/src/main/data/json/system/widget_types/horizontal_noise_level_card_with_background.json @@ -0,0 +1,28 @@ +{ + "fqn": "horizontal_noise_level_card_with_background", + "name": "Horizontal noise level card with background", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays a latest noise level telemetry data in a horizontal layout with background.", + "descriptor": { + "type": "latest", + "sizeX": 5, + "sizeY": 1, + "resources": [], + "templateHtml": "\n", + "templateCss": "", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueCardWidget.onDataUpdated();\n};\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n horizontal: true,\n previewWidth: '420px',\n previewHeight: '90px',\n embedTitlePanel: true,\n defaultDataKeysFunction: function() {\n return [{ name: 'noise', label: 'Noise level', type: 'timeseries' }];\n }\n };\n};\n\nself.onDestroy = function() {\n};\n", + "settingsSchema": "", + "dataKeySettingsSchema": "", + "settingsDirective": "tb-value-card-widget-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"function\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Noise level\",\"color\":\"#2196f3\",\"settings\":{},\"_hash\":0.2392660816082064,\"funcBody\":\"var value;\\nif (!prevValue) {\\n value = Math.random() * 120;\\n} else {\\n value = prevValue + Math.random() * 40 - 20;\\n}\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 120) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]}}],\"timewindow\":{\"realtime\":{\"timewindowMs\":60000}},\"showTitle\":false,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"padding\":\"0px\",\"settings\":{\"labelPosition\":\"top\",\"layout\":\"horizontal\",\"showLabel\":true,\"labelFont\":{\"family\":\"Roboto\",\"size\":16,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"labelColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showIcon\":true,\"iconSize\":40,\"iconSizeUnit\":\"px\",\"icon\":\"bar_chart\",\"iconColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":50,\"color\":\"#7CC322\"},{\"from\":50,\"to\":70,\"color\":\"#F89E0D\"},{\"from\":70,\"to\":90,\"color\":\"#F77410\"},{\"from\":90,\"to\":null,\"color\":\"#DE2343\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"valueFont\":{\"size\":36,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\",\"rangeList\":[{\"from\":null,\"to\":50,\"color\":\"#7CC322\"},{\"from\":50,\"to\":70,\"color\":\"#F89E0D\"},{\"from\":70,\"to\":90,\"color\":\"#F77410\"},{\"from\":90,\"to\":null,\"color\":\"#DE2343\"}]},\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"dateColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"image\",\"imageBase64\":\"data:image/png;base64,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\",\"imageUrl\":null,\"color\":\"#fff\",\"overlay\":{\"enabled\":true,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Horizontal noise level card\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"units\":\"dB\",\"decimals\":0,\"useDashboardTimewindow\":true,\"showLegend\":false,\"widgetStyle\":{},\"actions\":{},\"configMode\":\"basic\",\"displayTimewindow\":true,\"margin\":\"0px\",\"borderRadius\":\"0px\",\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"showTitleIcon\":false,\"titleTooltip\":\"\",\"titleFont\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1.6\"},\"titleIcon\":\"\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"iconSize\":\"14px\",\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"14px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1\"},\"color\":null}}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "noise" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/humidity_chart_card.json b/application/src/main/data/json/system/widget_types/humidity_chart_card.json index 9b59059ac2..c66869c29f 100644 --- a/application/src/main/data/json/system/widget_types/humidity_chart_card.json +++ b/application/src/main/data/json/system/widget_types/humidity_chart_card.json @@ -20,7 +20,7 @@ "latestDataKeySettingsDirective": "tb-aggregated-value-card-key-settings", "hasBasicMode": true, "basicModeDirective": "tb-aggregated-value-card-basic-config", - "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"Main building\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Humidity\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{\"showLines\":true,\"fillLines\":true,\"showPoints\":false},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 7;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"#4caf50\",\"settings\":{\"position\":\"center\",\"font\":{\"size\":52,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"1\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":0,\"to\":20,\"color\":\"#D81838\"},{\"from\":20,\"to\":40,\"color\":\"#FFA600\"},{\"from\":40,\"to\":60,\"color\":\"#5B7EE6\"},{\"from\":60,\"to\":80,\"color\":\"#305AD7\"},{\"from\":80,\"to\":100,\"color\":\"#234CC7\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.9408410830697858,\"funcBody\":\"var value = prevValue + Math.random() * 7;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta percent\",\"color\":\"#f44336\",\"settings\":{\"position\":\"rightTop\",\"font\":{\"size\":14,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"20px\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[{\"from\":null,\"to\":0,\"color\":\"#198038\"},{\"from\":0,\"to\":0,\"color\":\"rgba(0, 0, 0, 0.87)\"},{\"from\":0,\"to\":null,\"color\":\"#D12730\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":true},\"_hash\":0.06392321853157967,\"funcBody\":\"var value = prevValue + Math.random() * 6 - 3;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < -25) {\\n\\tvalue = -25;\\n} else if (value > 25) {\\n\\tvalue = 25;\\n} \\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta absolute\",\"color\":\"#607d8b\",\"settings\":{\"position\":\"rightBottom\",\"font\":{\"size\":11,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.44695098620509865,\"funcBody\":\"var value = prevValue + Math.random() * 4 - 2;\\nif (value < -6) {\\n\\tvalue = -6;\\n} else if (value > 6) {\\n\\tvalue = 6;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":1,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1691927717318,\"endTimeMs\":1692014117318},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"stack\":false,\"fontSize\":10,\"fontColor\":\"#545454\",\"showTooltip\":true,\"tooltipIndividual\":false,\"tooltipCumulative\":false,\"hideZeros\":false,\"grid\":{\"verticalLines\":true,\"horizontalLines\":true,\"outlineWidth\":1,\"color\":\"#545454\",\"backgroundColor\":null,\"tickColor\":\"#DDDDDD\"},\"xaxis\":{\"title\":null,\"showLabels\":true,\"color\":\"#545454\"},\"yaxis\":{\"min\":null,\"max\":null,\"title\":null,\"showLabels\":true,\"color\":\"#545454\",\"tickSize\":null,\"tickDecimals\":0,\"ticksFormatter\":\"\"},\"shadowSize\":4,\"smoothLines\":false,\"comparisonEnabled\":false,\"xaxisSecond\":{\"axisPosition\":\"top\",\"title\":null,\"showLabels\":true},\"showLegend\":true,\"legendConfig\":{\"direction\":\"column\",\"position\":\"bottom\",\"sortDataKeys\":false,\"showMin\":false,\"showMax\":false,\"showAvg\":true,\"showTotal\":false,\"showLatest\":false},\"customLegendEnabled\":false,\"showSubtitle\":true,\"subtitle\":\"${entityName}\",\"subtitleFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"subtitleColor\":\"rgba(0, 0, 0, 0.38)\",\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"dateColor\":\"rgba(0, 0, 0, 0.38)\",\"showChart\":true,\"chartColor\":\"rgba(0, 0, 0, 0.87)\",\"background\":{\"type\":\"color\",\"color\":\"#fff\",\"overlay\":{\"enabled\":false,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Humidity\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"mdi:water-percent\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"24px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":false,\"displayTimewindow\":true,\"decimals\":0,\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"24px\",\"icon\":null,\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":false},\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null}" + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"Main building\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Humidity\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{\"showLines\":true,\"fillLines\":true,\"showPoints\":false},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 7;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"#4caf50\",\"settings\":{\"position\":\"center\",\"font\":{\"size\":52,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"1\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":0,\"to\":20,\"color\":\"#D81838\"},{\"from\":20,\"to\":40,\"color\":\"#FFA600\"},{\"from\":40,\"to\":60,\"color\":\"#5B7EE6\"},{\"from\":60,\"to\":80,\"color\":\"#305AD7\"},{\"from\":80,\"to\":100,\"color\":\"#234CC7\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.9408410830697858,\"funcBody\":\"var value = prevValue + Math.random() * 7;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta percent\",\"color\":\"#f44336\",\"settings\":{\"position\":\"rightTop\",\"font\":{\"size\":14,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"20px\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[{\"from\":null,\"to\":0,\"color\":\"#198038\"},{\"from\":0,\"to\":0,\"color\":\"rgba(0, 0, 0, 0.87)\"},{\"from\":0,\"to\":null,\"color\":\"#D12730\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":true},\"_hash\":0.06392321853157967,\"funcBody\":\"var value = prevValue + Math.random() * 6 - 3;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < -25) {\\n\\tvalue = -25;\\n} else if (value > 25) {\\n\\tvalue = 25;\\n} \\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta absolute\",\"color\":\"#607d8b\",\"settings\":{\"position\":\"rightBottom\",\"font\":{\"size\":11,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.44695098620509865,\"funcBody\":\"var value = prevValue + Math.random() * 4 - 2;\\nif (value < -6) {\\n\\tvalue = -6;\\n} else if (value > 6) {\\n\\tvalue = 6;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":1,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1691927717318,\"endTimeMs\":1692014117318},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"stack\":false,\"fontSize\":10,\"fontColor\":\"#545454\",\"showTooltip\":true,\"tooltipIndividual\":false,\"tooltipCumulative\":false,\"hideZeros\":false,\"grid\":{\"verticalLines\":true,\"horizontalLines\":true,\"outlineWidth\":1,\"color\":\"#545454\",\"backgroundColor\":null,\"tickColor\":\"#DDDDDD\"},\"xaxis\":{\"title\":null,\"showLabels\":true,\"color\":\"#545454\"},\"yaxis\":{\"min\":null,\"max\":null,\"title\":null,\"showLabels\":true,\"color\":\"#545454\",\"tickSize\":null,\"tickDecimals\":0,\"ticksFormatter\":\"\"},\"shadowSize\":4,\"smoothLines\":false,\"comparisonEnabled\":false,\"xaxisSecond\":{\"axisPosition\":\"top\",\"title\":null,\"showLabels\":true},\"showLegend\":true,\"legendConfig\":{\"direction\":\"column\",\"position\":\"bottom\",\"sortDataKeys\":false,\"showMin\":false,\"showMax\":false,\"showAvg\":true,\"showTotal\":false,\"showLatest\":false},\"customLegendEnabled\":false,\"showSubtitle\":true,\"subtitle\":\"${entityName}\",\"subtitleFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"subtitleColor\":\"rgba(0, 0, 0, 0.38)\",\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"dateColor\":\"rgba(0, 0, 0, 0.38)\",\"showChart\":true,\"chartColor\":\"rgba(0, 0, 0, 0.87)\",\"background\":{\"type\":\"color\",\"color\":\"#fff\",\"overlay\":{\"enabled\":false,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Humidity\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"mdi:water-percent\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"24px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":false,\"displayTimewindow\":true,\"decimals\":0,\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"24px\",\"icon\":null,\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":false},\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null}" }, "externalId": null, "tags": [ diff --git a/application/src/main/data/json/system/widget_types/humidity_chart_card_with_background.json b/application/src/main/data/json/system/widget_types/humidity_chart_card_with_background.json index da6078bac5..8e3d3db401 100644 --- a/application/src/main/data/json/system/widget_types/humidity_chart_card_with_background.json +++ b/application/src/main/data/json/system/widget_types/humidity_chart_card_with_background.json @@ -20,7 +20,7 @@ "latestDataKeySettingsDirective": "tb-aggregated-value-card-key-settings", "hasBasicMode": true, "basicModeDirective": "tb-aggregated-value-card-basic-config", - "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"Main building\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Humidity\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{\"showLines\":true,\"fillLines\":true,\"showPoints\":false},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 7;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"#4caf50\",\"settings\":{\"position\":\"center\",\"font\":{\"size\":52,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"1\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":0,\"to\":20,\"color\":\"#DE2343\"},{\"from\":20,\"to\":40,\"color\":\"#F89E0D\"},{\"from\":40,\"to\":60,\"color\":\"#5579E5\"},{\"from\":60,\"to\":80,\"color\":\"#2B54CE\"},{\"from\":80,\"to\":100,\"color\":\"#224AC2\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.9408410830697858,\"funcBody\":\"var value = prevValue + Math.random() * 7;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta percent\",\"color\":\"#f44336\",\"settings\":{\"position\":\"rightTop\",\"font\":{\"size\":14,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"20px\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[{\"from\":null,\"to\":0,\"color\":\"#198038\"},{\"from\":0,\"to\":0,\"color\":\"rgba(0, 0, 0, 0.87)\"},{\"from\":0,\"to\":null,\"color\":\"#D12730\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":true},\"_hash\":0.06392321853157967,\"funcBody\":\"var value = prevValue + Math.random() * 6 - 3;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < -25) {\\n\\tvalue = -25;\\n} else if (value > 25) {\\n\\tvalue = 25;\\n} \\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta absolute\",\"color\":\"#607d8b\",\"settings\":{\"position\":\"rightBottom\",\"font\":{\"size\":11,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.44695098620509865,\"funcBody\":\"var value = prevValue + Math.random() * 4 - 2;\\nif (value < -6) {\\n\\tvalue = -6;\\n} else if (value > 6) {\\n\\tvalue = 6;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":1,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1691927717318,\"endTimeMs\":1692014117318},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"stack\":false,\"fontSize\":10,\"fontColor\":\"#545454\",\"showTooltip\":true,\"tooltipIndividual\":false,\"tooltipCumulative\":false,\"hideZeros\":false,\"grid\":{\"verticalLines\":true,\"horizontalLines\":true,\"outlineWidth\":1,\"color\":\"#545454\",\"backgroundColor\":null,\"tickColor\":\"#DDDDDD\"},\"xaxis\":{\"title\":null,\"showLabels\":true,\"color\":\"#545454\"},\"yaxis\":{\"min\":null,\"max\":null,\"title\":null,\"showLabels\":true,\"color\":\"#545454\",\"tickSize\":null,\"tickDecimals\":0,\"ticksFormatter\":\"\"},\"shadowSize\":4,\"smoothLines\":false,\"comparisonEnabled\":false,\"xaxisSecond\":{\"axisPosition\":\"top\",\"title\":null,\"showLabels\":true},\"showLegend\":true,\"legendConfig\":{\"direction\":\"column\",\"position\":\"bottom\",\"sortDataKeys\":false,\"showMin\":false,\"showMax\":false,\"showAvg\":true,\"showTotal\":false,\"showLatest\":false},\"customLegendEnabled\":false,\"showSubtitle\":true,\"subtitle\":\"${entityName}\",\"subtitleFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"subtitleColor\":\"rgba(0, 0, 0, 0.38)\",\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"dateColor\":\"rgba(0, 0, 0, 0.38)\",\"showChart\":true,\"chartColor\":\"rgba(0, 0, 0, 0.87)\",\"background\":{\"type\":\"image\",\"imageBase64\":\"data:image/png;base64,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\",\"imageUrl\":null,\"color\":\"#fff\",\"overlay\":{\"enabled\":true,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Humidity\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"mdi:water-percent\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"24px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":false,\"displayTimewindow\":true,\"decimals\":0,\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"24px\",\"icon\":null,\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":false},\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null}" + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"Main building\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Humidity\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{\"showLines\":true,\"fillLines\":true,\"showPoints\":false},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 7;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"#4caf50\",\"settings\":{\"position\":\"center\",\"font\":{\"size\":52,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"1\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":0,\"to\":20,\"color\":\"#DE2343\"},{\"from\":20,\"to\":40,\"color\":\"#F89E0D\"},{\"from\":40,\"to\":60,\"color\":\"#5579E5\"},{\"from\":60,\"to\":80,\"color\":\"#2B54CE\"},{\"from\":80,\"to\":100,\"color\":\"#224AC2\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.9408410830697858,\"funcBody\":\"var value = prevValue + Math.random() * 7;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta percent\",\"color\":\"#f44336\",\"settings\":{\"position\":\"rightTop\",\"font\":{\"size\":14,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"20px\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[{\"from\":null,\"to\":0,\"color\":\"#198038\"},{\"from\":0,\"to\":0,\"color\":\"rgba(0, 0, 0, 0.87)\"},{\"from\":0,\"to\":null,\"color\":\"#D12730\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":true},\"_hash\":0.06392321853157967,\"funcBody\":\"var value = prevValue + Math.random() * 6 - 3;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < -25) {\\n\\tvalue = -25;\\n} else if (value > 25) {\\n\\tvalue = 25;\\n} \\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta absolute\",\"color\":\"#607d8b\",\"settings\":{\"position\":\"rightBottom\",\"font\":{\"size\":11,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.44695098620509865,\"funcBody\":\"var value = prevValue + Math.random() * 4 - 2;\\nif (value < -6) {\\n\\tvalue = -6;\\n} else if (value > 6) {\\n\\tvalue = 6;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":1,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1691927717318,\"endTimeMs\":1692014117318},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"stack\":false,\"fontSize\":10,\"fontColor\":\"#545454\",\"showTooltip\":true,\"tooltipIndividual\":false,\"tooltipCumulative\":false,\"hideZeros\":false,\"grid\":{\"verticalLines\":true,\"horizontalLines\":true,\"outlineWidth\":1,\"color\":\"#545454\",\"backgroundColor\":null,\"tickColor\":\"#DDDDDD\"},\"xaxis\":{\"title\":null,\"showLabels\":true,\"color\":\"#545454\"},\"yaxis\":{\"min\":null,\"max\":null,\"title\":null,\"showLabels\":true,\"color\":\"#545454\",\"tickSize\":null,\"tickDecimals\":0,\"ticksFormatter\":\"\"},\"shadowSize\":4,\"smoothLines\":false,\"comparisonEnabled\":false,\"xaxisSecond\":{\"axisPosition\":\"top\",\"title\":null,\"showLabels\":true},\"showLegend\":true,\"legendConfig\":{\"direction\":\"column\",\"position\":\"bottom\",\"sortDataKeys\":false,\"showMin\":false,\"showMax\":false,\"showAvg\":true,\"showTotal\":false,\"showLatest\":false},\"customLegendEnabled\":false,\"showSubtitle\":true,\"subtitle\":\"${entityName}\",\"subtitleFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"subtitleColor\":\"rgba(0, 0, 0, 0.38)\",\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"dateColor\":\"rgba(0, 0, 0, 0.38)\",\"showChart\":true,\"chartColor\":\"rgba(0, 0, 0, 0.87)\",\"background\":{\"type\":\"image\",\"imageBase64\":\"data:image/png;base64,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\",\"imageUrl\":null,\"color\":\"#fff\",\"overlay\":{\"enabled\":true,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Humidity\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"mdi:water-percent\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"24px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":false,\"displayTimewindow\":true,\"decimals\":0,\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"24px\",\"icon\":null,\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":false},\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null}" }, "externalId": null, "tags": [ diff --git a/application/src/main/data/json/system/widget_types/noise_level_card.json b/application/src/main/data/json/system/widget_types/noise_level_card.json new file mode 100644 index 0000000000..03d2551fdf --- /dev/null +++ b/application/src/main/data/json/system/widget_types/noise_level_card.json @@ -0,0 +1,28 @@ +{ + "fqn": "noise_level_card", + "name": "Noise level card", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays a latest noise level telemetry data in a box layout.", + "descriptor": { + "type": "latest", + "sizeX": 3, + "sizeY": 3, + "resources": [], + "templateHtml": "\n", + "templateCss": "", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueCardWidget.onDataUpdated();\n};\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '250px',\n previewHeight: '250px',\n embedTitlePanel: true,\n defaultDataKeysFunction: function() {\n return [{ name: 'noise', label: 'Noise level ', type: 'timeseries' }];\n }\n };\n};\n\nself.onDestroy = function() {\n};\n", + "settingsSchema": "", + "dataKeySettingsSchema": "", + "settingsDirective": "tb-value-card-widget-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"function\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Noise level\",\"color\":\"#2196f3\",\"settings\":{},\"_hash\":0.2392660816082064,\"funcBody\":\"var value;\\nif (!prevValue) {\\n value = Math.random() * 120;\\n} else {\\n value = prevValue + Math.random() * 40 - 20;\\n}\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 120) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]}}],\"timewindow\":{\"realtime\":{\"timewindowMs\":60000}},\"showTitle\":false,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"padding\":\"0px\",\"settings\":{\"labelPosition\":\"top\",\"layout\":\"square\",\"showLabel\":true,\"labelFont\":{\"family\":\"Roboto\",\"size\":16,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"labelColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showIcon\":true,\"iconSize\":40,\"iconSizeUnit\":\"px\",\"icon\":\"bar_chart\",\"iconColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":50,\"color\":\"#80C32C\"},{\"from\":50,\"to\":70,\"color\":\"#FFA600\"},{\"from\":70,\"to\":90,\"color\":\"#F36900\"},{\"from\":90,\"to\":null,\"color\":\"#D81838\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"valueFont\":{\"family\":\"Roboto\",\"size\":52,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\",\"rangeList\":[{\"from\":null,\"to\":50,\"color\":\"#80C32C\"},{\"from\":50,\"to\":70,\"color\":\"#FFA600\"},{\"from\":70,\"to\":90,\"color\":\"#F36900\"},{\"from\":90,\"to\":null,\"color\":\"#D81838\"}]},\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"dateColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"color\",\"color\":\"#fff\",\"overlay\":{\"enabled\":false,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Noise level card\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"units\":\"dB\",\"decimals\":0,\"useDashboardTimewindow\":true,\"showLegend\":false,\"widgetStyle\":{},\"actions\":{},\"configMode\":\"basic\",\"displayTimewindow\":true,\"margin\":\"0px\",\"borderRadius\":\"0px\",\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"showTitleIcon\":false,\"titleTooltip\":\"\",\"titleFont\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1.6\"},\"titleIcon\":\"\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"iconSize\":\"14px\",\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"14px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1\"},\"color\":null}}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "noise" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/noise_level_card_with_background.json b/application/src/main/data/json/system/widget_types/noise_level_card_with_background.json new file mode 100644 index 0000000000..8b01223e7e --- /dev/null +++ b/application/src/main/data/json/system/widget_types/noise_level_card_with_background.json @@ -0,0 +1,28 @@ +{ + "fqn": "noise_level_card_with_background", + "name": "Noise level card with background", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays a latest noise level telemetry data in a box layout with background.", + "descriptor": { + "type": "latest", + "sizeX": 3, + "sizeY": 3, + "resources": [], + "templateHtml": "\n", + "templateCss": "", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueCardWidget.onDataUpdated();\n};\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '250px',\n previewHeight: '250px',\n embedTitlePanel: true,\n defaultDataKeysFunction: function() {\n return [{ name: 'noise', label: 'Noise level ', type: 'timeseries' }];\n }\n };\n};\n\nself.onDestroy = function() {\n};\n", + "settingsSchema": "", + "dataKeySettingsSchema": "", + "settingsDirective": "tb-value-card-widget-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"function\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Noise level\",\"color\":\"#2196f3\",\"settings\":{},\"_hash\":0.2392660816082064,\"funcBody\":\"var value;\\nif (!prevValue) {\\n value = Math.random() * 120;\\n} else {\\n value = prevValue + Math.random() * 40 - 20;\\n}\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 120) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]}}],\"timewindow\":{\"realtime\":{\"timewindowMs\":60000}},\"showTitle\":false,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"padding\":\"0px\",\"settings\":{\"labelPosition\":\"top\",\"layout\":\"square\",\"showLabel\":true,\"labelFont\":{\"family\":\"Roboto\",\"size\":16,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"labelColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showIcon\":true,\"iconSize\":40,\"iconSizeUnit\":\"px\",\"icon\":\"bar_chart\",\"iconColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":50,\"color\":\"#7CC322\"},{\"from\":50,\"to\":70,\"color\":\"#F89E0D\"},{\"from\":70,\"to\":90,\"color\":\"#F77410\"},{\"from\":90,\"to\":null,\"color\":\"#DE2343\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"valueFont\":{\"family\":\"Roboto\",\"size\":52,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\",\"rangeList\":[{\"from\":null,\"to\":50,\"color\":\"#7CC322\"},{\"from\":50,\"to\":70,\"color\":\"#F89E0D\"},{\"from\":70,\"to\":90,\"color\":\"#F77410\"},{\"from\":90,\"to\":null,\"color\":\"#DE2343\"}]},\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"dateColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"image\",\"imageBase64\":\"data:image/png;base64,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\",\"imageUrl\":null,\"color\":\"#fff\",\"overlay\":{\"enabled\":true,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Noise level card\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"units\":\"dB\",\"decimals\":0,\"useDashboardTimewindow\":true,\"showLegend\":false,\"widgetStyle\":{},\"actions\":{},\"configMode\":\"basic\",\"displayTimewindow\":true,\"margin\":\"0px\",\"borderRadius\":\"0px\",\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"showTitleIcon\":false,\"titleTooltip\":\"\",\"titleFont\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1.6\"},\"titleIcon\":\"\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"iconSize\":\"14px\",\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"14px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1\"},\"color\":null}}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "noise" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/noise_level_chart_card.json b/application/src/main/data/json/system/widget_types/noise_level_chart_card.json new file mode 100644 index 0000000000..d267ffb8ca --- /dev/null +++ b/application/src/main/data/json/system/widget_types/noise_level_chart_card.json @@ -0,0 +1,31 @@ +{ + "fqn": "noise_level_chart_card", + "name": "Noise level chart card", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays a noise level data as a combination of the latest and aggregated values. Optionally may display the corresponding historical values as a simplified chart.", + "descriptor": { + "type": "timeseries", + "sizeX": 4.5, + "sizeY": 3.5, + "resources": [], + "templateHtml": "\n\n", + "templateCss": ".legend {\n font-size: 13px;\n line-height: 10px;\n}\n\n.legend table { \n border-spacing: 0px;\n border-collapse: separate;\n}\n\n.mouse-events .flot-overlay {\n cursor: crosshair; \n}\n\n", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onDataUpdated();\n};\n\nself.onLatestDataUpdated = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onLatestDataUpdated();\n}\n\nself.onResize = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onResize();\n}\n\nself.onEditModeChanged = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onEditModeChanged();\n}\n\nself.onDestroy = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onDestroy();\n}\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '400px',\n previewHeight: '300px',\n embedTitlePanel: true,\n hasAdditionalLatestDataKeys: true,\n defaultDataKeysFunction: function() {\n return [\n { name: 'noise', label: 'Noise level', type: 'timeseries', color: 'rgba(0, 0, 0, 0.87)', units: 'dB', decimals: 0 }\n ];\n },\n defaultLatestDataKeysFunction: function(configComponent, configData) {\n return configComponent.createDefaultAggregatedValueLatestDataKeys(configData, 'noise', 'dB', 0);\n }\n };\n}\n", + "settingsSchema": "{}", + "dataKeySettingsSchema": "{}", + "latestDataKeySettingsSchema": "{}", + "settingsDirective": "tb-aggregated-value-card-widget-settings", + "dataKeySettingsDirective": "", + "latestDataKeySettingsDirective": "tb-aggregated-value-card-key-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-aggregated-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"Main building\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Noise level\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{\"showLines\":true,\"fillLines\":true,\"showPoints\":false},\"_hash\":0.8587686344902596,\"funcBody\":\"var value;\\nif (!prevValue) {\\n value = Math.random() * 120;\\n} else {\\n value = prevValue + Math.random() * 40 - 20;\\n}\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 120) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"dB\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"#4caf50\",\"settings\":{\"position\":\"center\",\"font\":{\"size\":52,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"1\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":50,\"color\":\"#80C32C\"},{\"from\":50,\"to\":70,\"color\":\"#FFA600\"},{\"from\":70,\"to\":90,\"color\":\"#F36900\"},{\"from\":90,\"to\":null,\"color\":\"#D81838\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.9408410830697858,\"funcBody\":\"var value;\\nif (!prevValue) {\\n value = Math.random() * 120;\\n} else {\\n value = prevValue + Math.random() * 40 - 20;\\n}\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 120) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"dB\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta percent\",\"color\":\"#f44336\",\"settings\":{\"position\":\"rightTop\",\"font\":{\"size\":14,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"20px\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[{\"from\":null,\"to\":0,\"color\":\"#198038\"},{\"from\":0,\"to\":0,\"color\":\"rgba(0, 0, 0, 0.87)\"},{\"from\":0,\"to\":null,\"color\":\"#D12730\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":true},\"_hash\":0.06392321853157967,\"funcBody\":\"var value = prevValue + Math.random() * 6 - 3;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < -25) {\\n\\tvalue = -25;\\n} else if (value > 25) {\\n\\tvalue = 25;\\n} \\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta absolute\",\"color\":\"#607d8b\",\"settings\":{\"position\":\"rightBottom\",\"font\":{\"size\":11,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.44695098620509865,\"funcBody\":\"var value = prevValue + Math.random() * 20 - 10;\\nif (value < -20) {\\n\\tvalue = -20;\\n} else if (value > 20) {\\n\\tvalue = 20;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"dB\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1691927717318,\"endTimeMs\":1692014117318},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"stack\":false,\"fontSize\":10,\"fontColor\":\"#545454\",\"showTooltip\":true,\"tooltipIndividual\":false,\"tooltipCumulative\":false,\"hideZeros\":false,\"grid\":{\"verticalLines\":true,\"horizontalLines\":true,\"outlineWidth\":1,\"color\":\"#545454\",\"backgroundColor\":null,\"tickColor\":\"#DDDDDD\"},\"xaxis\":{\"title\":null,\"showLabels\":true,\"color\":\"#545454\"},\"yaxis\":{\"min\":null,\"max\":null,\"title\":null,\"showLabels\":true,\"color\":\"#545454\",\"tickSize\":null,\"tickDecimals\":0,\"ticksFormatter\":\"\"},\"shadowSize\":4,\"smoothLines\":false,\"comparisonEnabled\":false,\"xaxisSecond\":{\"axisPosition\":\"top\",\"title\":null,\"showLabels\":true},\"showLegend\":true,\"legendConfig\":{\"direction\":\"column\",\"position\":\"bottom\",\"sortDataKeys\":false,\"showMin\":false,\"showMax\":false,\"showAvg\":true,\"showTotal\":false,\"showLatest\":false},\"customLegendEnabled\":false,\"showSubtitle\":true,\"subtitle\":\"${entityName}\",\"subtitleFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"subtitleColor\":\"rgba(0, 0, 0, 0.38)\",\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"dateColor\":\"rgba(0, 0, 0, 0.38)\",\"showChart\":true,\"chartColor\":\"rgba(0, 0, 0, 0.87)\",\"background\":{\"type\":\"color\",\"color\":\"#fff\",\"overlay\":{\"enabled\":false,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Noise level\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"bar_chart\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"24px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":false,\"displayTimewindow\":true,\"decimals\":0,\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"24px\",\"icon\":null,\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":false},\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "noise" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/noise_level_chart_card_with_background.json b/application/src/main/data/json/system/widget_types/noise_level_chart_card_with_background.json new file mode 100644 index 0000000000..e263ea286a --- /dev/null +++ b/application/src/main/data/json/system/widget_types/noise_level_chart_card_with_background.json @@ -0,0 +1,31 @@ +{ + "fqn": "noise_level_chart_card_with_background", + "name": "Noise level chart card with background", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays a noise level data as a combination of the latest and aggregated values with background. Optionally may display the corresponding historical values as a simplified chart.", + "descriptor": { + "type": "timeseries", + "sizeX": 4.5, + "sizeY": 3.5, + "resources": [], + "templateHtml": "\n\n", + "templateCss": ".legend {\n font-size: 13px;\n line-height: 10px;\n}\n\n.legend table { \n border-spacing: 0px;\n border-collapse: separate;\n}\n\n.mouse-events .flot-overlay {\n cursor: crosshair; \n}\n\n", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onDataUpdated();\n};\n\nself.onLatestDataUpdated = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onLatestDataUpdated();\n}\n\nself.onResize = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onResize();\n}\n\nself.onEditModeChanged = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onEditModeChanged();\n}\n\nself.onDestroy = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onDestroy();\n}\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '400px',\n previewHeight: '300px',\n embedTitlePanel: true,\n hasAdditionalLatestDataKeys: true,\n defaultDataKeysFunction: function() {\n return [\n { name: 'noise', label: 'Noise level', type: 'timeseries', color: 'rgba(0, 0, 0, 0.87)', units: 'dB', decimals: 0 }\n ];\n },\n defaultLatestDataKeysFunction: function(configComponent, configData) {\n return configComponent.createDefaultAggregatedValueLatestDataKeys(configData, 'noise', 'dB', 0);\n }\n };\n}\n", + "settingsSchema": "{}", + "dataKeySettingsSchema": "{}", + "latestDataKeySettingsSchema": "{}", + "settingsDirective": "tb-aggregated-value-card-widget-settings", + "dataKeySettingsDirective": "", + "latestDataKeySettingsDirective": "tb-aggregated-value-card-key-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-aggregated-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"Main building\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Noise level\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{\"showLines\":true,\"fillLines\":true,\"showPoints\":false},\"_hash\":0.8587686344902596,\"funcBody\":\"var value;\\nif (!prevValue) {\\n value = Math.random() * 120;\\n} else {\\n value = prevValue + Math.random() * 40 - 20;\\n}\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 120) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"dB\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"#4caf50\",\"settings\":{\"position\":\"center\",\"font\":{\"size\":52,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"1\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":50,\"color\":\"#7CC322\"},{\"from\":50,\"to\":70,\"color\":\"#F89E0D\"},{\"from\":70,\"to\":90,\"color\":\"#F77410\"},{\"from\":90,\"to\":null,\"color\":\"#DE2343\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.9408410830697858,\"funcBody\":\"var value;\\nif (!prevValue) {\\n value = Math.random() * 120;\\n} else {\\n value = prevValue + Math.random() * 40 - 20;\\n}\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 120) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"dB\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta percent\",\"color\":\"#f44336\",\"settings\":{\"position\":\"rightTop\",\"font\":{\"size\":14,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"20px\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[{\"from\":null,\"to\":0,\"color\":\"#198038\"},{\"from\":0,\"to\":0,\"color\":\"rgba(0, 0, 0, 0.87)\"},{\"from\":0,\"to\":null,\"color\":\"#D12730\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":true},\"_hash\":0.06392321853157967,\"funcBody\":\"var value = prevValue + Math.random() * 6 - 3;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < -25) {\\n\\tvalue = -25;\\n} else if (value > 25) {\\n\\tvalue = 25;\\n} \\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta absolute\",\"color\":\"#607d8b\",\"settings\":{\"position\":\"rightBottom\",\"font\":{\"size\":11,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.44695098620509865,\"funcBody\":\"var value = prevValue + Math.random() * 20 - 10;\\nif (value < -20) {\\n\\tvalue = -20;\\n} else if (value > 20) {\\n\\tvalue = 20;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"dB\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1691927717318,\"endTimeMs\":1692014117318},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"stack\":false,\"fontSize\":10,\"fontColor\":\"#545454\",\"showTooltip\":true,\"tooltipIndividual\":false,\"tooltipCumulative\":false,\"hideZeros\":false,\"grid\":{\"verticalLines\":true,\"horizontalLines\":true,\"outlineWidth\":1,\"color\":\"#545454\",\"backgroundColor\":null,\"tickColor\":\"#DDDDDD\"},\"xaxis\":{\"title\":null,\"showLabels\":true,\"color\":\"#545454\"},\"yaxis\":{\"min\":null,\"max\":null,\"title\":null,\"showLabels\":true,\"color\":\"#545454\",\"tickSize\":null,\"tickDecimals\":0,\"ticksFormatter\":\"\"},\"shadowSize\":4,\"smoothLines\":false,\"comparisonEnabled\":false,\"xaxisSecond\":{\"axisPosition\":\"top\",\"title\":null,\"showLabels\":true},\"showLegend\":true,\"legendConfig\":{\"direction\":\"column\",\"position\":\"bottom\",\"sortDataKeys\":false,\"showMin\":false,\"showMax\":false,\"showAvg\":true,\"showTotal\":false,\"showLatest\":false},\"customLegendEnabled\":false,\"showSubtitle\":true,\"subtitle\":\"${entityName}\",\"subtitleFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"subtitleColor\":\"rgba(0, 0, 0, 0.38)\",\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"dateColor\":\"rgba(0, 0, 0, 0.38)\",\"showChart\":true,\"chartColor\":\"rgba(0, 0, 0, 0.87)\",\"background\":{\"type\":\"image\",\"imageBase64\":\"data:image/png;base64,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\",\"imageUrl\":null,\"color\":\"#fff\",\"overlay\":{\"enabled\":true,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Noise level\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"bar_chart\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"24px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":false,\"displayTimewindow\":true,\"decimals\":0,\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"24px\",\"icon\":null,\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":false},\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "noise" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/pressure_chart_card.json b/application/src/main/data/json/system/widget_types/pressure_chart_card.json index 475189d065..db218a4160 100644 --- a/application/src/main/data/json/system/widget_types/pressure_chart_card.json +++ b/application/src/main/data/json/system/widget_types/pressure_chart_card.json @@ -20,7 +20,7 @@ "latestDataKeySettingsDirective": "tb-aggregated-value-card-key-settings", "hasBasicMode": true, "basicModeDirective": "tb-aggregated-value-card-basic-config", - "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"Main building\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Pressure\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{\"showLines\":true,\"fillLines\":true,\"showPoints\":false},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 80 - 40;\\nif (value < 980) {\\n\\tvalue = 980;\\n} else if (value > 1040) {\\n\\tvalue = 1040;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"hPa\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"#4caf50\",\"settings\":{\"position\":\"center\",\"font\":{\"size\":52,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"1\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":1000,\"color\":\"#D81838\"},{\"from\":1000,\"to\":1020,\"color\":\"#80C32C\"},{\"from\":1020,\"to\":null,\"color\":\"#D81838\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.9408410830697858,\"funcBody\":\"var value = prevValue + Math.random() * 80 - 40;\\nif (value < 980) {\\n\\tvalue = 980;\\n} else if (value > 1040) {\\n\\tvalue = 1040;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"hPa\",\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta percent\",\"color\":\"#f44336\",\"settings\":{\"position\":\"rightTop\",\"font\":{\"size\":14,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"20px\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[{\"from\":null,\"to\":0,\"color\":\"#198038\"},{\"from\":0,\"to\":0,\"color\":\"rgba(0, 0, 0, 0.87)\"},{\"from\":0,\"to\":null,\"color\":\"#D12730\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":true},\"_hash\":0.06392321853157967,\"funcBody\":\"var value = prevValue + Math.random() * 6 - 3;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < -25) {\\n\\tvalue = -25;\\n} else if (value > 25) {\\n\\tvalue = 25;\\n} \\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta absolute\",\"color\":\"#607d8b\",\"settings\":{\"position\":\"rightBottom\",\"font\":{\"size\":11,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.44695098620509865,\"funcBody\":\"var value = prevValue + Math.random() * 4 - 2;\\nif (value < -6) {\\n\\tvalue = -6;\\n} else if (value > 6) {\\n\\tvalue = 6;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"hPa\",\"decimals\":1,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1691927717318,\"endTimeMs\":1692014117318},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"stack\":false,\"fontSize\":10,\"fontColor\":\"#545454\",\"showTooltip\":true,\"tooltipIndividual\":false,\"tooltipCumulative\":false,\"hideZeros\":false,\"grid\":{\"verticalLines\":true,\"horizontalLines\":true,\"outlineWidth\":1,\"color\":\"#545454\",\"backgroundColor\":null,\"tickColor\":\"#DDDDDD\"},\"xaxis\":{\"title\":null,\"showLabels\":true,\"color\":\"#545454\"},\"yaxis\":{\"min\":null,\"max\":null,\"title\":null,\"showLabels\":true,\"color\":\"#545454\",\"tickSize\":null,\"tickDecimals\":0,\"ticksFormatter\":\"\"},\"shadowSize\":4,\"smoothLines\":false,\"comparisonEnabled\":false,\"xaxisSecond\":{\"axisPosition\":\"top\",\"title\":null,\"showLabels\":true},\"showLegend\":true,\"legendConfig\":{\"direction\":\"column\",\"position\":\"bottom\",\"sortDataKeys\":false,\"showMin\":false,\"showMax\":false,\"showAvg\":true,\"showTotal\":false,\"showLatest\":false},\"customLegendEnabled\":false,\"showSubtitle\":true,\"subtitle\":\"${entityName}\",\"subtitleFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"subtitleColor\":\"rgba(0, 0, 0, 0.38)\",\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"dateColor\":\"rgba(0, 0, 0, 0.38)\",\"showChart\":true,\"chartColor\":\"rgba(0, 0, 0, 0.87)\",\"background\":{\"type\":\"color\",\"color\":\"#fff\",\"overlay\":{\"enabled\":false,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Pressure\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"compress\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"24px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":false,\"displayTimewindow\":true,\"decimals\":0,\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"24px\",\"icon\":null,\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":false},\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null}" + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"Main building\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Pressure\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{\"showLines\":true,\"fillLines\":true,\"showPoints\":false},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 80 - 40;\\nif (value < 980) {\\n\\tvalue = 980;\\n} else if (value > 1040) {\\n\\tvalue = 1040;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"hPa\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"#4caf50\",\"settings\":{\"position\":\"center\",\"font\":{\"size\":52,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"1\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":1000,\"color\":\"#D81838\"},{\"from\":1000,\"to\":1020,\"color\":\"#80C32C\"},{\"from\":1020,\"to\":null,\"color\":\"#D81838\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.9408410830697858,\"funcBody\":\"var value = prevValue + Math.random() * 80 - 40;\\nif (value < 980) {\\n\\tvalue = 980;\\n} else if (value > 1040) {\\n\\tvalue = 1040;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"hPa\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta percent\",\"color\":\"#f44336\",\"settings\":{\"position\":\"rightTop\",\"font\":{\"size\":14,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"20px\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[{\"from\":null,\"to\":0,\"color\":\"#198038\"},{\"from\":0,\"to\":0,\"color\":\"rgba(0, 0, 0, 0.87)\"},{\"from\":0,\"to\":null,\"color\":\"#D12730\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":true},\"_hash\":0.06392321853157967,\"funcBody\":\"var value = prevValue + Math.random() * 6 - 3;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < -25) {\\n\\tvalue = -25;\\n} else if (value > 25) {\\n\\tvalue = 25;\\n} \\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta absolute\",\"color\":\"#607d8b\",\"settings\":{\"position\":\"rightBottom\",\"font\":{\"size\":11,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.44695098620509865,\"funcBody\":\"var value = prevValue + Math.random() * 4 - 2;\\nif (value < -6) {\\n\\tvalue = -6;\\n} else if (value > 6) {\\n\\tvalue = 6;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"hPa\",\"decimals\":1,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1691927717318,\"endTimeMs\":1692014117318},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"stack\":false,\"fontSize\":10,\"fontColor\":\"#545454\",\"showTooltip\":true,\"tooltipIndividual\":false,\"tooltipCumulative\":false,\"hideZeros\":false,\"grid\":{\"verticalLines\":true,\"horizontalLines\":true,\"outlineWidth\":1,\"color\":\"#545454\",\"backgroundColor\":null,\"tickColor\":\"#DDDDDD\"},\"xaxis\":{\"title\":null,\"showLabels\":true,\"color\":\"#545454\"},\"yaxis\":{\"min\":null,\"max\":null,\"title\":null,\"showLabels\":true,\"color\":\"#545454\",\"tickSize\":null,\"tickDecimals\":0,\"ticksFormatter\":\"\"},\"shadowSize\":4,\"smoothLines\":false,\"comparisonEnabled\":false,\"xaxisSecond\":{\"axisPosition\":\"top\",\"title\":null,\"showLabels\":true},\"showLegend\":true,\"legendConfig\":{\"direction\":\"column\",\"position\":\"bottom\",\"sortDataKeys\":false,\"showMin\":false,\"showMax\":false,\"showAvg\":true,\"showTotal\":false,\"showLatest\":false},\"customLegendEnabled\":false,\"showSubtitle\":true,\"subtitle\":\"${entityName}\",\"subtitleFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"subtitleColor\":\"rgba(0, 0, 0, 0.38)\",\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"dateColor\":\"rgba(0, 0, 0, 0.38)\",\"showChart\":true,\"chartColor\":\"rgba(0, 0, 0, 0.87)\",\"background\":{\"type\":\"color\",\"color\":\"#fff\",\"overlay\":{\"enabled\":false,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Pressure\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"compress\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"24px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":false,\"displayTimewindow\":true,\"decimals\":0,\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"24px\",\"icon\":null,\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":false},\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null}" }, "externalId": null, "tags": [ diff --git a/application/src/main/data/json/system/widget_types/pressure_chart_card_with_background.json b/application/src/main/data/json/system/widget_types/pressure_chart_card_with_background.json index 63ba24c45e..5e005284bc 100644 --- a/application/src/main/data/json/system/widget_types/pressure_chart_card_with_background.json +++ b/application/src/main/data/json/system/widget_types/pressure_chart_card_with_background.json @@ -20,7 +20,7 @@ "latestDataKeySettingsDirective": "tb-aggregated-value-card-key-settings", "hasBasicMode": true, "basicModeDirective": "tb-aggregated-value-card-basic-config", - "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"Main building\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Pressure\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{\"showLines\":true,\"fillLines\":true,\"showPoints\":false},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 80 - 40;\\nif (value < 980) {\\n\\tvalue = 980;\\n} else if (value > 1040) {\\n\\tvalue = 1040;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"hPa\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"#4caf50\",\"settings\":{\"position\":\"center\",\"font\":{\"size\":52,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"1\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":1000,\"color\":\"#DE2343\"},{\"from\":1000,\"to\":1020,\"color\":\"#7CC322\"},{\"from\":1020,\"to\":null,\"color\":\"#DE2343\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.9408410830697858,\"funcBody\":\"var value = prevValue + Math.random() * 80 - 40;\\nif (value < 980) {\\n\\tvalue = 980;\\n} else if (value > 1040) {\\n\\tvalue = 1040;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"hPa\",\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta percent\",\"color\":\"#f44336\",\"settings\":{\"position\":\"rightTop\",\"font\":{\"size\":14,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"20px\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[{\"from\":null,\"to\":0,\"color\":\"#198038\"},{\"from\":0,\"to\":0,\"color\":\"rgba(0, 0, 0, 0.87)\"},{\"from\":0,\"to\":null,\"color\":\"#D12730\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":true},\"_hash\":0.06392321853157967,\"funcBody\":\"var value = prevValue + Math.random() * 6 - 3;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < -25) {\\n\\tvalue = -25;\\n} else if (value > 25) {\\n\\tvalue = 25;\\n} \\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta absolute\",\"color\":\"#607d8b\",\"settings\":{\"position\":\"rightBottom\",\"font\":{\"size\":11,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.44695098620509865,\"funcBody\":\"var value = prevValue + Math.random() * 4 - 2;\\nif (value < -6) {\\n\\tvalue = -6;\\n} else if (value > 6) {\\n\\tvalue = 6;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"hPa\",\"decimals\":1,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1691927717318,\"endTimeMs\":1692014117318},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"stack\":false,\"fontSize\":10,\"fontColor\":\"#545454\",\"showTooltip\":true,\"tooltipIndividual\":false,\"tooltipCumulative\":false,\"hideZeros\":false,\"grid\":{\"verticalLines\":true,\"horizontalLines\":true,\"outlineWidth\":1,\"color\":\"#545454\",\"backgroundColor\":null,\"tickColor\":\"#DDDDDD\"},\"xaxis\":{\"title\":null,\"showLabels\":true,\"color\":\"#545454\"},\"yaxis\":{\"min\":null,\"max\":null,\"title\":null,\"showLabels\":true,\"color\":\"#545454\",\"tickSize\":null,\"tickDecimals\":0,\"ticksFormatter\":\"\"},\"shadowSize\":4,\"smoothLines\":false,\"comparisonEnabled\":false,\"xaxisSecond\":{\"axisPosition\":\"top\",\"title\":null,\"showLabels\":true},\"showLegend\":true,\"legendConfig\":{\"direction\":\"column\",\"position\":\"bottom\",\"sortDataKeys\":false,\"showMin\":false,\"showMax\":false,\"showAvg\":true,\"showTotal\":false,\"showLatest\":false},\"customLegendEnabled\":false,\"showSubtitle\":true,\"subtitle\":\"${entityName}\",\"subtitleFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"subtitleColor\":\"rgba(0, 0, 0, 0.38)\",\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"dateColor\":\"rgba(0, 0, 0, 0.38)\",\"showChart\":true,\"chartColor\":\"rgba(0, 0, 0, 0.87)\",\"background\":{\"type\":\"image\",\"imageBase64\":\"data:image/png;base64,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\",\"imageUrl\":null,\"color\":\"#fff\",\"overlay\":{\"enabled\":true,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Pressure\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"compress\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"24px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":false,\"displayTimewindow\":true,\"decimals\":0,\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"24px\",\"icon\":null,\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":false},\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null}" + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"Main building\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Pressure\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{\"showLines\":true,\"fillLines\":true,\"showPoints\":false},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 80 - 40;\\nif (value < 980) {\\n\\tvalue = 980;\\n} else if (value > 1040) {\\n\\tvalue = 1040;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"hPa\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"#4caf50\",\"settings\":{\"position\":\"center\",\"font\":{\"size\":52,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"1\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":1000,\"color\":\"#DE2343\"},{\"from\":1000,\"to\":1020,\"color\":\"#7CC322\"},{\"from\":1020,\"to\":null,\"color\":\"#DE2343\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.9408410830697858,\"funcBody\":\"var value = prevValue + Math.random() * 80 - 40;\\nif (value < 980) {\\n\\tvalue = 980;\\n} else if (value > 1040) {\\n\\tvalue = 1040;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"hPa\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta percent\",\"color\":\"#f44336\",\"settings\":{\"position\":\"rightTop\",\"font\":{\"size\":14,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"20px\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[{\"from\":null,\"to\":0,\"color\":\"#198038\"},{\"from\":0,\"to\":0,\"color\":\"rgba(0, 0, 0, 0.87)\"},{\"from\":0,\"to\":null,\"color\":\"#D12730\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":true},\"_hash\":0.06392321853157967,\"funcBody\":\"var value = prevValue + Math.random() * 6 - 3;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < -25) {\\n\\tvalue = -25;\\n} else if (value > 25) {\\n\\tvalue = 25;\\n} \\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta absolute\",\"color\":\"#607d8b\",\"settings\":{\"position\":\"rightBottom\",\"font\":{\"size\":11,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.44695098620509865,\"funcBody\":\"var value = prevValue + Math.random() * 4 - 2;\\nif (value < -6) {\\n\\tvalue = -6;\\n} else if (value > 6) {\\n\\tvalue = 6;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"hPa\",\"decimals\":1,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1691927717318,\"endTimeMs\":1692014117318},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"stack\":false,\"fontSize\":10,\"fontColor\":\"#545454\",\"showTooltip\":true,\"tooltipIndividual\":false,\"tooltipCumulative\":false,\"hideZeros\":false,\"grid\":{\"verticalLines\":true,\"horizontalLines\":true,\"outlineWidth\":1,\"color\":\"#545454\",\"backgroundColor\":null,\"tickColor\":\"#DDDDDD\"},\"xaxis\":{\"title\":null,\"showLabels\":true,\"color\":\"#545454\"},\"yaxis\":{\"min\":null,\"max\":null,\"title\":null,\"showLabels\":true,\"color\":\"#545454\",\"tickSize\":null,\"tickDecimals\":0,\"ticksFormatter\":\"\"},\"shadowSize\":4,\"smoothLines\":false,\"comparisonEnabled\":false,\"xaxisSecond\":{\"axisPosition\":\"top\",\"title\":null,\"showLabels\":true},\"showLegend\":true,\"legendConfig\":{\"direction\":\"column\",\"position\":\"bottom\",\"sortDataKeys\":false,\"showMin\":false,\"showMax\":false,\"showAvg\":true,\"showTotal\":false,\"showLatest\":false},\"customLegendEnabled\":false,\"showSubtitle\":true,\"subtitle\":\"${entityName}\",\"subtitleFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"subtitleColor\":\"rgba(0, 0, 0, 0.38)\",\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"dateColor\":\"rgba(0, 0, 0, 0.38)\",\"showChart\":true,\"chartColor\":\"rgba(0, 0, 0, 0.87)\",\"background\":{\"type\":\"image\",\"imageBase64\":\"data:image/png;base64,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\",\"imageUrl\":null,\"color\":\"#fff\",\"overlay\":{\"enabled\":true,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Pressure\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"compress\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"24px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":false,\"displayTimewindow\":true,\"decimals\":0,\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"24px\",\"icon\":null,\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":false},\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null}" }, "externalId": null, "tags": [ diff --git a/application/src/main/data/json/system/widget_types/simple_noise_level_chart_card.json b/application/src/main/data/json/system/widget_types/simple_noise_level_chart_card.json new file mode 100644 index 0000000000..0e94d387e5 --- /dev/null +++ b/application/src/main/data/json/system/widget_types/simple_noise_level_chart_card.json @@ -0,0 +1,31 @@ +{ + "fqn": "simple_noise_level_chart_card", + "name": "Simple noise level chart card", + "deprecated": false, + "image": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAMgAAACgCAMAAAB+IdObAAAAhFBMVEUAAADf39/g4ODf39/f39/g4OD////k5OSAwyzg4OAhISE8PDyQkJDHx8fy8vJ0dHSv2Xvv9+UvLy9YWFienp6Qy0asrKyg0mCIxzm6urqrq6v3+/JmZmaCgoLV1dXP6bDf8MrH5aPA4ZaYzlO43YhLS0vn9NhKSkrX7L2w2Xuo1m729vZb/Cn5AAAABnRSTlMAIL9AEN/GQiaNAAAEq0lEQVR42uzPwQ2AIBAAsBMQcx8WYf/9TJzAJ5B2gwYAAAAAAMB/7dpc+xq15LO5vGvElbNvb2SNMvoBZonsR0iRxYisRuRlt25WbQdhMAzPvkBiIqgUFOusrPu/w2Olm7N/OtzsZcGXSpN29ExKZ2tBZmtBZmtBZmtBZusXIUa4iwx3vQuSvQHNE65qwvc2xl3icNffQVz+snEFlPX/28dA2H+FsGJA1CUCUgbymCy57YJci7nWD4GSo3dDyL5DZBc7IS54EYN4OHFjetWQPiCHeNkRHDIThVhZ3wshdj8gFlyHGBf06YTUCnO0MXXcBcl92YLtEX5ciH4+CAon1m4BYj0hTUJtcCwS+IKcizApmxQcQSTEKSASP0MQAytx7oM/IWTqublAvQuSuI0lVCYclXozQqhD8Dpa4XJCZEdmVXak7oJY2McyvnEuZNrLbJB0jkkU9OKQgLijyZhKvxX0spxnPFMpAPbAkRAT7vsLiG0NmyJnPKb1rzVbCzJbCzJbCzJbCzJbCzJbCzJbE0Isb9qeD9HIZ7I9G2KRD5dJS2ShB0NMOF1jEaHnQjwrPqJwPBbyjz2zW04WBsLw2WYnIcHwI6loRaFWvf8L/Db5JAyFItYplRmeAwzGcfLM7pvI+M4DaJA8mKtIKFq3caTmKcJ42LqXfD1PkZAzaBGLuYiodbJuFi98QZqSzEMkiDixvakkXMIXYvFqIuotSWS3lUKp3usDY2MT0i3Ja4kkESdE0n7ztr0yweNgF/NYQYdYqGdFdA6eXHemV9nxkRTHUim5bR0MTGzrUfLJebyBHiTfPiWiK4OYHv+7HFJEc/nikuIKoEotZba/EwUe1IMEPGHExtSSfzQfU+xBEZ2SBqlkQBxJg8Zl3hVZocNP9qNE2BxxULPmyciujMJ3+y0ytP0p6Ga8yAXTwhmcSQrxmsMe8dgrorUurn6ylzWX3fAyIWAcLOQ8EoIuYbIOthG16WgRpFUSBiuwCprGGWZQcypyLwIWg1doGNpD41s/qS1nMBa22YVhIMGhNoLHb+PD7kUqLF1Q0NQaKVIFWiJpY9n/75eHiShhoOQHT+DHkIp4e0DkjHj2pXCFsWiblxLRi7juOwx1Fms3ikVIIJ5Q+RwrcjiubOd3RS6IJ5quRVaEGSoIiBhasCQIJDzNWBHbP6XuiLiUd3Ytsx96xthAH1OJnPcUg1R3RHLXRo1IURRnejkM/qSdgKGMaBf2a1tEI+6BaIU9Q/Nt1EUIfUwpQutMbxcXCvhW5GAt+xnYZn9dxC+WusotMncZL/2e3BG52M/0sht47p6gIsbl/IS4cqGoyM0f3hUa7fQakcKQZR/yY8BjChFapslKdGGHCjHLjB37cyTz58gNc4Iuajd0XEwiAvsUiUyD5ejHzcleXb2Ile7zkILvFAwyRdhPReHbPi+KVpbtVK5zoAtBgz8vhxd5jr8vx6+J7Pjn3XLMQySAu8xC5D6LyCIyFxaRV2MReTUWkVdjEXk1FpF/7dwxDcAwDABB11YjZSmR8ucXChkT647BE/jTCDlNo5BssA4a48uo2WAe9M8not77t1RZnUZhAAAAAAAAWxauHfe/D+cw4gAAAABJRU5ErkJggg==", + "description": "Displays historical noise level values as a simplified chart. Optionally may display the corresponding latest noise level value.", + "descriptor": { + "type": "timeseries", + "sizeX": 4.5, + "sizeY": 2, + "resources": [], + "templateHtml": "\n\n", + "templateCss": ".legend {\n font-size: 13px;\n line-height: 10px;\n}\n\n.legend table { \n border-spacing: 0px;\n border-collapse: separate;\n}\n\n.mouse-events .flot-overlay {\n cursor: crosshair; \n}\n\n", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueChartCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueChartCardWidget.onDataUpdated();\n};\n\nself.onLatestDataUpdated = function() {\n self.ctx.$scope.valueChartCardWidget.onLatestDataUpdated();\n}\n\nself.onEditModeChanged = function() {\n self.ctx.$scope.valueChartCardWidget.onEditModeChanged();\n}\n\nself.onDestroy = function() {\n self.ctx.$scope.valueChartCardWidget.onDestroy();\n}\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '300px',\n previewHeight: '150px',\n embedTitlePanel: true,\n hasAdditionalLatestDataKeys: true,\n defaultDataKeysFunction: function() {\n return [\n { name: 'noise', label: 'Noise level', type: 'timeseries', color: 'rgba(0, 0, 0, 0.87)'}\n ];\n },\n defaultLatestDataKeysFunction: function(configComponent) {\n return [{ name: 'noise', label: 'Latest', type: 'timeseries'}];\n }\n };\n}\n", + "settingsSchema": "{}", + "dataKeySettingsSchema": "{}", + "latestDataKeySettingsSchema": "{}", + "settingsDirective": "tb-value-chart-card-widget-settings", + "dataKeySettingsDirective": "", + "latestDataKeySettingsDirective": "", + "hasBasicMode": true, + "basicModeDirective": "tb-value-chart-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Noise level\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{},\"_hash\":0.8587686344902596,\"funcBody\":\"var value;\\nif (!prevValue) {\\n value = Math.random() * 120;\\n} else {\\n value = prevValue + Math.random() * 40 - 20;\\n}\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 120) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{},\"_hash\":0.8587686344902596,\"funcBody\":\"var value;\\nif (!prevValue) {\\n value = Math.random() * 120;\\n} else {\\n value = prevValue + Math.random() * 40 - 20;\\n}\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 120) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"layout\":\"left\",\"autoScale\":true,\"showValue\":true,\"valueFont\":{\"family\":\"Roboto\",\"size\":28,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\",\"lineHeight\":\"32px\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":50,\"color\":\"#80C32C\"},{\"from\":50,\"to\":70,\"color\":\"#FFA600\"},{\"from\":70,\"to\":90,\"color\":\"#F36900\"},{\"from\":90,\"to\":null,\"color\":\"#D81838\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"color\",\"color\":\"#fff\",\"overlay\":{\"enabled\":false,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}}},\"title\":\"Noise level\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":null,\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"bar_chart\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"18px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":true,\"decimals\":0,\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null,\"units\":\"dB\",\"displayTimewindow\":true,\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1697382151041,\"endTimeMs\":1697468551041},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"timewindowStyle\":{\"showIcon\":false,\"iconSize\":\"24px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":true}}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "noise" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/simple_noise_level_chart_card_with_background.json b/application/src/main/data/json/system/widget_types/simple_noise_level_chart_card_with_background.json new file mode 100644 index 0000000000..715d0d46ba --- /dev/null +++ b/application/src/main/data/json/system/widget_types/simple_noise_level_chart_card_with_background.json @@ -0,0 +1,31 @@ +{ + "fqn": "simple_noise_level_chart_card_with_background", + "name": "Simple noise level chart card with background", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays historical noise level values as a simplified chart with background. Optionally may display the corresponding latest noise level value.", + "descriptor": { + "type": "timeseries", + "sizeX": 4.5, + "sizeY": 2, + "resources": [], + "templateHtml": "\n\n", + "templateCss": ".legend {\n font-size: 13px;\n line-height: 10px;\n}\n\n.legend table { \n border-spacing: 0px;\n border-collapse: separate;\n}\n\n.mouse-events .flot-overlay {\n cursor: crosshair; \n}\n\n", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueChartCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueChartCardWidget.onDataUpdated();\n};\n\nself.onLatestDataUpdated = function() {\n self.ctx.$scope.valueChartCardWidget.onLatestDataUpdated();\n}\n\nself.onEditModeChanged = function() {\n self.ctx.$scope.valueChartCardWidget.onEditModeChanged();\n}\n\nself.onDestroy = function() {\n self.ctx.$scope.valueChartCardWidget.onDestroy();\n}\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '300px',\n previewHeight: '150px',\n embedTitlePanel: true,\n hasAdditionalLatestDataKeys: true,\n defaultDataKeysFunction: function() {\n return [\n { name: 'noise', label: 'Noise level', type: 'timeseries', color: 'rgba(0, 0, 0, 0.87)'}\n ];\n },\n defaultLatestDataKeysFunction: function(configComponent) {\n return [{ name: 'noise', label: 'Latest', type: 'timeseries'}];\n }\n };\n}\n", + "settingsSchema": "{}", + "dataKeySettingsSchema": "{}", + "latestDataKeySettingsSchema": "{}", + "settingsDirective": "tb-value-chart-card-widget-settings", + "dataKeySettingsDirective": "", + "latestDataKeySettingsDirective": "", + "hasBasicMode": true, + "basicModeDirective": "tb-value-chart-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Noise level\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{},\"_hash\":0.8587686344902596,\"funcBody\":\"var value;\\nif (!prevValue) {\\n value = Math.random() * 120;\\n} else {\\n value = prevValue + Math.random() * 40 - 20;\\n}\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 120) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{},\"_hash\":0.8587686344902596,\"funcBody\":\"var value;\\nif (!prevValue) {\\n value = Math.random() * 120;\\n} else {\\n value = prevValue + Math.random() * 40 - 20;\\n}\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 120) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"layout\":\"left\",\"autoScale\":true,\"showValue\":true,\"valueFont\":{\"family\":\"Roboto\",\"size\":28,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\",\"lineHeight\":\"32px\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":50,\"color\":\"#7CC322\"},{\"from\":50,\"to\":70,\"color\":\"#F89E0D\"},{\"from\":70,\"to\":90,\"color\":\"#F77410\"},{\"from\":90,\"to\":null,\"color\":\"#DE2343\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"image\",\"imageBase64\":\"data:image/png;base64,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\",\"imageUrl\":null,\"color\":\"#fff\",\"overlay\":{\"enabled\":true,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}}},\"title\":\"Noise level\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":null,\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"bar_chart\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"18px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":true,\"decimals\":0,\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null,\"units\":\"dB\",\"displayTimewindow\":true,\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1697382151041,\"endTimeMs\":1697468551041},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"timewindowStyle\":{\"showIcon\":false,\"iconSize\":\"24px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":true}}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "noise" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/soil_moisture_chart_card_with_background.json b/application/src/main/data/json/system/widget_types/soil_moisture_chart_card_with_background.json index 60624f716a..69aacadb7e 100644 --- a/application/src/main/data/json/system/widget_types/soil_moisture_chart_card_with_background.json +++ b/application/src/main/data/json/system/widget_types/soil_moisture_chart_card_with_background.json @@ -20,7 +20,7 @@ "latestDataKeySettingsDirective": "tb-aggregated-value-card-key-settings", "hasBasicMode": true, "basicModeDirective": "tb-aggregated-value-card-basic-config", - "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"Main building\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Soil Moisture\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{\"showLines\":true,\"fillLines\":true,\"showPoints\":false},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 7;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"#4caf50\",\"settings\":{\"position\":\"center\",\"font\":{\"size\":52,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"1\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":0,\"to\":20,\"color\":\"#DE2343\"},{\"from\":20,\"to\":40,\"color\":\"#F77410\"},{\"from\":40,\"to\":60,\"color\":\"#4369DD\"},{\"from\":60,\"to\":100,\"color\":\"#224AC2\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.9408410830697858,\"funcBody\":\"var value = prevValue + Math.random() * 7;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta percent\",\"color\":\"#f44336\",\"settings\":{\"position\":\"rightTop\",\"font\":{\"size\":14,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"20px\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[{\"from\":null,\"to\":0,\"color\":\"#198038\"},{\"from\":0,\"to\":0,\"color\":\"rgba(0, 0, 0, 0.87)\"},{\"from\":0,\"to\":null,\"color\":\"#D12730\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":true},\"_hash\":0.06392321853157967,\"funcBody\":\"var value = prevValue + Math.random() * 6 - 3;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < -25) {\\n\\tvalue = -25;\\n} else if (value > 25) {\\n\\tvalue = 25;\\n} \\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta absolute\",\"color\":\"#607d8b\",\"settings\":{\"position\":\"rightBottom\",\"font\":{\"size\":11,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.44695098620509865,\"funcBody\":\"var value = prevValue + Math.random() * 4 - 2;\\nif (value < -6) {\\n\\tvalue = -6;\\n} else if (value > 6) {\\n\\tvalue = 6;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":1,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1691927717318,\"endTimeMs\":1692014117318},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"stack\":false,\"fontSize\":10,\"fontColor\":\"#545454\",\"showTooltip\":true,\"tooltipIndividual\":false,\"tooltipCumulative\":false,\"hideZeros\":false,\"grid\":{\"verticalLines\":true,\"horizontalLines\":true,\"outlineWidth\":1,\"color\":\"#545454\",\"backgroundColor\":null,\"tickColor\":\"#DDDDDD\"},\"xaxis\":{\"title\":null,\"showLabels\":true,\"color\":\"#545454\"},\"yaxis\":{\"min\":null,\"max\":null,\"title\":null,\"showLabels\":true,\"color\":\"#545454\",\"tickSize\":null,\"tickDecimals\":0,\"ticksFormatter\":\"\"},\"shadowSize\":4,\"smoothLines\":false,\"comparisonEnabled\":false,\"xaxisSecond\":{\"axisPosition\":\"top\",\"title\":null,\"showLabels\":true},\"showLegend\":true,\"legendConfig\":{\"direction\":\"column\",\"position\":\"bottom\",\"sortDataKeys\":false,\"showMin\":false,\"showMax\":false,\"showAvg\":true,\"showTotal\":false,\"showLatest\":false},\"customLegendEnabled\":false,\"showSubtitle\":true,\"subtitle\":\"${entityName}\",\"subtitleFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"subtitleColor\":\"rgba(0, 0, 0, 0.38)\",\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"dateColor\":\"rgba(0, 0, 0, 0.38)\",\"showChart\":true,\"chartColor\":\"rgba(0, 0, 0, 0.87)\",\"background\":{\"type\":\"image\",\"imageBase64\":\"data:image/png;base64,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\",\"imageUrl\":null,\"color\":\"#fff\",\"overlay\":{\"enabled\":true,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Soil Moisture\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"mdi:water-percent\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"24px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":false,\"displayTimewindow\":true,\"decimals\":0,\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"24px\",\"icon\":null,\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":false},\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null}" + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"Main building\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Soil Moisture\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{\"showLines\":true,\"fillLines\":true,\"showPoints\":false},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 7;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"#4caf50\",\"settings\":{\"position\":\"center\",\"font\":{\"size\":52,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"1\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":0,\"to\":20,\"color\":\"#DE2343\"},{\"from\":20,\"to\":40,\"color\":\"#F77410\"},{\"from\":40,\"to\":60,\"color\":\"#4369DD\"},{\"from\":60,\"to\":100,\"color\":\"#224AC2\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.9408410830697858,\"funcBody\":\"var value = prevValue + Math.random() * 7;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta percent\",\"color\":\"#f44336\",\"settings\":{\"position\":\"rightTop\",\"font\":{\"size\":14,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"20px\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[{\"from\":null,\"to\":0,\"color\":\"#198038\"},{\"from\":0,\"to\":0,\"color\":\"rgba(0, 0, 0, 0.87)\"},{\"from\":0,\"to\":null,\"color\":\"#D12730\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":true},\"_hash\":0.06392321853157967,\"funcBody\":\"var value = prevValue + Math.random() * 6 - 3;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < -25) {\\n\\tvalue = -25;\\n} else if (value > 25) {\\n\\tvalue = 25;\\n} \\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta absolute\",\"color\":\"#607d8b\",\"settings\":{\"position\":\"rightBottom\",\"font\":{\"size\":11,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.44695098620509865,\"funcBody\":\"var value = prevValue + Math.random() * 4 - 2;\\nif (value < -6) {\\n\\tvalue = -6;\\n} else if (value > 6) {\\n\\tvalue = 6;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":1,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1691927717318,\"endTimeMs\":1692014117318},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"stack\":false,\"fontSize\":10,\"fontColor\":\"#545454\",\"showTooltip\":true,\"tooltipIndividual\":false,\"tooltipCumulative\":false,\"hideZeros\":false,\"grid\":{\"verticalLines\":true,\"horizontalLines\":true,\"outlineWidth\":1,\"color\":\"#545454\",\"backgroundColor\":null,\"tickColor\":\"#DDDDDD\"},\"xaxis\":{\"title\":null,\"showLabels\":true,\"color\":\"#545454\"},\"yaxis\":{\"min\":null,\"max\":null,\"title\":null,\"showLabels\":true,\"color\":\"#545454\",\"tickSize\":null,\"tickDecimals\":0,\"ticksFormatter\":\"\"},\"shadowSize\":4,\"smoothLines\":false,\"comparisonEnabled\":false,\"xaxisSecond\":{\"axisPosition\":\"top\",\"title\":null,\"showLabels\":true},\"showLegend\":true,\"legendConfig\":{\"direction\":\"column\",\"position\":\"bottom\",\"sortDataKeys\":false,\"showMin\":false,\"showMax\":false,\"showAvg\":true,\"showTotal\":false,\"showLatest\":false},\"customLegendEnabled\":false,\"showSubtitle\":true,\"subtitle\":\"${entityName}\",\"subtitleFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"subtitleColor\":\"rgba(0, 0, 0, 0.38)\",\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"dateColor\":\"rgba(0, 0, 0, 0.38)\",\"showChart\":true,\"chartColor\":\"rgba(0, 0, 0, 0.87)\",\"background\":{\"type\":\"image\",\"imageBase64\":\"data:image/png;base64,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\",\"imageUrl\":null,\"color\":\"#fff\",\"overlay\":{\"enabled\":true,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Soil Moisture\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"mdi:water-percent\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"24px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":false,\"displayTimewindow\":true,\"decimals\":0,\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"24px\",\"icon\":null,\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":false},\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null}" }, "externalId": null, "tags": [ diff --git a/application/src/main/data/json/system/widget_types/temperature_chart_card.json b/application/src/main/data/json/system/widget_types/temperature_chart_card.json index cebef335f5..8debe15925 100644 --- a/application/src/main/data/json/system/widget_types/temperature_chart_card.json +++ b/application/src/main/data/json/system/widget_types/temperature_chart_card.json @@ -20,7 +20,7 @@ "latestDataKeySettingsDirective": "tb-aggregated-value-card-key-settings", "hasBasicMode": true, "basicModeDirective": "tb-aggregated-value-card-basic-config", - "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"Main building\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Temperature\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{\"showLines\":true,\"fillLines\":true,\"showPoints\":false},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 40 - 20;\\nif (value < -60) {\\n\\tvalue = -60;\\n} else if (value > 60) {\\n\\tvalue = 60;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"°C\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"#4caf50\",\"settings\":{\"position\":\"center\",\"font\":{\"size\":52,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"1\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":-20,\"color\":\"#234CC7\"},{\"from\":-20,\"to\":0,\"color\":\"#305AD7\"},{\"from\":0,\"to\":10,\"color\":\"#7191EF\"},{\"from\":10,\"to\":20,\"color\":\"#FFA600\"},{\"from\":20,\"to\":30,\"color\":\"#F36900\"},{\"from\":30,\"to\":40,\"color\":\"#F04022\"},{\"from\":40,\"to\":null,\"color\":\"#D81838\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.9408410830697858,\"funcBody\":\"var value = prevValue + Math.random() * 40 - 20;\\nif (value < -60) {\\n\\tvalue = -60;\\n} else if (value > 60) {\\n\\tvalue = 60;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"°C\",\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta percent\",\"color\":\"#f44336\",\"settings\":{\"position\":\"rightTop\",\"font\":{\"size\":14,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"20px\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[{\"from\":null,\"to\":0,\"color\":\"#198038\"},{\"from\":0,\"to\":0,\"color\":\"rgba(0, 0, 0, 0.87)\"},{\"from\":0,\"to\":null,\"color\":\"#D12730\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":true},\"_hash\":0.06392321853157967,\"funcBody\":\"var value = prevValue + Math.random() * 6 - 3;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < -25) {\\n\\tvalue = -25;\\n} else if (value > 25) {\\n\\tvalue = 25;\\n} \\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta absolute\",\"color\":\"#607d8b\",\"settings\":{\"position\":\"rightBottom\",\"font\":{\"size\":11,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.44695098620509865,\"funcBody\":\"var value = prevValue + Math.random() * 4 - 2;\\nif (value < -6) {\\n\\tvalue = -6;\\n} else if (value > 6) {\\n\\tvalue = 6;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"°C\",\"decimals\":1,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1691927717318,\"endTimeMs\":1692014117318},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"stack\":false,\"fontSize\":10,\"fontColor\":\"#545454\",\"showTooltip\":true,\"tooltipIndividual\":false,\"tooltipCumulative\":false,\"hideZeros\":false,\"grid\":{\"verticalLines\":true,\"horizontalLines\":true,\"outlineWidth\":1,\"color\":\"#545454\",\"backgroundColor\":null,\"tickColor\":\"#DDDDDD\"},\"xaxis\":{\"title\":null,\"showLabels\":true,\"color\":\"#545454\"},\"yaxis\":{\"min\":null,\"max\":null,\"title\":null,\"showLabels\":true,\"color\":\"#545454\",\"tickSize\":null,\"tickDecimals\":0,\"ticksFormatter\":\"\"},\"shadowSize\":4,\"smoothLines\":false,\"comparisonEnabled\":false,\"xaxisSecond\":{\"axisPosition\":\"top\",\"title\":null,\"showLabels\":true},\"showLegend\":true,\"legendConfig\":{\"direction\":\"column\",\"position\":\"bottom\",\"sortDataKeys\":false,\"showMin\":false,\"showMax\":false,\"showAvg\":true,\"showTotal\":false,\"showLatest\":false},\"customLegendEnabled\":false,\"showSubtitle\":true,\"subtitle\":\"${entityName}\",\"subtitleFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"subtitleColor\":\"rgba(0, 0, 0, 0.38)\",\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"dateColor\":\"rgba(0, 0, 0, 0.38)\",\"showChart\":true,\"chartColor\":\"rgba(0, 0, 0, 0.87)\",\"background\":{\"type\":\"color\",\"color\":\"#fff\",\"overlay\":{\"enabled\":false,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Temperature\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"device_thermostat\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"24px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":false,\"displayTimewindow\":true,\"decimals\":0,\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"24px\",\"icon\":null,\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":false},\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null}" + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"Main building\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Temperature\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{\"showLines\":true,\"fillLines\":true,\"showPoints\":false},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 40 - 20;\\nif (value < -60) {\\n\\tvalue = -60;\\n} else if (value > 60) {\\n\\tvalue = 60;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"°C\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"#4caf50\",\"settings\":{\"position\":\"center\",\"font\":{\"size\":52,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"1\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":-20,\"color\":\"#234CC7\"},{\"from\":-20,\"to\":0,\"color\":\"#305AD7\"},{\"from\":0,\"to\":10,\"color\":\"#7191EF\"},{\"from\":10,\"to\":20,\"color\":\"#FFA600\"},{\"from\":20,\"to\":30,\"color\":\"#F36900\"},{\"from\":30,\"to\":40,\"color\":\"#F04022\"},{\"from\":40,\"to\":null,\"color\":\"#D81838\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.9408410830697858,\"funcBody\":\"var value = prevValue + Math.random() * 40 - 20;\\nif (value < -60) {\\n\\tvalue = -60;\\n} else if (value > 60) {\\n\\tvalue = 60;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"°C\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta percent\",\"color\":\"#f44336\",\"settings\":{\"position\":\"rightTop\",\"font\":{\"size\":14,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"20px\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[{\"from\":null,\"to\":0,\"color\":\"#198038\"},{\"from\":0,\"to\":0,\"color\":\"rgba(0, 0, 0, 0.87)\"},{\"from\":0,\"to\":null,\"color\":\"#D12730\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":true},\"_hash\":0.06392321853157967,\"funcBody\":\"var value = prevValue + Math.random() * 6 - 3;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < -25) {\\n\\tvalue = -25;\\n} else if (value > 25) {\\n\\tvalue = 25;\\n} \\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta absolute\",\"color\":\"#607d8b\",\"settings\":{\"position\":\"rightBottom\",\"font\":{\"size\":11,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.44695098620509865,\"funcBody\":\"var value = prevValue + Math.random() * 4 - 2;\\nif (value < -6) {\\n\\tvalue = -6;\\n} else if (value > 6) {\\n\\tvalue = 6;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"°C\",\"decimals\":1,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1691927717318,\"endTimeMs\":1692014117318},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"stack\":false,\"fontSize\":10,\"fontColor\":\"#545454\",\"showTooltip\":true,\"tooltipIndividual\":false,\"tooltipCumulative\":false,\"hideZeros\":false,\"grid\":{\"verticalLines\":true,\"horizontalLines\":true,\"outlineWidth\":1,\"color\":\"#545454\",\"backgroundColor\":null,\"tickColor\":\"#DDDDDD\"},\"xaxis\":{\"title\":null,\"showLabels\":true,\"color\":\"#545454\"},\"yaxis\":{\"min\":null,\"max\":null,\"title\":null,\"showLabels\":true,\"color\":\"#545454\",\"tickSize\":null,\"tickDecimals\":0,\"ticksFormatter\":\"\"},\"shadowSize\":4,\"smoothLines\":false,\"comparisonEnabled\":false,\"xaxisSecond\":{\"axisPosition\":\"top\",\"title\":null,\"showLabels\":true},\"showLegend\":true,\"legendConfig\":{\"direction\":\"column\",\"position\":\"bottom\",\"sortDataKeys\":false,\"showMin\":false,\"showMax\":false,\"showAvg\":true,\"showTotal\":false,\"showLatest\":false},\"customLegendEnabled\":false,\"showSubtitle\":true,\"subtitle\":\"${entityName}\",\"subtitleFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"subtitleColor\":\"rgba(0, 0, 0, 0.38)\",\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"dateColor\":\"rgba(0, 0, 0, 0.38)\",\"showChart\":true,\"chartColor\":\"rgba(0, 0, 0, 0.87)\",\"background\":{\"type\":\"color\",\"color\":\"#fff\",\"overlay\":{\"enabled\":false,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Temperature\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"device_thermostat\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"24px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":false,\"displayTimewindow\":true,\"decimals\":0,\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"24px\",\"icon\":null,\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":false},\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null}" }, "externalId": null, "tags": [ diff --git a/application/src/main/data/json/system/widget_types/temperature_chart_card_with_background.json b/application/src/main/data/json/system/widget_types/temperature_chart_card_with_background.json index d5be89cb73..54bee4076e 100644 --- a/application/src/main/data/json/system/widget_types/temperature_chart_card_with_background.json +++ b/application/src/main/data/json/system/widget_types/temperature_chart_card_with_background.json @@ -20,7 +20,7 @@ "latestDataKeySettingsDirective": "tb-aggregated-value-card-key-settings", "hasBasicMode": true, "basicModeDirective": "tb-aggregated-value-card-basic-config", - "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"Main building\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Temperature\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{\"showLines\":true,\"fillLines\":true,\"showPoints\":false},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 40 - 20;\\nif (value < -60) {\\n\\tvalue = -60;\\n} else if (value > 60) {\\n\\tvalue = 60;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"°C\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"#4caf50\",\"settings\":{\"position\":\"center\",\"font\":{\"size\":52,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"1\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":-20,\"color\":\"#224AC2\"},{\"from\":-20,\"to\":0,\"color\":\"#2B54CE\"},{\"from\":0,\"to\":10,\"color\":\"#6083EC\"},{\"from\":10,\"to\":20,\"color\":\"#F89E0D\"},{\"from\":20,\"to\":30,\"color\":\"#F77410\"},{\"from\":30,\"to\":40,\"color\":\"#F04022\"},{\"from\":40,\"to\":null,\"color\":\"#DE2343\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.9408410830697858,\"funcBody\":\"var value = prevValue + Math.random() * 40 - 20;\\nif (value < -60) {\\n\\tvalue = -60;\\n} else if (value > 60) {\\n\\tvalue = 60;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"°C\",\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta percent\",\"color\":\"#f44336\",\"settings\":{\"position\":\"rightTop\",\"font\":{\"size\":14,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"20px\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[{\"from\":null,\"to\":0,\"color\":\"#198038\"},{\"from\":0,\"to\":0,\"color\":\"rgba(0, 0, 0, 0.87)\"},{\"from\":0,\"to\":null,\"color\":\"#D12730\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":true},\"_hash\":0.06392321853157967,\"funcBody\":\"var value = prevValue + Math.random() * 6 - 3;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < -25) {\\n\\tvalue = -25;\\n} else if (value > 25) {\\n\\tvalue = 25;\\n} \\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta absolute\",\"color\":\"#607d8b\",\"settings\":{\"position\":\"rightBottom\",\"font\":{\"size\":11,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.44695098620509865,\"funcBody\":\"var value = prevValue + Math.random() * 4 - 2;\\nif (value < -6) {\\n\\tvalue = -6;\\n} else if (value > 6) {\\n\\tvalue = 6;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"°C\",\"decimals\":1,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1691927717318,\"endTimeMs\":1692014117318},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"stack\":false,\"fontSize\":10,\"fontColor\":\"#545454\",\"showTooltip\":true,\"tooltipIndividual\":false,\"tooltipCumulative\":false,\"hideZeros\":false,\"grid\":{\"verticalLines\":true,\"horizontalLines\":true,\"outlineWidth\":1,\"color\":\"#545454\",\"backgroundColor\":null,\"tickColor\":\"#DDDDDD\"},\"xaxis\":{\"title\":null,\"showLabels\":true,\"color\":\"#545454\"},\"yaxis\":{\"min\":null,\"max\":null,\"title\":null,\"showLabels\":true,\"color\":\"#545454\",\"tickSize\":null,\"tickDecimals\":0,\"ticksFormatter\":\"\"},\"shadowSize\":4,\"smoothLines\":false,\"comparisonEnabled\":false,\"xaxisSecond\":{\"axisPosition\":\"top\",\"title\":null,\"showLabels\":true},\"showLegend\":true,\"legendConfig\":{\"direction\":\"column\",\"position\":\"bottom\",\"sortDataKeys\":false,\"showMin\":false,\"showMax\":false,\"showAvg\":true,\"showTotal\":false,\"showLatest\":false},\"customLegendEnabled\":false,\"showSubtitle\":true,\"subtitle\":\"${entityName}\",\"subtitleFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"subtitleColor\":\"rgba(0, 0, 0, 0.38)\",\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"dateColor\":\"rgba(0, 0, 0, 0.38)\",\"showChart\":true,\"chartColor\":\"rgba(0, 0, 0, 0.87)\",\"background\":{\"type\":\"image\",\"imageBase64\":\"data:image/png;base64,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\",\"imageUrl\":null,\"color\":\"#fff\",\"overlay\":{\"enabled\":true,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Temperature\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"device_thermostat\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"24px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":false,\"displayTimewindow\":true,\"decimals\":0,\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"24px\",\"icon\":null,\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":false},\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null}" + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"Main building\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Temperature\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{\"showLines\":true,\"fillLines\":true,\"showPoints\":false},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 40 - 20;\\nif (value < -60) {\\n\\tvalue = -60;\\n} else if (value > 60) {\\n\\tvalue = 60;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"°C\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"#4caf50\",\"settings\":{\"position\":\"center\",\"font\":{\"size\":52,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"1\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":-20,\"color\":\"#224AC2\"},{\"from\":-20,\"to\":0,\"color\":\"#2B54CE\"},{\"from\":0,\"to\":10,\"color\":\"#6083EC\"},{\"from\":10,\"to\":20,\"color\":\"#F89E0D\"},{\"from\":20,\"to\":30,\"color\":\"#F77410\"},{\"from\":30,\"to\":40,\"color\":\"#F04022\"},{\"from\":40,\"to\":null,\"color\":\"#DE2343\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.9408410830697858,\"funcBody\":\"var value = prevValue + Math.random() * 40 - 20;\\nif (value < -60) {\\n\\tvalue = -60;\\n} else if (value > 60) {\\n\\tvalue = 60;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"°C\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta percent\",\"color\":\"#f44336\",\"settings\":{\"position\":\"rightTop\",\"font\":{\"size\":14,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"20px\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[{\"from\":null,\"to\":0,\"color\":\"#198038\"},{\"from\":0,\"to\":0,\"color\":\"rgba(0, 0, 0, 0.87)\"},{\"from\":0,\"to\":null,\"color\":\"#D12730\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":true},\"_hash\":0.06392321853157967,\"funcBody\":\"var value = prevValue + Math.random() * 6 - 3;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < -25) {\\n\\tvalue = -25;\\n} else if (value > 25) {\\n\\tvalue = 25;\\n} \\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta absolute\",\"color\":\"#607d8b\",\"settings\":{\"position\":\"rightBottom\",\"font\":{\"size\":11,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.44695098620509865,\"funcBody\":\"var value = prevValue + Math.random() * 4 - 2;\\nif (value < -6) {\\n\\tvalue = -6;\\n} else if (value > 6) {\\n\\tvalue = 6;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"°C\",\"decimals\":1,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1691927717318,\"endTimeMs\":1692014117318},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"stack\":false,\"fontSize\":10,\"fontColor\":\"#545454\",\"showTooltip\":true,\"tooltipIndividual\":false,\"tooltipCumulative\":false,\"hideZeros\":false,\"grid\":{\"verticalLines\":true,\"horizontalLines\":true,\"outlineWidth\":1,\"color\":\"#545454\",\"backgroundColor\":null,\"tickColor\":\"#DDDDDD\"},\"xaxis\":{\"title\":null,\"showLabels\":true,\"color\":\"#545454\"},\"yaxis\":{\"min\":null,\"max\":null,\"title\":null,\"showLabels\":true,\"color\":\"#545454\",\"tickSize\":null,\"tickDecimals\":0,\"ticksFormatter\":\"\"},\"shadowSize\":4,\"smoothLines\":false,\"comparisonEnabled\":false,\"xaxisSecond\":{\"axisPosition\":\"top\",\"title\":null,\"showLabels\":true},\"showLegend\":true,\"legendConfig\":{\"direction\":\"column\",\"position\":\"bottom\",\"sortDataKeys\":false,\"showMin\":false,\"showMax\":false,\"showAvg\":true,\"showTotal\":false,\"showLatest\":false},\"customLegendEnabled\":false,\"showSubtitle\":true,\"subtitle\":\"${entityName}\",\"subtitleFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"subtitleColor\":\"rgba(0, 0, 0, 0.38)\",\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"dateColor\":\"rgba(0, 0, 0, 0.38)\",\"showChart\":true,\"chartColor\":\"rgba(0, 0, 0, 0.87)\",\"background\":{\"type\":\"image\",\"imageBase64\":\"data:image/png;base64,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\",\"imageUrl\":null,\"color\":\"#fff\",\"overlay\":{\"enabled\":true,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Temperature\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"device_thermostat\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"24px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":false,\"displayTimewindow\":true,\"decimals\":0,\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"24px\",\"icon\":null,\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":false},\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null}" }, "externalId": null, "tags": [ diff --git a/application/src/main/data/json/system/widget_types/value_and_chart_card.json b/application/src/main/data/json/system/widget_types/value_and_chart_card.json index 20b0245488..a868a8d810 100644 --- a/application/src/main/data/json/system/widget_types/value_and_chart_card.json +++ b/application/src/main/data/json/system/widget_types/value_and_chart_card.json @@ -20,7 +20,7 @@ "latestDataKeySettingsDirective": "tb-aggregated-value-card-key-settings", "hasBasicMode": true, "basicModeDirective": "tb-aggregated-value-card-basic-config", - "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"Main building\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"watermeter\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{\"showLines\":true,\"fillLines\":true,\"showPoints\":false},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 10 - 5;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < 5) {\\n\\tvalue = 5;\\n} else if (value > 80) {\\n\\tvalue = 80;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"m³\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"#4caf50\",\"settings\":{\"position\":\"center\",\"font\":{\"size\":52,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"1\"},\"color\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.9408410830697858,\"funcBody\":\"var value = prevValue + Math.random() * 10 - 5;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < 5) {\\n\\tvalue = 5;\\n} else if (value > 80) {\\n\\tvalue = 80;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"m³\",\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta percent\",\"color\":\"#f44336\",\"settings\":{\"position\":\"rightTop\",\"font\":{\"size\":14,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"20px\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[{\"from\":null,\"to\":0,\"color\":\"#198038\"},{\"from\":0,\"to\":0,\"color\":\"rgba(0, 0, 0, 0.87)\"},{\"from\":0,\"to\":null,\"color\":\"#D12730\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":true},\"_hash\":0.06392321853157967,\"funcBody\":\"var value = prevValue + Math.random() * 6 - 3;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < -25) {\\n\\tvalue = -25;\\n} else if (value > 25) {\\n\\tvalue = 25;\\n} \\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta absolute\",\"color\":\"#607d8b\",\"settings\":{\"position\":\"rightBottom\",\"font\":{\"size\":11,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.44695098620509865,\"funcBody\":\"var value = prevValue + Math.random() * 100 - 50;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < -1000) {\\n\\tvalue = -1000;\\n} else if (value > 1000) {\\n\\tvalue = 1000;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"m³\",\"decimals\":1,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1691927717318,\"endTimeMs\":1692014117318},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"stack\":false,\"fontSize\":10,\"fontColor\":\"#545454\",\"showTooltip\":true,\"tooltipIndividual\":false,\"tooltipCumulative\":false,\"hideZeros\":false,\"grid\":{\"verticalLines\":true,\"horizontalLines\":true,\"outlineWidth\":1,\"color\":\"#545454\",\"backgroundColor\":null,\"tickColor\":\"#DDDDDD\"},\"xaxis\":{\"title\":null,\"showLabels\":true,\"color\":\"#545454\"},\"yaxis\":{\"min\":null,\"max\":null,\"title\":null,\"showLabels\":true,\"color\":\"#545454\",\"tickSize\":null,\"tickDecimals\":0,\"ticksFormatter\":\"\"},\"shadowSize\":4,\"smoothLines\":false,\"comparisonEnabled\":false,\"xaxisSecond\":{\"axisPosition\":\"top\",\"title\":null,\"showLabels\":true},\"showLegend\":true,\"legendConfig\":{\"direction\":\"column\",\"position\":\"bottom\",\"sortDataKeys\":false,\"showMin\":false,\"showMax\":false,\"showAvg\":true,\"showTotal\":false,\"showLatest\":false},\"customLegendEnabled\":false,\"showSubtitle\":true,\"subtitle\":\"${entityName}\",\"subtitleFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"subtitleColor\":\"rgba(0, 0, 0, 0.38)\",\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"dateColor\":\"rgba(0, 0, 0, 0.38)\",\"showChart\":true,\"chartColor\":\"rgba(0, 0, 0, 0.87)\",\"background\":{\"type\":\"color\",\"color\":\"#fff\",\"overlay\":{\"enabled\":false,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}}},\"title\":\"Value and chart card\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"water_drop\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"24px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":false,\"displayTimewindow\":true,\"decimals\":0,\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"24px\",\"icon\":null,\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":false},\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null}" + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"Main building\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"watermeter\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{\"showLines\":true,\"fillLines\":true,\"showPoints\":false},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 10 - 5;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < 5) {\\n\\tvalue = 5;\\n} else if (value > 80) {\\n\\tvalue = 80;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"m³\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"#4caf50\",\"settings\":{\"position\":\"center\",\"font\":{\"size\":52,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"1\"},\"color\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.9408410830697858,\"funcBody\":\"var value = prevValue + Math.random() * 10 - 5;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < 5) {\\n\\tvalue = 5;\\n} else if (value > 80) {\\n\\tvalue = 80;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"m³\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta percent\",\"color\":\"#f44336\",\"settings\":{\"position\":\"rightTop\",\"font\":{\"size\":14,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"20px\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[{\"from\":null,\"to\":0,\"color\":\"#198038\"},{\"from\":0,\"to\":0,\"color\":\"rgba(0, 0, 0, 0.87)\"},{\"from\":0,\"to\":null,\"color\":\"#D12730\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":true},\"_hash\":0.06392321853157967,\"funcBody\":\"var value = prevValue + Math.random() * 6 - 3;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < -25) {\\n\\tvalue = -25;\\n} else if (value > 25) {\\n\\tvalue = 25;\\n} \\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta absolute\",\"color\":\"#607d8b\",\"settings\":{\"position\":\"rightBottom\",\"font\":{\"size\":11,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.44695098620509865,\"funcBody\":\"var value = prevValue + Math.random() * 100 - 50;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < -1000) {\\n\\tvalue = -1000;\\n} else if (value > 1000) {\\n\\tvalue = 1000;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"m³\",\"decimals\":1,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1691927717318,\"endTimeMs\":1692014117318},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"stack\":false,\"fontSize\":10,\"fontColor\":\"#545454\",\"showTooltip\":true,\"tooltipIndividual\":false,\"tooltipCumulative\":false,\"hideZeros\":false,\"grid\":{\"verticalLines\":true,\"horizontalLines\":true,\"outlineWidth\":1,\"color\":\"#545454\",\"backgroundColor\":null,\"tickColor\":\"#DDDDDD\"},\"xaxis\":{\"title\":null,\"showLabels\":true,\"color\":\"#545454\"},\"yaxis\":{\"min\":null,\"max\":null,\"title\":null,\"showLabels\":true,\"color\":\"#545454\",\"tickSize\":null,\"tickDecimals\":0,\"ticksFormatter\":\"\"},\"shadowSize\":4,\"smoothLines\":false,\"comparisonEnabled\":false,\"xaxisSecond\":{\"axisPosition\":\"top\",\"title\":null,\"showLabels\":true},\"showLegend\":true,\"legendConfig\":{\"direction\":\"column\",\"position\":\"bottom\",\"sortDataKeys\":false,\"showMin\":false,\"showMax\":false,\"showAvg\":true,\"showTotal\":false,\"showLatest\":false},\"customLegendEnabled\":false,\"showSubtitle\":true,\"subtitle\":\"${entityName}\",\"subtitleFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"subtitleColor\":\"rgba(0, 0, 0, 0.38)\",\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"dateColor\":\"rgba(0, 0, 0, 0.38)\",\"showChart\":true,\"chartColor\":\"rgba(0, 0, 0, 0.87)\",\"background\":{\"type\":\"color\",\"color\":\"#fff\",\"overlay\":{\"enabled\":false,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Value and chart card\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"water_drop\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"24px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":false,\"displayTimewindow\":true,\"decimals\":0,\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"24px\",\"icon\":null,\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":false},\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null}" }, "externalId": null, "tags": null From 15b5c7a971eb69e52cfc18a27a648c1499c2ccf7 Mon Sep 17 00:00:00 2001 From: Igor Kulikov Date: Tue, 24 Oct 2023 15:33:31 +0300 Subject: [PATCH 35/43] UI: Outdoor Environment: Noise level widgets. --- .../data/json/system/widget_types/soil_moisture_chart_card.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/application/src/main/data/json/system/widget_types/soil_moisture_chart_card.json b/application/src/main/data/json/system/widget_types/soil_moisture_chart_card.json index 742f8cd9b4..5931b661cb 100644 --- a/application/src/main/data/json/system/widget_types/soil_moisture_chart_card.json +++ b/application/src/main/data/json/system/widget_types/soil_moisture_chart_card.json @@ -20,7 +20,7 @@ "latestDataKeySettingsDirective": "tb-aggregated-value-card-key-settings", "hasBasicMode": true, "basicModeDirective": "tb-aggregated-value-card-basic-config", - "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"Main building\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Soil Moisture\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{\"showLines\":true,\"fillLines\":true,\"showPoints\":false},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 7;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"#4caf50\",\"settings\":{\"position\":\"center\",\"font\":{\"size\":52,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"1\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":0,\"to\":20,\"color\":\"#D81838\"},{\"from\":20,\"to\":40,\"color\":\"#F36900\"},{\"from\":40,\"to\":60,\"color\":\"#4B70DD\"},{\"from\":60,\"to\":100,\"color\":\"#234CC7\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.9408410830697858,\"funcBody\":\"var value = prevValue + Math.random() * 7;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta percent\",\"color\":\"#f44336\",\"settings\":{\"position\":\"rightTop\",\"font\":{\"size\":14,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"20px\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[{\"from\":null,\"to\":0,\"color\":\"#198038\"},{\"from\":0,\"to\":0,\"color\":\"rgba(0, 0, 0, 0.87)\"},{\"from\":0,\"to\":null,\"color\":\"#D12730\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":true},\"_hash\":0.06392321853157967,\"funcBody\":\"var value = prevValue + Math.random() * 6 - 3;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < -25) {\\n\\tvalue = -25;\\n} else if (value > 25) {\\n\\tvalue = 25;\\n} \\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta absolute\",\"color\":\"#607d8b\",\"settings\":{\"position\":\"rightBottom\",\"font\":{\"size\":11,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.44695098620509865,\"funcBody\":\"var value = prevValue + Math.random() * 4 - 2;\\nif (value < -6) {\\n\\tvalue = -6;\\n} else if (value > 6) {\\n\\tvalue = 6;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":1,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1691927717318,\"endTimeMs\":1692014117318},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"stack\":false,\"fontSize\":10,\"fontColor\":\"#545454\",\"showTooltip\":true,\"tooltipIndividual\":false,\"tooltipCumulative\":false,\"hideZeros\":false,\"grid\":{\"verticalLines\":true,\"horizontalLines\":true,\"outlineWidth\":1,\"color\":\"#545454\",\"backgroundColor\":null,\"tickColor\":\"#DDDDDD\"},\"xaxis\":{\"title\":null,\"showLabels\":true,\"color\":\"#545454\"},\"yaxis\":{\"min\":null,\"max\":null,\"title\":null,\"showLabels\":true,\"color\":\"#545454\",\"tickSize\":null,\"tickDecimals\":0,\"ticksFormatter\":\"\"},\"shadowSize\":4,\"smoothLines\":false,\"comparisonEnabled\":false,\"xaxisSecond\":{\"axisPosition\":\"top\",\"title\":null,\"showLabels\":true},\"showLegend\":true,\"legendConfig\":{\"direction\":\"column\",\"position\":\"bottom\",\"sortDataKeys\":false,\"showMin\":false,\"showMax\":false,\"showAvg\":true,\"showTotal\":false,\"showLatest\":false},\"customLegendEnabled\":false,\"showSubtitle\":true,\"subtitle\":\"${entityName}\",\"subtitleFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"subtitleColor\":\"rgba(0, 0, 0, 0.38)\",\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"dateColor\":\"rgba(0, 0, 0, 0.38)\",\"showChart\":true,\"chartColor\":\"rgba(0, 0, 0, 0.87)\",\"background\":{\"type\":\"color\",\"color\":\"#fff\",\"overlay\":{\"enabled\":false,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Soil Moisture\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"mdi:water-percent\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"24px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":false,\"displayTimewindow\":true,\"decimals\":0,\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"24px\",\"icon\":null,\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":false},\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null}" + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"Main building\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Soil Moisture\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{\"showLines\":true,\"fillLines\":true,\"showPoints\":false},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 7;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"#4caf50\",\"settings\":{\"position\":\"center\",\"font\":{\"size\":52,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"1\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":0,\"to\":20,\"color\":\"#D81838\"},{\"from\":20,\"to\":40,\"color\":\"#F36900\"},{\"from\":40,\"to\":60,\"color\":\"#4B70DD\"},{\"from\":60,\"to\":100,\"color\":\"#234CC7\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.9408410830697858,\"funcBody\":\"var value = prevValue + Math.random() * 7;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta percent\",\"color\":\"#f44336\",\"settings\":{\"position\":\"rightTop\",\"font\":{\"size\":14,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"20px\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[{\"from\":null,\"to\":0,\"color\":\"#198038\"},{\"from\":0,\"to\":0,\"color\":\"rgba(0, 0, 0, 0.87)\"},{\"from\":0,\"to\":null,\"color\":\"#D12730\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":true},\"_hash\":0.06392321853157967,\"funcBody\":\"var value = prevValue + Math.random() * 6 - 3;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < -25) {\\n\\tvalue = -25;\\n} else if (value > 25) {\\n\\tvalue = 25;\\n} \\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta absolute\",\"color\":\"#607d8b\",\"settings\":{\"position\":\"rightBottom\",\"font\":{\"size\":11,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.44695098620509865,\"funcBody\":\"var value = prevValue + Math.random() * 4 - 2;\\nif (value < -6) {\\n\\tvalue = -6;\\n} else if (value > 6) {\\n\\tvalue = 6;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":1,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1691927717318,\"endTimeMs\":1692014117318},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"stack\":false,\"fontSize\":10,\"fontColor\":\"#545454\",\"showTooltip\":true,\"tooltipIndividual\":false,\"tooltipCumulative\":false,\"hideZeros\":false,\"grid\":{\"verticalLines\":true,\"horizontalLines\":true,\"outlineWidth\":1,\"color\":\"#545454\",\"backgroundColor\":null,\"tickColor\":\"#DDDDDD\"},\"xaxis\":{\"title\":null,\"showLabels\":true,\"color\":\"#545454\"},\"yaxis\":{\"min\":null,\"max\":null,\"title\":null,\"showLabels\":true,\"color\":\"#545454\",\"tickSize\":null,\"tickDecimals\":0,\"ticksFormatter\":\"\"},\"shadowSize\":4,\"smoothLines\":false,\"comparisonEnabled\":false,\"xaxisSecond\":{\"axisPosition\":\"top\",\"title\":null,\"showLabels\":true},\"showLegend\":true,\"legendConfig\":{\"direction\":\"column\",\"position\":\"bottom\",\"sortDataKeys\":false,\"showMin\":false,\"showMax\":false,\"showAvg\":true,\"showTotal\":false,\"showLatest\":false},\"customLegendEnabled\":false,\"showSubtitle\":true,\"subtitle\":\"${entityName}\",\"subtitleFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"subtitleColor\":\"rgba(0, 0, 0, 0.38)\",\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"dateColor\":\"rgba(0, 0, 0, 0.38)\",\"showChart\":true,\"chartColor\":\"rgba(0, 0, 0, 0.87)\",\"background\":{\"type\":\"color\",\"color\":\"#fff\",\"overlay\":{\"enabled\":false,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Soil Moisture\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"mdi:water-percent\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"24px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":false,\"displayTimewindow\":true,\"decimals\":0,\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"24px\",\"icon\":null,\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":false},\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null}" }, "externalId": null, "tags": [ From c238576e54a0eddf571779930bd8a800f5607a0f Mon Sep 17 00:00:00 2001 From: Igor Kulikov Date: Tue, 24 Oct 2023 18:18:11 +0300 Subject: [PATCH 36/43] UI: Outdoor Environment: Vibration widgets. --- .../widget_bundles/outdoor_environment.json | 10 +++++- .../horizontal_vibration_card.json | 28 +++++++++++++++++ ...zontal_vibration_card_with_background.json | 28 +++++++++++++++++ .../simple_vibration_chart_card.json | 31 +++++++++++++++++++ ..._vibration_chart_card_with_background.json | 31 +++++++++++++++++++ .../system/widget_types/vibration_card.json | 28 +++++++++++++++++ .../vibration_card_with_background.json | 28 +++++++++++++++++ .../widget_types/vibration_chart_card.json | 31 +++++++++++++++++++ .../vibration_chart_card_with_background.json | 31 +++++++++++++++++++ 9 files changed, 245 insertions(+), 1 deletion(-) create mode 100644 application/src/main/data/json/system/widget_types/horizontal_vibration_card.json create mode 100644 application/src/main/data/json/system/widget_types/horizontal_vibration_card_with_background.json create mode 100644 application/src/main/data/json/system/widget_types/simple_vibration_chart_card.json create mode 100644 application/src/main/data/json/system/widget_types/simple_vibration_chart_card_with_background.json create mode 100644 application/src/main/data/json/system/widget_types/vibration_card.json create mode 100644 application/src/main/data/json/system/widget_types/vibration_card_with_background.json create mode 100644 application/src/main/data/json/system/widget_types/vibration_chart_card.json create mode 100644 application/src/main/data/json/system/widget_types/vibration_chart_card_with_background.json diff --git a/application/src/main/data/json/system/widget_bundles/outdoor_environment.json b/application/src/main/data/json/system/widget_bundles/outdoor_environment.json index cc3b703fa3..a5644dcea5 100644 --- a/application/src/main/data/json/system/widget_bundles/outdoor_environment.json +++ b/application/src/main/data/json/system/widget_bundles/outdoor_environment.json @@ -111,6 +111,14 @@ "noise_level_chart_card", "noise_level_chart_card_with_background", "simple_noise_level_chart_card", - "simple_noise_level_chart_card_with_background" + "simple_noise_level_chart_card_with_background", + "vibration_card", + "vibration_card_with_background", + "horizontal_vibration_card", + "horizontal_vibration_card_with_background", + "vibration_chart_card", + "vibration_chart_card_with_background", + "simple_vibration_chart_card", + "simple_vibration_chart_card_with_background" ] } \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/horizontal_vibration_card.json b/application/src/main/data/json/system/widget_types/horizontal_vibration_card.json new file mode 100644 index 0000000000..4a2b878e4b --- /dev/null +++ b/application/src/main/data/json/system/widget_types/horizontal_vibration_card.json @@ -0,0 +1,28 @@ +{ + "fqn": "horizontal_vibration_card", + "name": "Horizontal vibration card", + "deprecated": false, + "image": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAMgAAACgCAMAAAB+IdObAAAAn1BMVEUAAADf39/f39/g4ODg4OD////k5OTYGDjg4OD64ubwqLTdNVH1xc3nboLIyMjiUmnOzs7aJkXx8fHsi5v09PT98fL5+fm3t7f41Nrb29vCwsLzt8GQkJDV1dW8vLxYWFjn5+fumqjpfY90dHTgQ1398fPiUmqsrKw8PDyenp5KSkqCgoLkYHYvLy9mZmZLS0shISGwsLCdnZ3pfZDpfY64MVbEAAAABXRSTlMAIETfv0i0+14AAAO7SURBVHja7doNb6IwHMfxnbc/tS30eBZQQHyYD9vu+f2/tmsL7LadOpZcFrb8PomsApp+04kmegUAAAAAAAAAAAAAAAAAAAAAAAAAAADwlj69ezZj8tl576afJ7rDSendi53J1XVMH0B6fTWlD2GKkJFByNggZGwQMjYIGZsTIZnb4tQJD0RK/XQOJT1wqFI0Jv+GNKwjqXcfUq1UuJ45FIbmRuE+LEvSY3L0vaHc7k8TzZ+MOnNhuHTO3KXHJ7svhHgeWZxRb3Fw9rRW62N9UPfH6vj1sLvfLRbOt69rul/v1bCKVcDIiJgm+cMooU7AjBs6gzOPHmwCyZpLIfxxCE/IUvVubUJUuFc1OYfbmva0WNzO6JvznRY7etl2w7T2eaWbrcx8XTO6Y6v+FCaFNqczBMuol0lBG3kphPFHIV8Eteq6NCGz8KhDbg+zLmRHdTgwhMtItCErM/NtwBLymDDTD/rJPVmMhFMydxOdO+dkfZH2LOEm/QKdDUmy5yGJS8ZiTybkW73QIT/39ZGOC/2vVX+9pYEhGm9DvrC53m5Ypm/m2SXrJurqQk4dXekFTC+ZWcmofXijNzesu5/JTXI2RNw8DxGSHgu77ZNNZ3iI2267BKlHlmCbgAXRQ0jQzHXF3Txi9rzGbD224iLQj8iCFdHrQi76nyERk7/1KkR9SGMWKbCrJ8x5N/1yCs/d6sWSko8zhHhip96HCHthsOfqYaY3NnalU2grjGSkIVbA+MkQr93fSL0W0UtviDx7HsKz/x6iZ9i+2LuXfcCS/i0uuRAi76iViaBPf/XlN6YT4vD5jnhQSMPuuhlG7Jeel50r7xbJHjgV4tr8rdzYC3hE1uA3xCQha9bGxBTmZKUppVPf7JhSSkTL3ZLSPG8P6B3xhZCtZF4kWaRHgR2JbmpzFtgDJ0M8PbDDO9H0i/b6jyg6pCz9XClfjwoq8qJKZ4VflsqvQr9KifxlXFU5xb494KvqfAhxyVh78czMqLGvYbMV5m5EJ0MCj4ytx/Q5goaERKwjn4T4s1j5S78NWZa5Hut9y9wvlA2Z5rkOUbOlinVuEdMFCU/6uG7E/949STD34bF86Md4t5NQ74efF/6sVEVsVsSv8mIWz5Sv94XVUvlkQlKzIsvqhzlQFgW9qS7k1fIlnVeqnIYYQ0iaXjoY0xCjCBkjhIwNQsYGIWODkLGZXl1/gK/ZieLrq4nzAb5oT52J+QnH1HnvPk8+0o9qAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN7IH7CH4Te59eAaAAAAAElFTkSuQmCC", + "description": "Displays a latest vibration telemetry data in a horizontal layout.", + "descriptor": { + "type": "latest", + "sizeX": 5, + "sizeY": 1, + "resources": [], + "templateHtml": "\n", + "templateCss": "", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueCardWidget.onDataUpdated();\n};\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n horizontal: true,\n previewWidth: '420px',\n previewHeight: '90px',\n embedTitlePanel: true,\n defaultDataKeysFunction: function() {\n return [{ name: 'vibration', label: 'Vibration', type: 'timeseries' }];\n }\n };\n};\n\nself.onDestroy = function() {\n};\n", + "settingsSchema": "", + "dataKeySettingsSchema": "", + "settingsDirective": "tb-value-card-widget-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"function\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Vibration\",\"color\":\"#2196f3\",\"settings\":{},\"_hash\":0.2392660816082064,\"funcBody\":\"let factor = 1000;\\nif (prevValue < 1) {\\n factor = 1;\\n} else if (prevValue < 10) {\\n factor = 10;\\n} else if (prevValue < 100) {\\n factor = 100;\\n}\\nlet value = prevValue + Math.random() * factor;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 1100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]}}],\"timewindow\":{\"realtime\":{\"timewindowMs\":60000}},\"showTitle\":false,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"padding\":\"0px\",\"settings\":{\"labelPosition\":\"top\",\"layout\":\"horizontal\",\"showLabel\":true,\"labelFont\":{\"family\":\"Roboto\",\"size\":16,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"labelColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showIcon\":true,\"iconSize\":40,\"iconSizeUnit\":\"px\",\"icon\":\"vibration\",\"iconColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":0.1,\"color\":\"rgba(0, 0, 0, 0.87)\"},{\"from\":0.1,\"to\":1,\"color\":\"#FFA600\"},{\"from\":1,\"to\":10,\"color\":\"#F36900\"},{\"from\":10,\"to\":100,\"color\":\"#F04022\"},{\"from\":100,\"to\":1000,\"color\":\"#D81838\"},{\"from\":1000,\"to\":null,\"color\":\"#6F113A\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"valueFont\":{\"size\":36,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\",\"rangeList\":[{\"from\":null,\"to\":0.1,\"color\":\"rgba(0, 0, 0, 0.87)\"},{\"from\":0.1,\"to\":1,\"color\":\"#FFA600\"},{\"from\":1,\"to\":10,\"color\":\"#F36900\"},{\"from\":10,\"to\":100,\"color\":\"#F04022\"},{\"from\":100,\"to\":1000,\"color\":\"#D81838\"},{\"from\":1000,\"to\":null,\"color\":\"#6F113A\"}]},\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"dateColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"color\",\"color\":\"#fff\",\"overlay\":{\"enabled\":false,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Horizontal noise level card\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"units\":\"m/s²\",\"decimals\":1,\"useDashboardTimewindow\":true,\"showLegend\":false,\"widgetStyle\":{},\"actions\":{},\"configMode\":\"basic\",\"displayTimewindow\":true,\"margin\":\"0px\",\"borderRadius\":\"0px\",\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"showTitleIcon\":false,\"titleTooltip\":\"\",\"titleFont\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1.6\"},\"titleIcon\":\"\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"iconSize\":\"14px\",\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"14px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1\"},\"color\":null}}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "vibration" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/horizontal_vibration_card_with_background.json b/application/src/main/data/json/system/widget_types/horizontal_vibration_card_with_background.json new file mode 100644 index 0000000000..b39869c2ab --- /dev/null +++ b/application/src/main/data/json/system/widget_types/horizontal_vibration_card_with_background.json @@ -0,0 +1,28 @@ +{ + "fqn": "horizontal_vibration_card_with_background", + "name": "Horizontal vibration card with background", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays a latest vibration telemetry data in a horizontal layout with background.", + "descriptor": { + "type": "latest", + "sizeX": 5, + "sizeY": 1, + "resources": [], + "templateHtml": "\n", + "templateCss": "", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueCardWidget.onDataUpdated();\n};\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n horizontal: true,\n previewWidth: '420px',\n previewHeight: '90px',\n embedTitlePanel: true,\n defaultDataKeysFunction: function() {\n return [{ name: 'vibration', label: 'Vibration', type: 'timeseries' }];\n }\n };\n};\n\nself.onDestroy = function() {\n};\n", + "settingsSchema": "", + "dataKeySettingsSchema": "", + "settingsDirective": "tb-value-card-widget-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"function\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Vibration\",\"color\":\"#2196f3\",\"settings\":{},\"_hash\":0.2392660816082064,\"funcBody\":\"let factor = 1000;\\nif (prevValue < 1) {\\n factor = 1;\\n} else if (prevValue < 10) {\\n factor = 10;\\n} else if (prevValue < 100) {\\n factor = 100;\\n}\\nlet value = prevValue + Math.random() * factor;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 1100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]}}],\"timewindow\":{\"realtime\":{\"timewindowMs\":60000}},\"showTitle\":false,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"padding\":\"0px\",\"settings\":{\"labelPosition\":\"top\",\"layout\":\"horizontal\",\"showLabel\":true,\"labelFont\":{\"family\":\"Roboto\",\"size\":16,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"labelColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showIcon\":true,\"iconSize\":40,\"iconSizeUnit\":\"px\",\"icon\":\"vibration\",\"iconColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":0.1,\"color\":\"rgba(0, 0, 0, 0.87)\"},{\"from\":0.1,\"to\":1,\"color\":\"#F89E0D\"},{\"from\":1,\"to\":10,\"color\":\"#F77410\"},{\"from\":10,\"to\":100,\"color\":\"#F04022\"},{\"from\":100,\"to\":1000,\"color\":\"#DE2343\"},{\"from\":1000,\"to\":null,\"color\":\"#791541\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"valueFont\":{\"size\":36,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\",\"rangeList\":[{\"from\":null,\"to\":0.1,\"color\":\"rgba(0, 0, 0, 0.87)\"},{\"from\":0.1,\"to\":1,\"color\":\"#F89E0D\"},{\"from\":1,\"to\":10,\"color\":\"#F77410\"},{\"from\":10,\"to\":100,\"color\":\"#F04022\"},{\"from\":100,\"to\":1000,\"color\":\"#DE2343\"},{\"from\":1000,\"to\":null,\"color\":\"#791541\"}]},\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"dateColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"image\",\"imageBase64\":\"data:image/png;base64,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\",\"imageUrl\":null,\"color\":\"#fff\",\"overlay\":{\"enabled\":true,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Horizontal noise level card\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"units\":\"m/s²\",\"decimals\":1,\"useDashboardTimewindow\":true,\"showLegend\":false,\"widgetStyle\":{},\"actions\":{},\"configMode\":\"basic\",\"displayTimewindow\":true,\"margin\":\"0px\",\"borderRadius\":\"0px\",\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"showTitleIcon\":false,\"titleTooltip\":\"\",\"titleFont\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1.6\"},\"titleIcon\":\"\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"iconSize\":\"14px\",\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"14px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1\"},\"color\":null}}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "vibration" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/simple_vibration_chart_card.json b/application/src/main/data/json/system/widget_types/simple_vibration_chart_card.json new file mode 100644 index 0000000000..7309e1b1a9 --- /dev/null +++ b/application/src/main/data/json/system/widget_types/simple_vibration_chart_card.json @@ -0,0 +1,31 @@ +{ + "fqn": "simple_vibration_chart_card", + "name": "Simple vibration chart card", + "deprecated": false, + "image": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAMgAAACgCAMAAAB+IdObAAAAh1BMVEUAAADf39/g4ODf39/f39/g4OD////k5OTYGDjg4OAhISH1xc3j4+OQkJD64uY8PDzdNVFYWFisrKx0dHTiUmr98fPy8vLaJkXnboLsi5vHx8cvLy+enp7V1dXwqLSCgoL409rkYHbzt8HpfY9KSkpmZma6urq5ubni4uLumqjtmqjfQ13gRF1p+9dsAAAABnRSTlMAIL9AEN/GQiaNAAAE7UlEQVR42uzPQQ3AIBAAsBswFgyg4fwrXOZgTyCtgwYAAAAAAMB/7dpci08t+Wwu7xpx5ezbm1mjHPDofZYY/QhDZDEiqxF52a133YZhGArD2xkIEgQlgIMu0BLb7/+GtRu3zdAARQeDafVPkjh94KJoTUi0JiRaExKtCYnWLyDOCNgTCOcjebgXAGvmkSGEbyo3x2X9HDJM9mrHR9UAmGJr30AKMXoOCOH1vgxNK86kOpwGtgShIgkorTR4kxWcaXAXB9oxcOEmjMt6DimbnhBR7ucbFSRiZIOQLSSQWjNXy9TYaOnH0DSrgalmVVzWcwilL4hk3LOMxXCHAFLfd8QJsAWF+FAW6uhU+DT/qOshUp3SJyQRiwIQVbIPSCIAJMEhToP4AeKi7x7YA8QBanEgXL4g7jgzMpyQxnrDAWm1FzV0Wj0Rex28a+NA4P2ErB2fJU0AxoJ2W0gZzQA30sXgStumjE2pbmAt+ykEBBi3vFc7XqYnEJajhNfpP38aYzYh0ZqQaE1ItCYkWhMSrQmJ1oRcGa/F/wCEjfbk9SFapZdM49Uhb+yabZOiMAyAv2UyLZairQVB3sS7Uff//77bNJbDWbrj7I53cufzAZTYnTybBBh0Lda0a0SycJFsAGIrqoWLlBvep8dli+yps4imXLbID7EPs7JfpkhVimPChQhDskiRtdisSnoamwGEIVmkSJYCVCIteUR4SL4poiyMWAWPZJelAyeeiIbKkh13kxrtvyBiz0b6feEQdQGe3iC6XE0c9RX4jIu28Bt7cPjWRwY73QyiimQdHZK4iKWM0YsYRO0QD/S6RnQacZKWxCvwCRJzmJCjKZyz8+20fd+U/HIunFCRxLC+V8QhITn3E8CB32jsLLQOCwj06KQHPiHHHiZ0BqDD2RXcTmLHnfWBfZkeB5E1g1jdKYLm3HPuHV6oQj75HrEFstIQOFP4Ftv6HJVs4YrTIWCBUU7b2WvfT+qgNK2qtExmf8YwZFSNlWjubC0AGYpw8F2OHUCB7tpgnIWXMrf/++5EI1Urak2tgKh9Z9kO3zGKJ8v10Wsf37YPe4hDJps7hz2IIBac4YU2+hpRY5ugKTpzVqMI4sXQJDmj0UuGNnpDl3faz1frdAtzNOKuX7uwyfaLIpo3Y4Qx6AmJ5T5UczE6LqBCPS6SNHHSuVpKNTfrGXyN74t0zvSyQNRBhIpgeVHNlat9c7a8iARYvoCPlM1fE2EKPhJE4EbEcCNSp50lkJMk1Mwoi+oPiJipSAs3KMQ6JqLwwp/JfQ/2EGcndg8TCWctg2Y8a/WIFiZw5jGRM9ZBt891KF1k1rePE+k4NYeHkNl4HWEnxQPQx0Q0d5asJbk4ikRI0gweJ3L2u5PfWq+jNOYUL5Q/kntbVBERyUeomvz5uMhQJg8UsTSkb0j5eh9tHKeE2I1HKPGISE6dxX9H5wdNayOsRAUPFAHV4TsHC0ThENG0nBjfR2pEdCeIiegwT8ogr41QiRU8RASUCilIOQ63Hc+bNqTUyvZ3WKmwlN9Mb3wVrY2RlMNTP/ttawX3kKRp8tQi97IR+3/jaXxT/R9fK7xElshL5Nl4iTwbL5Fn4yXybLxEno1f7dwxDQAgEATBwIcC/4ZBAuVzmXGwBlZIN0K62TnLncqYII27pVr/b6lmJY3CAAAAAAAAnhww9gaQpe5WwgAAAABJRU5ErkJggg==", + "description": "Displays historical vibration values as a simplified chart. Optionally may display the corresponding latest vibration value.", + "descriptor": { + "type": "timeseries", + "sizeX": 4.5, + "sizeY": 2, + "resources": [], + "templateHtml": "\n\n", + "templateCss": ".legend {\n font-size: 13px;\n line-height: 10px;\n}\n\n.legend table { \n border-spacing: 0px;\n border-collapse: separate;\n}\n\n.mouse-events .flot-overlay {\n cursor: crosshair; \n}\n\n", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueChartCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueChartCardWidget.onDataUpdated();\n};\n\nself.onLatestDataUpdated = function() {\n self.ctx.$scope.valueChartCardWidget.onLatestDataUpdated();\n}\n\nself.onEditModeChanged = function() {\n self.ctx.$scope.valueChartCardWidget.onEditModeChanged();\n}\n\nself.onDestroy = function() {\n self.ctx.$scope.valueChartCardWidget.onDestroy();\n}\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '300px',\n previewHeight: '150px',\n embedTitlePanel: true,\n hasAdditionalLatestDataKeys: true,\n defaultDataKeysFunction: function() {\n return [\n { name: 'vibration', label: 'Vibration', type: 'timeseries', color: 'rgba(0, 0, 0, 0.87)'}\n ];\n },\n defaultLatestDataKeysFunction: function(configComponent) {\n return [{ name: 'vibration', label: 'Latest', type: 'timeseries'}];\n }\n };\n}\n", + "settingsSchema": "{}", + "dataKeySettingsSchema": "{}", + "latestDataKeySettingsSchema": "{}", + "settingsDirective": "tb-value-chart-card-widget-settings", + "dataKeySettingsDirective": "", + "latestDataKeySettingsDirective": "", + "hasBasicMode": true, + "basicModeDirective": "tb-value-chart-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Vibration\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{},\"_hash\":0.8587686344902596,\"funcBody\":\"let factor = 1000;\\nif (prevValue < 1) {\\n factor = 1;\\n} else if (prevValue < 10) {\\n factor = 10;\\n} else if (prevValue < 100) {\\n factor = 100;\\n}\\nlet value = prevValue + Math.random() * factor;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 1100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{},\"_hash\":0.8587686344902596,\"funcBody\":\"let factor = 1000;\\nif (prevValue < 1) {\\n factor = 1;\\n} else if (prevValue < 10) {\\n factor = 10;\\n} else if (prevValue < 100) {\\n factor = 100;\\n}\\nlet value = prevValue + Math.random() * factor;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 1100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"layout\":\"left\",\"autoScale\":true,\"showValue\":true,\"valueFont\":{\"family\":\"Roboto\",\"size\":28,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\",\"lineHeight\":\"32px\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":0.1,\"color\":\"rgba(0, 0, 0, 0.87)\"},{\"from\":0.1,\"to\":1,\"color\":\"#FFA600\"},{\"from\":1,\"to\":10,\"color\":\"#F36900\"},{\"from\":10,\"to\":100,\"color\":\"#F04022\"},{\"from\":100,\"to\":1000,\"color\":\"#D81838\"},{\"from\":1000,\"to\":null,\"color\":\"#6F113A\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"color\",\"color\":\"#fff\",\"overlay\":{\"enabled\":false,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}}},\"title\":\"Vibration\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":null,\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"vibration\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"18px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":true,\"decimals\":1,\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null,\"units\":\"m/s²\",\"displayTimewindow\":true,\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1697382151041,\"endTimeMs\":1697468551041},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"timewindowStyle\":{\"showIcon\":false,\"iconSize\":\"24px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":true}}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "vibration" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/simple_vibration_chart_card_with_background.json b/application/src/main/data/json/system/widget_types/simple_vibration_chart_card_with_background.json new file mode 100644 index 0000000000..21cf352901 --- /dev/null +++ b/application/src/main/data/json/system/widget_types/simple_vibration_chart_card_with_background.json @@ -0,0 +1,31 @@ +{ + "fqn": "simple_vibration_chart_card_with_background", + "name": "Simple vibration chart card with background", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays historical vibration values as a simplified chart with background. Optionally may display the corresponding latest vibration value.", + "descriptor": { + "type": "timeseries", + "sizeX": 4.5, + "sizeY": 2, + "resources": [], + "templateHtml": "\n\n", + "templateCss": ".legend {\n font-size: 13px;\n line-height: 10px;\n}\n\n.legend table { \n border-spacing: 0px;\n border-collapse: separate;\n}\n\n.mouse-events .flot-overlay {\n cursor: crosshair; \n}\n\n", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueChartCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueChartCardWidget.onDataUpdated();\n};\n\nself.onLatestDataUpdated = function() {\n self.ctx.$scope.valueChartCardWidget.onLatestDataUpdated();\n}\n\nself.onEditModeChanged = function() {\n self.ctx.$scope.valueChartCardWidget.onEditModeChanged();\n}\n\nself.onDestroy = function() {\n self.ctx.$scope.valueChartCardWidget.onDestroy();\n}\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '300px',\n previewHeight: '150px',\n embedTitlePanel: true,\n hasAdditionalLatestDataKeys: true,\n defaultDataKeysFunction: function() {\n return [\n { name: 'vibration', label: 'Vibration', type: 'timeseries', color: 'rgba(0, 0, 0, 0.87)'}\n ];\n },\n defaultLatestDataKeysFunction: function(configComponent) {\n return [{ name: 'vibration', label: 'Latest', type: 'timeseries'}];\n }\n };\n}\n", + "settingsSchema": "{}", + "dataKeySettingsSchema": "{}", + "latestDataKeySettingsSchema": "{}", + "settingsDirective": "tb-value-chart-card-widget-settings", + "dataKeySettingsDirective": "", + "latestDataKeySettingsDirective": "", + "hasBasicMode": true, + "basicModeDirective": "tb-value-chart-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Vibration\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{},\"_hash\":0.8587686344902596,\"funcBody\":\"let factor = 1000;\\nif (prevValue < 1) {\\n factor = 1;\\n} else if (prevValue < 10) {\\n factor = 10;\\n} else if (prevValue < 100) {\\n factor = 100;\\n}\\nlet value = prevValue + Math.random() * factor;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 1100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{},\"_hash\":0.8587686344902596,\"funcBody\":\"let factor = 1000;\\nif (prevValue < 1) {\\n factor = 1;\\n} else if (prevValue < 10) {\\n factor = 10;\\n} else if (prevValue < 100) {\\n factor = 100;\\n}\\nlet value = prevValue + Math.random() * factor;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 1100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"layout\":\"left\",\"autoScale\":true,\"showValue\":true,\"valueFont\":{\"family\":\"Roboto\",\"size\":28,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\",\"lineHeight\":\"32px\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":0.1,\"color\":\"rgba(0, 0, 0, 0.87)\"},{\"from\":0.1,\"to\":1,\"color\":\"#F89E0D\"},{\"from\":1,\"to\":10,\"color\":\"#F77410\"},{\"from\":10,\"to\":100,\"color\":\"#F04022\"},{\"from\":100,\"to\":1000,\"color\":\"#DE2343\"},{\"from\":1000,\"to\":null,\"color\":\"#791541\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"image\",\"imageBase64\":\"data:image/png;base64,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\",\"imageUrl\":null,\"color\":\"#fff\",\"overlay\":{\"enabled\":true,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}}},\"title\":\"Vibration\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":null,\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"vibration\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"18px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":true,\"decimals\":1,\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null,\"units\":\"m/s²\",\"displayTimewindow\":true,\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1697382151041,\"endTimeMs\":1697468551041},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"timewindowStyle\":{\"showIcon\":false,\"iconSize\":\"24px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":true}}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "vibration" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/vibration_card.json b/application/src/main/data/json/system/widget_types/vibration_card.json new file mode 100644 index 0000000000..5afa70f0ee --- /dev/null +++ b/application/src/main/data/json/system/widget_types/vibration_card.json @@ -0,0 +1,28 @@ +{ + "fqn": "vibration_card", + "name": "Vibration card", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays a latest vibration telemetry data in a box layout.", + "descriptor": { + "type": "latest", + "sizeX": 3, + "sizeY": 3, + "resources": [], + "templateHtml": "\n", + "templateCss": "", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueCardWidget.onDataUpdated();\n};\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '250px',\n previewHeight: '250px',\n embedTitlePanel: true,\n defaultDataKeysFunction: function() {\n return [{ name: 'vibration', label: 'Vibration ', type: 'timeseries' }];\n }\n };\n};\n\nself.onDestroy = function() {\n};\n", + "settingsSchema": "", + "dataKeySettingsSchema": "", + "settingsDirective": "tb-value-card-widget-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"function\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Vibration\",\"color\":\"#2196f3\",\"settings\":{},\"_hash\":0.2392660816082064,\"funcBody\":\"let factor = 1000;\\nif (prevValue < 1) {\\n factor = 1;\\n} else if (prevValue < 10) {\\n factor = 10;\\n} else if (prevValue < 100) {\\n factor = 100;\\n}\\nlet value = prevValue + Math.random() * factor;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 1100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]}}],\"timewindow\":{\"realtime\":{\"timewindowMs\":60000}},\"showTitle\":false,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"padding\":\"0px\",\"settings\":{\"labelPosition\":\"top\",\"layout\":\"square\",\"showLabel\":true,\"labelFont\":{\"family\":\"Roboto\",\"size\":16,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"labelColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showIcon\":true,\"iconSize\":40,\"iconSizeUnit\":\"px\",\"icon\":\"vibration\",\"iconColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":0.1,\"color\":\"rgba(0, 0, 0, 0.87)\"},{\"from\":0.1,\"to\":1,\"color\":\"#FFA600\"},{\"from\":1,\"to\":10,\"color\":\"#F36900\"},{\"from\":10,\"to\":100,\"color\":\"#F04022\"},{\"from\":100,\"to\":1000,\"color\":\"#D81838\"},{\"from\":1000,\"to\":null,\"color\":\"#6F113A\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"valueFont\":{\"size\":28,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\",\"rangeList\":[{\"from\":null,\"to\":0.1,\"color\":\"rgba(0, 0, 0, 0.87)\"},{\"from\":0.1,\"to\":1,\"color\":\"#FFA600\"},{\"from\":1,\"to\":10,\"color\":\"#F36900\"},{\"from\":10,\"to\":100,\"color\":\"#F04022\"},{\"from\":100,\"to\":1000,\"color\":\"#D81838\"},{\"from\":1000,\"to\":null,\"color\":\"#6F113A\"}]},\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"dateColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"color\",\"color\":\"#fff\",\"overlay\":{\"enabled\":false,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Vibration card\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"units\":\"m/s²\",\"decimals\":1,\"useDashboardTimewindow\":true,\"showLegend\":false,\"widgetStyle\":{},\"actions\":{},\"configMode\":\"basic\",\"displayTimewindow\":true,\"margin\":\"0px\",\"borderRadius\":\"0px\",\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"showTitleIcon\":false,\"titleTooltip\":\"\",\"titleFont\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1.6\"},\"titleIcon\":\"\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"iconSize\":\"14px\",\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"14px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1\"},\"color\":null}}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "vibration" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/vibration_card_with_background.json b/application/src/main/data/json/system/widget_types/vibration_card_with_background.json new file mode 100644 index 0000000000..92b82633f3 --- /dev/null +++ b/application/src/main/data/json/system/widget_types/vibration_card_with_background.json @@ -0,0 +1,28 @@ +{ + "fqn": "vibration_card_with_background", + "name": "Vibration card with background", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays a latest vibration telemetry data in a box layout with background.", + "descriptor": { + "type": "latest", + "sizeX": 3, + "sizeY": 3, + "resources": [], + "templateHtml": "\n", + "templateCss": "", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueCardWidget.onDataUpdated();\n};\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '250px',\n previewHeight: '250px',\n embedTitlePanel: true,\n defaultDataKeysFunction: function() {\n return [{ name: 'vibration', label: 'Vibration ', type: 'timeseries' }];\n }\n };\n};\n\nself.onDestroy = function() {\n};\n", + "settingsSchema": "", + "dataKeySettingsSchema": "", + "settingsDirective": "tb-value-card-widget-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"function\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Vibration\",\"color\":\"#2196f3\",\"settings\":{},\"_hash\":0.2392660816082064,\"funcBody\":\"let factor = 1000;\\nif (prevValue < 1) {\\n factor = 1;\\n} else if (prevValue < 10) {\\n factor = 10;\\n} else if (prevValue < 100) {\\n factor = 100;\\n}\\nlet value = prevValue + Math.random() * factor;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 1100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]}}],\"timewindow\":{\"realtime\":{\"timewindowMs\":60000}},\"showTitle\":false,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"padding\":\"0px\",\"settings\":{\"labelPosition\":\"top\",\"layout\":\"square\",\"showLabel\":true,\"labelFont\":{\"family\":\"Roboto\",\"size\":16,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"labelColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showIcon\":true,\"iconSize\":40,\"iconSizeUnit\":\"px\",\"icon\":\"vibration\",\"iconColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":0.1,\"color\":\"rgba(0, 0, 0, 0.87)\"},{\"from\":0.1,\"to\":1,\"color\":\"#F89E0D\"},{\"from\":1,\"to\":10,\"color\":\"#F77410\"},{\"from\":10,\"to\":100,\"color\":\"#F04022\"},{\"from\":100,\"to\":1000,\"color\":\"#DE2343\"},{\"from\":1000,\"to\":null,\"color\":\"#791541\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"valueFont\":{\"size\":28,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\",\"rangeList\":[{\"from\":null,\"to\":0.1,\"color\":\"rgba(0, 0, 0, 0.87)\"},{\"from\":0.1,\"to\":1,\"color\":\"#F89E0D\"},{\"from\":1,\"to\":10,\"color\":\"#F77410\"},{\"from\":10,\"to\":100,\"color\":\"#F04022\"},{\"from\":100,\"to\":1000,\"color\":\"#DE2343\"},{\"from\":1000,\"to\":null,\"color\":\"#791541\"}]},\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"dateColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"image\",\"imageBase64\":\"data:image/png;base64,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\",\"imageUrl\":null,\"color\":\"#fff\",\"overlay\":{\"enabled\":true,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Vibration card\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"units\":\"m/s²\",\"decimals\":1,\"useDashboardTimewindow\":true,\"showLegend\":false,\"widgetStyle\":{},\"actions\":{},\"configMode\":\"basic\",\"displayTimewindow\":true,\"margin\":\"0px\",\"borderRadius\":\"0px\",\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"showTitleIcon\":false,\"titleTooltip\":\"\",\"titleFont\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1.6\"},\"titleIcon\":\"\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"iconSize\":\"14px\",\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"14px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1\"},\"color\":null}}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "vibration" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/vibration_chart_card.json b/application/src/main/data/json/system/widget_types/vibration_chart_card.json new file mode 100644 index 0000000000..32fc30dfee --- /dev/null +++ b/application/src/main/data/json/system/widget_types/vibration_chart_card.json @@ -0,0 +1,31 @@ +{ + "fqn": "vibration_chart_card", + "name": "Vibration chart card", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays a vibration data as a combination of the latest and aggregated values. Optionally may display the corresponding historical values as a simplified chart.", + "descriptor": { + "type": "timeseries", + "sizeX": 4.5, + "sizeY": 3.5, + "resources": [], + "templateHtml": "\n\n", + "templateCss": ".legend {\n font-size: 13px;\n line-height: 10px;\n}\n\n.legend table { \n border-spacing: 0px;\n border-collapse: separate;\n}\n\n.mouse-events .flot-overlay {\n cursor: crosshair; \n}\n\n", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onDataUpdated();\n};\n\nself.onLatestDataUpdated = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onLatestDataUpdated();\n}\n\nself.onResize = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onResize();\n}\n\nself.onEditModeChanged = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onEditModeChanged();\n}\n\nself.onDestroy = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onDestroy();\n}\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '400px',\n previewHeight: '300px',\n embedTitlePanel: true,\n hasAdditionalLatestDataKeys: true,\n defaultDataKeysFunction: function() {\n return [\n { name: 'vibration', label: 'Vibration', type: 'timeseries', color: 'rgba(0, 0, 0, 0.87)', units: 'm/s²', decimals: 1 }\n ];\n },\n defaultLatestDataKeysFunction: function(configComponent, configData) {\n return configComponent.createDefaultAggregatedValueLatestDataKeys(configData, 'vibration', 'm/s²', 1);\n }\n };\n}\n", + "settingsSchema": "{}", + "dataKeySettingsSchema": "{}", + "latestDataKeySettingsSchema": "{}", + "settingsDirective": "tb-aggregated-value-card-widget-settings", + "dataKeySettingsDirective": "", + "latestDataKeySettingsDirective": "tb-aggregated-value-card-key-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-aggregated-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"Main building\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Vibration\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{\"showLines\":true,\"fillLines\":true,\"showPoints\":false},\"_hash\":0.8587686344902596,\"funcBody\":\"let factor = 1000;\\nif (prevValue < 1) {\\n factor = 1;\\n} else if (prevValue < 10) {\\n factor = 10;\\n} else if (prevValue < 100) {\\n factor = 100;\\n}\\nlet value = prevValue + Math.random() * factor;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 1100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"m/s²\",\"decimals\":1,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"#4caf50\",\"settings\":{\"position\":\"center\",\"font\":{\"size\":36,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"1\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":0.1,\"color\":\"rgba(0, 0, 0, 0.87)\"},{\"from\":0.1,\"to\":1,\"color\":\"#FFA600\"},{\"from\":1,\"to\":10,\"color\":\"#F36900\"},{\"from\":10,\"to\":100,\"color\":\"#F04022\"},{\"from\":100,\"to\":1000,\"color\":\"#D81838\"},{\"from\":1000,\"to\":null,\"color\":\"#6F113A\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.9408410830697858,\"funcBody\":\"let factor = 1000;\\nif (prevValue < 1) {\\n factor = 1;\\n} else if (prevValue < 10) {\\n factor = 10;\\n} else if (prevValue < 100) {\\n factor = 100;\\n}\\nlet value = prevValue + Math.random() * factor;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 1100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"m/s²\",\"decimals\":1,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta percent\",\"color\":\"#f44336\",\"settings\":{\"position\":\"rightTop\",\"font\":{\"size\":14,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"20px\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[{\"from\":null,\"to\":0,\"color\":\"#198038\"},{\"from\":0,\"to\":0,\"color\":\"rgba(0, 0, 0, 0.87)\"},{\"from\":0,\"to\":null,\"color\":\"#D12730\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":true},\"_hash\":0.06392321853157967,\"funcBody\":\"var value = prevValue + Math.random() * 6 - 3;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < -25) {\\n\\tvalue = -25;\\n} else if (value > 25) {\\n\\tvalue = 25;\\n} \\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta absolute\",\"color\":\"#607d8b\",\"settings\":{\"position\":\"rightBottom\",\"font\":{\"size\":11,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.44695098620509865,\"funcBody\":\"var value = prevValue + Math.random() * 200 - 100;\\nif (value < -100) {\\n\\tvalue = -100;\\n} else if (value > 100) {\\n\\tvalue = 100;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"m/s²\",\"decimals\":1,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1691927717318,\"endTimeMs\":1692014117318},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"stack\":false,\"fontSize\":10,\"fontColor\":\"#545454\",\"showTooltip\":true,\"tooltipIndividual\":false,\"tooltipCumulative\":false,\"hideZeros\":false,\"grid\":{\"verticalLines\":true,\"horizontalLines\":true,\"outlineWidth\":1,\"color\":\"#545454\",\"backgroundColor\":null,\"tickColor\":\"#DDDDDD\"},\"xaxis\":{\"title\":null,\"showLabels\":true,\"color\":\"#545454\"},\"yaxis\":{\"min\":null,\"max\":null,\"title\":null,\"showLabels\":true,\"color\":\"#545454\",\"tickSize\":null,\"tickDecimals\":0,\"ticksFormatter\":\"\"},\"shadowSize\":4,\"smoothLines\":false,\"comparisonEnabled\":false,\"xaxisSecond\":{\"axisPosition\":\"top\",\"title\":null,\"showLabels\":true},\"showLegend\":true,\"legendConfig\":{\"direction\":\"column\",\"position\":\"bottom\",\"sortDataKeys\":false,\"showMin\":false,\"showMax\":false,\"showAvg\":true,\"showTotal\":false,\"showLatest\":false},\"customLegendEnabled\":false,\"showSubtitle\":true,\"subtitle\":\"${entityName}\",\"subtitleFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"subtitleColor\":\"rgba(0, 0, 0, 0.38)\",\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"dateColor\":\"rgba(0, 0, 0, 0.38)\",\"showChart\":true,\"chartColor\":\"rgba(0, 0, 0, 0.87)\",\"background\":{\"type\":\"color\",\"color\":\"#fff\",\"overlay\":{\"enabled\":false,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Vibration\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"vibration\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"24px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":false,\"displayTimewindow\":true,\"decimals\":0,\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"24px\",\"icon\":null,\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":false},\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "vibration" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/vibration_chart_card_with_background.json b/application/src/main/data/json/system/widget_types/vibration_chart_card_with_background.json new file mode 100644 index 0000000000..04e3d5ed24 --- /dev/null +++ b/application/src/main/data/json/system/widget_types/vibration_chart_card_with_background.json @@ -0,0 +1,31 @@ +{ + "fqn": "vibration_chart_card_with_background", + "name": "Vibration chart card with background", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays a vibration data as a combination of the latest and aggregated values with background. Optionally may display the corresponding historical values as a simplified chart.", + "descriptor": { + "type": "timeseries", + "sizeX": 4.5, + "sizeY": 3.5, + "resources": [], + "templateHtml": "\n\n", + "templateCss": ".legend {\n font-size: 13px;\n line-height: 10px;\n}\n\n.legend table { \n border-spacing: 0px;\n border-collapse: separate;\n}\n\n.mouse-events .flot-overlay {\n cursor: crosshair; \n}\n\n", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onDataUpdated();\n};\n\nself.onLatestDataUpdated = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onLatestDataUpdated();\n}\n\nself.onResize = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onResize();\n}\n\nself.onEditModeChanged = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onEditModeChanged();\n}\n\nself.onDestroy = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onDestroy();\n}\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '400px',\n previewHeight: '300px',\n embedTitlePanel: true,\n hasAdditionalLatestDataKeys: true,\n defaultDataKeysFunction: function() {\n return [\n { name: 'vibration', label: 'Vibration', type: 'timeseries', color: 'rgba(0, 0, 0, 0.87)', units: 'm/s²', decimals: 1 }\n ];\n },\n defaultLatestDataKeysFunction: function(configComponent, configData) {\n return configComponent.createDefaultAggregatedValueLatestDataKeys(configData, 'vibration', 'm/s²', 1);\n }\n };\n}\n", + "settingsSchema": "{}", + "dataKeySettingsSchema": "{}", + "latestDataKeySettingsSchema": "{}", + "settingsDirective": "tb-aggregated-value-card-widget-settings", + "dataKeySettingsDirective": "", + "latestDataKeySettingsDirective": "tb-aggregated-value-card-key-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-aggregated-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"Main building\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Vibration\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{\"showLines\":true,\"fillLines\":true,\"showPoints\":false},\"_hash\":0.8587686344902596,\"funcBody\":\"let factor = 1000;\\nif (prevValue < 1) {\\n factor = 1;\\n} else if (prevValue < 10) {\\n factor = 10;\\n} else if (prevValue < 100) {\\n factor = 100;\\n}\\nlet value = prevValue + Math.random() * factor;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 1100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"m/s²\",\"decimals\":1,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"#4caf50\",\"settings\":{\"position\":\"center\",\"font\":{\"size\":36,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"1\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":0.1,\"color\":\"rgba(0, 0, 0, 0.87)\"},{\"from\":0.1,\"to\":1,\"color\":\"#F89E0D\"},{\"from\":1,\"to\":10,\"color\":\"#F77410\"},{\"from\":10,\"to\":100,\"color\":\"#F04022\"},{\"from\":100,\"to\":1000,\"color\":\"#DE2343\"},{\"from\":1000,\"to\":null,\"color\":\"#791541\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.9408410830697858,\"funcBody\":\"let factor = 1000;\\nif (prevValue < 1) {\\n factor = 1;\\n} else if (prevValue < 10) {\\n factor = 10;\\n} else if (prevValue < 100) {\\n factor = 100;\\n}\\nlet value = prevValue + Math.random() * factor;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 1100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"m/s²\",\"decimals\":1,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta percent\",\"color\":\"#f44336\",\"settings\":{\"position\":\"rightTop\",\"font\":{\"size\":14,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"20px\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[{\"from\":null,\"to\":0,\"color\":\"#198038\"},{\"from\":0,\"to\":0,\"color\":\"rgba(0, 0, 0, 0.87)\"},{\"from\":0,\"to\":null,\"color\":\"#D12730\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":true},\"_hash\":0.06392321853157967,\"funcBody\":\"var value = prevValue + Math.random() * 6 - 3;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < -25) {\\n\\tvalue = -25;\\n} else if (value > 25) {\\n\\tvalue = 25;\\n} \\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta absolute\",\"color\":\"#607d8b\",\"settings\":{\"position\":\"rightBottom\",\"font\":{\"size\":11,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.44695098620509865,\"funcBody\":\"var value = prevValue + Math.random() * 200 - 100;\\nif (value < -100) {\\n\\tvalue = -100;\\n} else if (value > 100) {\\n\\tvalue = 100;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"m/s²\",\"decimals\":1,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1691927717318,\"endTimeMs\":1692014117318},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"stack\":false,\"fontSize\":10,\"fontColor\":\"#545454\",\"showTooltip\":true,\"tooltipIndividual\":false,\"tooltipCumulative\":false,\"hideZeros\":false,\"grid\":{\"verticalLines\":true,\"horizontalLines\":true,\"outlineWidth\":1,\"color\":\"#545454\",\"backgroundColor\":null,\"tickColor\":\"#DDDDDD\"},\"xaxis\":{\"title\":null,\"showLabels\":true,\"color\":\"#545454\"},\"yaxis\":{\"min\":null,\"max\":null,\"title\":null,\"showLabels\":true,\"color\":\"#545454\",\"tickSize\":null,\"tickDecimals\":0,\"ticksFormatter\":\"\"},\"shadowSize\":4,\"smoothLines\":false,\"comparisonEnabled\":false,\"xaxisSecond\":{\"axisPosition\":\"top\",\"title\":null,\"showLabels\":true},\"showLegend\":true,\"legendConfig\":{\"direction\":\"column\",\"position\":\"bottom\",\"sortDataKeys\":false,\"showMin\":false,\"showMax\":false,\"showAvg\":true,\"showTotal\":false,\"showLatest\":false},\"customLegendEnabled\":false,\"showSubtitle\":true,\"subtitle\":\"${entityName}\",\"subtitleFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"subtitleColor\":\"rgba(0, 0, 0, 0.38)\",\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"dateColor\":\"rgba(0, 0, 0, 0.38)\",\"showChart\":true,\"chartColor\":\"rgba(0, 0, 0, 0.87)\",\"background\":{\"type\":\"image\",\"imageBase64\":\"data:image/png;base64,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\",\"imageUrl\":null,\"color\":\"#fff\",\"overlay\":{\"enabled\":true,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Vibration\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"vibration\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"24px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":false,\"displayTimewindow\":true,\"decimals\":0,\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"24px\",\"icon\":null,\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":false},\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "vibration" + ] +} \ No newline at end of file From 7f87c7c926de6a91280f02199dc663543835d619 Mon Sep 17 00:00:00 2001 From: Igor Kulikov Date: Wed, 25 Oct 2023 13:31:02 +0300 Subject: [PATCH 37/43] UI: Outdoor Environment: Leaf wetness widgets. --- .../widget_bundles/outdoor_environment.json | 12 ++++++- .../horizontal_leaf_wetness_card.json | 29 +++++++++++++++++ ...tal_leaf_wetness_card_with_background.json | 29 +++++++++++++++++ .../widget_types/leaf_wetness_card.json | 29 +++++++++++++++++ .../leaf_wetness_card_with_background.json | 29 +++++++++++++++++ .../widget_types/leaf_wetness_chart_card.json | 32 +++++++++++++++++++ ...af_wetness_chart_card_with_background.json | 32 +++++++++++++++++++ .../leaf_wetness_progress_bar.json | 30 +++++++++++++++++ ..._wetness_progress_bar_with_background.json | 30 +++++++++++++++++ .../simple_leaf_wetness_chart_card.json | 32 +++++++++++++++++++ ...af_wetness_chart_card_with_background.json | 32 +++++++++++++++++++ 11 files changed, 315 insertions(+), 1 deletion(-) create mode 100644 application/src/main/data/json/system/widget_types/horizontal_leaf_wetness_card.json create mode 100644 application/src/main/data/json/system/widget_types/horizontal_leaf_wetness_card_with_background.json create mode 100644 application/src/main/data/json/system/widget_types/leaf_wetness_card.json create mode 100644 application/src/main/data/json/system/widget_types/leaf_wetness_card_with_background.json create mode 100644 application/src/main/data/json/system/widget_types/leaf_wetness_chart_card.json create mode 100644 application/src/main/data/json/system/widget_types/leaf_wetness_chart_card_with_background.json create mode 100644 application/src/main/data/json/system/widget_types/leaf_wetness_progress_bar.json create mode 100644 application/src/main/data/json/system/widget_types/leaf_wetness_progress_bar_with_background.json create mode 100644 application/src/main/data/json/system/widget_types/simple_leaf_wetness_chart_card.json create mode 100644 application/src/main/data/json/system/widget_types/simple_leaf_wetness_chart_card_with_background.json diff --git a/application/src/main/data/json/system/widget_bundles/outdoor_environment.json b/application/src/main/data/json/system/widget_bundles/outdoor_environment.json index a5644dcea5..f66977a66a 100644 --- a/application/src/main/data/json/system/widget_bundles/outdoor_environment.json +++ b/application/src/main/data/json/system/widget_bundles/outdoor_environment.json @@ -119,6 +119,16 @@ "vibration_chart_card", "vibration_chart_card_with_background", "simple_vibration_chart_card", - "simple_vibration_chart_card_with_background" + "simple_vibration_chart_card_with_background", + "leaf_wetness_card", + "leaf_wetness_card_with_background", + "horizontal_leaf_wetness_card", + "horizontal_leaf_wetness_card_with_background", + "leaf_wetness_chart_card", + "leaf_wetness_chart_card_with_background", + "simple_leaf_wetness_chart_card", + "simple_leaf_wetness_chart_card_with_background", + "leaf_wetness_progress_bar", + "leaf_wetness_progress_bar_with_background" ] } \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/horizontal_leaf_wetness_card.json b/application/src/main/data/json/system/widget_types/horizontal_leaf_wetness_card.json new file mode 100644 index 0000000000..82c85c3c94 --- /dev/null +++ b/application/src/main/data/json/system/widget_types/horizontal_leaf_wetness_card.json @@ -0,0 +1,29 @@ +{ + "fqn": "horizontal_leaf_wetness_card", + "name": "Horizontal leaf wetness card", + "deprecated": false, + "image": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAMgAAACgCAMAAAB+IdObAAAAk1BMVEUAAADf39/f39/g4ODg4ODf39/////k5ORLcN3g4ODy8vLIyMhYWFjOzs5hguHo7fv5+fm7yfK7u7v09v2Opurb29utra3CwsK2trZmZmbV1dWlt+7n5+c9PT2QkJB0dHTd5PmaruzS2/d4lOWwwPBWed+Dned4k+WCgoJKSkrt7e1ti+MsLCzH0vSenp6dnZ2DnOgFpIuiAAAABnRSTlMAIEDfv1C6kOEmAAADEklEQVR42u3aaW+iQBzHcde2f8Y5GOSUm3rbc9//q9sB7Wq3DfqAbUbz+6QYHEIyXwZsEzsCAAAAAAAAAAAAAAAAAAAAAAAAAAAA+Em/rl6XMb5zrt3k7sF0OB5dPe6MR/ecboB3P5rQTZggxDIIsQ1CbIMQ2yDENheFxA4d+buMTjhkh4tCpDAvnJvNIS7jbp+3Ce1bwc2o2eXHbWDNtBNQJ1jm+tKQZvkYGvn8JETI9M3Z1VK8pET+Vki+c3ap9F/qeJeWtE2lU9WleKtN6MBy1tnPRrurDZtfFDJ12UF4EpJu30oeV2X3hsut9LdxGpeOdOKKSv4S129V7fP31Oc0sDXLp4bez45pWvwmcl/PhYSMfRtSCRHXzj6EpIxL8Z4KQR8hQjiZSONM1BUNbMH06fIQhRvK3eBMyCP7JmQnt5msK1Gmh5Bqy1+Il2nN07oNoUqmWWXutHcpfRqYy+g461c2D9xQsyn1h8zZ15ADTl/w4zD/2DgNja2eGVvo45V2dRjSmZA16ywOITYIGFvnLvt7LzUNTVf6XMiKGavD8/5IVgga8/LMlvRBu0u9zJveEGa4et9hTrVHfnJZQzPD5zWbn1uRJmd7c7JBM20+h2imlyyg57AvZMFY/rEgbs9jbgaf/h3g9F9M2aK7taZ04D5S7pqpbvo/tVxzZud45qyLMT9PEXU8j7yJagcm5BFRERfkRdH+gBkYNClwzcO+OF7WZhPQK3vVpqf398jSrEpnQychWaYiIZTZSyiJEt+bJSrLhPKflO8RqYL7fkRcdQeU8GlAet3ORlPn9EO4N4QCYp0w+BSiZlyoQu1Diiwy+2asiFQiupBJFJkQMSsEN7kJpyEFOvg6dPZvrWC9YqvNnI5iFSVqlomEtyui/CiZ8ZlQZuzJL4SiNsRrV6Tw4/ZAliT0w05DLhcVPQczEdElbAjxvL6DnC5hRYiNEGIbhNgGIbZBiG0mo/sb+JqdiN+Pxs4NfNHuOePR6OFu4ly7u/Et/VMNAAAAAAAAAAAAAAAAAAAAAAAAAAAAwA/5A5Ee9c9zue74AAAAAElFTkSuQmCC", + "description": "Displays a latest leaf wetness telemetry data in a horizontal layout.", + "descriptor": { + "type": "latest", + "sizeX": 5, + "sizeY": 1, + "resources": [], + "templateHtml": "\n", + "templateCss": "", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueCardWidget.onDataUpdated();\n};\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n horizontal: true,\n previewWidth: '420px',\n previewHeight: '90px',\n embedTitlePanel: true,\n defaultDataKeysFunction: function() {\n return [{ name: 'leaf', label: 'Leaf wetness', type: 'timeseries' }];\n }\n };\n};\n\nself.onDestroy = function() {\n};\n", + "settingsSchema": "", + "dataKeySettingsSchema": "", + "settingsDirective": "tb-value-card-widget-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"function\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Leaf wetness\",\"color\":\"#2196f3\",\"settings\":{},\"_hash\":0.2392660816082064,\"funcBody\":\"var value = prevValue + Math.random() * 7;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]}}],\"timewindow\":{\"realtime\":{\"timewindowMs\":60000}},\"showTitle\":false,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"padding\":\"0px\",\"settings\":{\"labelPosition\":\"top\",\"layout\":\"horizontal\",\"showLabel\":true,\"labelFont\":{\"family\":\"Roboto\",\"size\":16,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"labelColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showIcon\":true,\"iconSize\":40,\"iconSizeUnit\":\"px\",\"icon\":\"mdi:leaf\",\"iconColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":0,\"to\":10,\"color\":\"#4B70DD\"},{\"from\":10,\"to\":50,\"color\":\"#FFA600\"},{\"from\":50,\"to\":90,\"color\":\"#F36900\"},{\"from\":90,\"to\":null,\"color\":\"#D81838\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"valueFont\":{\"size\":36,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\",\"rangeList\":[{\"from\":0,\"to\":10,\"color\":\"#4B70DD\"},{\"from\":10,\"to\":50,\"color\":\"#FFA600\"},{\"from\":50,\"to\":90,\"color\":\"#F36900\"},{\"from\":90,\"to\":null,\"color\":\"#D81838\"}]},\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"dateColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"color\",\"color\":\"#fff\",\"overlay\":{\"enabled\":false,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Horizontal humidity card\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"units\":\"%\",\"decimals\":0,\"useDashboardTimewindow\":true,\"showLegend\":false,\"widgetStyle\":{},\"actions\":{},\"configMode\":\"basic\",\"displayTimewindow\":true,\"margin\":\"0px\",\"borderRadius\":\"0px\",\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"showTitleIcon\":false,\"titleTooltip\":\"\",\"titleFont\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1.6\"},\"titleIcon\":\"\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"iconSize\":\"14px\",\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"14px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1\"},\"color\":null}}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "leaf", + "wetness" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/horizontal_leaf_wetness_card_with_background.json b/application/src/main/data/json/system/widget_types/horizontal_leaf_wetness_card_with_background.json new file mode 100644 index 0000000000..57acfcf515 --- /dev/null +++ b/application/src/main/data/json/system/widget_types/horizontal_leaf_wetness_card_with_background.json @@ -0,0 +1,29 @@ +{ + "fqn": "horizontal_leaf_wetness_card_with_background", + "name": "Horizontal leaf wetness card with background", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays a latest leaf wetness telemetry data in a horizontal layout with background.", + "descriptor": { + "type": "latest", + "sizeX": 5, + "sizeY": 1, + "resources": [], + "templateHtml": "\n", + "templateCss": "", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueCardWidget.onDataUpdated();\n};\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n horizontal: true,\n previewWidth: '420px',\n previewHeight: '90px',\n embedTitlePanel: true,\n defaultDataKeysFunction: function() {\n return [{ name: 'leaf', label: 'Leaf wetness', type: 'timeseries' }];\n }\n };\n};\n\nself.onDestroy = function() {\n};\n", + "settingsSchema": "", + "dataKeySettingsSchema": "", + "settingsDirective": "tb-value-card-widget-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"function\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Leaf wetness\",\"color\":\"#2196f3\",\"settings\":{},\"_hash\":0.2392660816082064,\"funcBody\":\"var value = prevValue + Math.random() * 7;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]}}],\"timewindow\":{\"realtime\":{\"timewindowMs\":60000}},\"showTitle\":false,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"padding\":\"0px\",\"settings\":{\"labelPosition\":\"top\",\"layout\":\"horizontal\",\"showLabel\":true,\"labelFont\":{\"family\":\"Roboto\",\"size\":16,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"labelColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showIcon\":true,\"iconSize\":40,\"iconSizeUnit\":\"px\",\"icon\":\"mdi:leaf\",\"iconColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":0,\"to\":10,\"color\":\"#4369DD\"},{\"from\":10,\"to\":50,\"color\":\"#F89E0D\"},{\"from\":50,\"to\":90,\"color\":\"#F77410\"},{\"from\":90,\"to\":null,\"color\":\"#DE2343\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"valueFont\":{\"size\":36,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\",\"rangeList\":[{\"from\":0,\"to\":10,\"color\":\"#4369DD\"},{\"from\":10,\"to\":50,\"color\":\"#F89E0D\"},{\"from\":50,\"to\":90,\"color\":\"#F77410\"},{\"from\":90,\"to\":null,\"color\":\"#DE2343\"}]},\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"dateColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"image\",\"imageBase64\":\"data:image/png;base64,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\",\"imageUrl\":null,\"color\":\"#fff\",\"overlay\":{\"enabled\":true,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Horizontal humidity card\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"units\":\"%\",\"decimals\":0,\"useDashboardTimewindow\":true,\"showLegend\":false,\"widgetStyle\":{},\"actions\":{},\"configMode\":\"basic\",\"displayTimewindow\":true,\"margin\":\"0px\",\"borderRadius\":\"0px\",\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"showTitleIcon\":false,\"titleTooltip\":\"\",\"titleFont\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1.6\"},\"titleIcon\":\"\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"iconSize\":\"14px\",\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"14px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1\"},\"color\":null}}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "leaf", + "wetness" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/leaf_wetness_card.json b/application/src/main/data/json/system/widget_types/leaf_wetness_card.json new file mode 100644 index 0000000000..2c19b88b1f --- /dev/null +++ b/application/src/main/data/json/system/widget_types/leaf_wetness_card.json @@ -0,0 +1,29 @@ +{ + "fqn": "leaf_wetness_card", + "name": "Leaf wetness card", + "deprecated": false, + "image": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAMgAAACgCAMAAAB+IdObAAAAn1BMVEXg4ODf39/g4OAAAADg4ODf39/////h4eFLcN2rq6vo7fthguEhISE9PT3z8/PCwsK7u7vS2/ft7e3n5+e7yfLx8fGenp709v2lt+7IyMjV1dX5+fnOzs62traCgoJWed+wsLAvLy9KSkp0dHRYWFjH0vWwwPCOpep4lOVti+OQkJDd5PlmZmaDnOfa2tqkpKSOpuqar+yaruxtiuPb29sx7JjMAAAABnRSTlPvIL8Ar7DvmsykAAAF9UlEQVR42uzPQQ0AMAgDwDII/Enwb3U2Cuk5OLg91HZhDkPnegNDTB7QD5Un4EqkFCGjCBtF2CjCRhE2irBRhI0in716W3EbBgIwfDcjOTNFbiOn0oWKDtsmigLd93+5SqZNnNbBWxYvXtgfhAXCwR+R0Nb6gGytV0D07JuqZHhJG4JEnvs9KnJWLREWWh1y6Pqn/X7/1PfnwyJEEsJcSDO+t4T0zztx6zQHyRwyAKb2MEypfbFKGtwAmGydckQbKEidZGAHoAsHCW0h2fY6R702pD+Ku3YzEOeVJAmBTSaDmcY9hGQ0MUiqM2dC0oocIgXlyEJhldu6s8WDJGO8WxdyuIi/+jYD8QUxFEC01XPdWjwo9hhTdSIOpLGu/R5IGZFdhaBGGEhqjatCup34pxkItRIMPqQJxJXo0hAGSNTCCcRQK4IKxArAMaV1ISfxIoh3UNOUAScQ6dnIQBaih9YE0h41bTQ60taC5bIm5KtYgnhZA+elKoP20bgJRBOPAwxFk0MFOPsHk1ipoAxljKSzN5bjipBOLEEct+oz+ISggs9hAMUIY8XV0T5Q1mUD1ZuRFYwjes56XFBtwa+6tX7eHfIrZLM9hExO+o+deL+Qw+3u6C+3OWy2R5D+epl3k1N/hM22BDkd9uLWBTbbI8hZjO26u2vxO2y2hTPSwbOYdIb/69NneNiXt4HAcfwH7q+TE0z7xY4ZrcYVAmH47l9mF0Y7LqZHz1CvWkqJQrvv/2xVs5scNrlZyAle+CHD4Kj4ISKogi3xgnesBh1xGwEr3dF/kUi7Gqe75+SMLeRa5Baji3CeWxZb4/jS20REEBdbu4VRCaY4IIrzaIi0wDG2uIsITn3j2xtywnuRlSxFSTaJ8Us/g9a8TQmHYskgWQou0YGpjnmdR5p8z2u1rVEyk1LYReRb3XgNb/w4fiAi7IoLSRyzx5sIUEQDFhMdr9S6Fss1Xuc5Qh8ehVdFEaScLaTEPURw/gV833j8wUcnktbicFG6FyGnuaaRFtNFTDJmvc3L+iLCtarwDM3N0vMeIp3No37vAcrMkQ5cXAiwK/sIIFiYKlK1eFlqKgWBup6C+SYihfsdcYSQkC6RskucCbuJ/L4dx98n3KNEdLgk1QOrKsMQAE6kC7yhcE0NmQRJIRpSQUMdsFIfHa/VRBlrre8ncjw//zudnn8+4SE8HiGLkBvzp1HxCKI2zC/TKTIqU2Q0pshoTJHRmCKjMUVGY4qMxhQZjSkyGlNkNKbIaEyR0ZgiozFFRmOKjMZnihz/s28+LQ7CQBS/lZA5BQLmllM0IgVtv/9329nJDtvYHde9vQXfoVWTQn/MnzdS22t4Wx+3bVz0DBdkcL2m3fLmRKtv57ggyzFI1eskoQIGCYcgka/UEiZ+S5qJoCDRsehbj/3vw88bi0nyTUSUMEESc2RzlRejxk1CMTI1Jsikzw9ZD62G1wNPTIYJUj+r4DTIykUEWiNcBe5x1JuL9rZFCopQiz1LQ7JE7CBfpeGYi08javt1rCj+PhitYORaZ9xJzgjVR8QP05Yda477tJEYNGUvheJRQXo/pGL9iyMvkmcJ1tmL61XeHbMS1TQ0C8EdUVKLxDTdSY6yOVKJheCCBAbI4007k5k8aiGwIKyFg6Ak9riiFuJDWEBBdjN7+GlFLSTIForgIFIwo7VE8tqUsEGK+R3FQsR0cmsLBRokGCBqIbXViZ+dq9AgVkTUQnh11H0DFkh0rNjXiGUh/VDvsUAkmR5d11oMC8EGGbLMgy+ZRQcWwssFFKRlE3mJDklmWRbCYuoEWiM6p8/rOjsjIMOkV6tETz4zw3UtLyRN1o1s9C8VdV8zv0Y4EHEF1XyY+fDOXu7ZsXKNv299OtazwM5aPgR/sqh4J/z0e06w9yN/0AVygfwXXSBoukDQdIF8tHcHVADCMBBDrxtQBfNvFRtZX76DKAiNITSG0BhCYwiNITSG0BhCYwiNITSG0BhCYwiNITSG0BhCYwiNITSdfCN01ohl83lTGVByUtn19O2yav/eUkL1IMIcZgAAAABJRU5ErkJggg==", + "description": "Displays a latest leaf wetness telemetry data in a box layout.", + "descriptor": { + "type": "latest", + "sizeX": 3, + "sizeY": 3, + "resources": [], + "templateHtml": "\n", + "templateCss": "", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueCardWidget.onDataUpdated();\n};\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '250px',\n previewHeight: '250px',\n embedTitlePanel: true,\n defaultDataKeysFunction: function() {\n return [{ name: 'leaf', label: 'Leaf wetness', type: 'timeseries' }];\n }\n };\n};\n\nself.onDestroy = function() {\n};\n", + "settingsSchema": "", + "dataKeySettingsSchema": "", + "settingsDirective": "tb-value-card-widget-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"function\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Leaf wetness\",\"color\":\"#2196f3\",\"settings\":{},\"_hash\":0.2392660816082064,\"funcBody\":\"var value = prevValue + Math.random() * 7;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]}}],\"timewindow\":{\"realtime\":{\"timewindowMs\":60000}},\"showTitle\":false,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"padding\":\"0px\",\"settings\":{\"labelPosition\":\"top\",\"layout\":\"square\",\"showLabel\":true,\"labelFont\":{\"family\":\"Roboto\",\"size\":16,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"labelColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showIcon\":true,\"iconSize\":40,\"iconSizeUnit\":\"px\",\"icon\":\"mdi:leaf\",\"iconColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":0,\"to\":10,\"color\":\"#4B70DD\"},{\"from\":10,\"to\":50,\"color\":\"#FFA600\"},{\"from\":50,\"to\":90,\"color\":\"#F36900\"},{\"from\":90,\"to\":null,\"color\":\"#D81838\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"valueFont\":{\"family\":\"Roboto\",\"size\":52,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\",\"rangeList\":[{\"from\":0,\"to\":10,\"color\":\"#4B70DD\"},{\"from\":10,\"to\":50,\"color\":\"#FFA600\"},{\"from\":50,\"to\":90,\"color\":\"#F36900\"},{\"from\":90,\"to\":null,\"color\":\"#D81838\"}]},\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"dateColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"color\",\"color\":\"#fff\",\"overlay\":{\"enabled\":false,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Humidity card\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"units\":\"%\",\"decimals\":0,\"useDashboardTimewindow\":true,\"showLegend\":false,\"widgetStyle\":{},\"actions\":{},\"configMode\":\"basic\",\"displayTimewindow\":true,\"margin\":\"0px\",\"borderRadius\":\"0px\",\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"showTitleIcon\":false,\"titleTooltip\":\"\",\"titleFont\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1.6\"},\"titleIcon\":\"\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"iconSize\":\"14px\",\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"14px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1\"},\"color\":null}}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "leaf", + "wetness" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/leaf_wetness_card_with_background.json b/application/src/main/data/json/system/widget_types/leaf_wetness_card_with_background.json new file mode 100644 index 0000000000..5c61b126cb --- /dev/null +++ b/application/src/main/data/json/system/widget_types/leaf_wetness_card_with_background.json @@ -0,0 +1,29 @@ +{ + "fqn": "leaf_wetness_card_with_background", + "name": "Leaf wetness card with background", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays a latest leaf wetness telemetry data in a box layout with background.", + "descriptor": { + "type": "latest", + "sizeX": 3, + "sizeY": 3, + "resources": [], + "templateHtml": "\n", + "templateCss": "", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueCardWidget.onDataUpdated();\n};\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '250px',\n previewHeight: '250px',\n embedTitlePanel: true,\n defaultDataKeysFunction: function() {\n return [{ name: 'leaf', label: 'Leaf wetness', type: 'timeseries' }];\n }\n };\n};\n\nself.onDestroy = function() {\n};\n", + "settingsSchema": "", + "dataKeySettingsSchema": "", + "settingsDirective": "tb-value-card-widget-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"function\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Leaf wetness\",\"color\":\"#2196f3\",\"settings\":{},\"_hash\":0.2392660816082064,\"funcBody\":\"var value = prevValue + Math.random() * 7;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]}}],\"timewindow\":{\"realtime\":{\"timewindowMs\":60000}},\"showTitle\":false,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"padding\":\"0px\",\"settings\":{\"labelPosition\":\"top\",\"layout\":\"square\",\"showLabel\":true,\"labelFont\":{\"family\":\"Roboto\",\"size\":16,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"labelColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showIcon\":true,\"iconSize\":40,\"iconSizeUnit\":\"px\",\"icon\":\"mdi:leaf\",\"iconColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":0,\"to\":10,\"color\":\"#4369DD\"},{\"from\":10,\"to\":50,\"color\":\"#F89E0D\"},{\"from\":50,\"to\":90,\"color\":\"#F77410\"},{\"from\":90,\"to\":null,\"color\":\"#DE2343\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"valueFont\":{\"family\":\"Roboto\",\"size\":52,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\",\"rangeList\":[{\"from\":0,\"to\":10,\"color\":\"#4369DD\"},{\"from\":10,\"to\":50,\"color\":\"#F89E0D\"},{\"from\":50,\"to\":90,\"color\":\"#F77410\"},{\"from\":90,\"to\":null,\"color\":\"#DE2343\"}]},\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"dateColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"image\",\"imageBase64\":\"data:image/png;base64,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\",\"imageUrl\":null,\"color\":\"#fff\",\"overlay\":{\"enabled\":true,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Humidity card\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"units\":\"%\",\"decimals\":0,\"useDashboardTimewindow\":true,\"showLegend\":false,\"widgetStyle\":{},\"actions\":{},\"configMode\":\"basic\",\"displayTimewindow\":true,\"margin\":\"0px\",\"borderRadius\":\"0px\",\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"showTitleIcon\":false,\"titleTooltip\":\"\",\"titleFont\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1.6\"},\"titleIcon\":\"\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"iconSize\":\"14px\",\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"14px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1\"},\"color\":null}}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "leaf", + "wetness" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/leaf_wetness_chart_card.json b/application/src/main/data/json/system/widget_types/leaf_wetness_chart_card.json new file mode 100644 index 0000000000..39692a4fce --- /dev/null +++ b/application/src/main/data/json/system/widget_types/leaf_wetness_chart_card.json @@ -0,0 +1,32 @@ +{ + "fqn": "leaf_wetness_chart_card", + "name": "Leaf wetness chart card", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays a leaf wetness data as a combination of the latest and aggregated values. Optionally may display the corresponding historical values as a simplified chart.", + "descriptor": { + "type": "timeseries", + "sizeX": 4.5, + "sizeY": 3.5, + "resources": [], + "templateHtml": "\n\n", + "templateCss": ".legend {\n font-size: 13px;\n line-height: 10px;\n}\n\n.legend table { \n border-spacing: 0px;\n border-collapse: separate;\n}\n\n.mouse-events .flot-overlay {\n cursor: crosshair; \n}\n\n", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onDataUpdated();\n};\n\nself.onLatestDataUpdated = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onLatestDataUpdated();\n}\n\nself.onResize = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onResize();\n}\n\nself.onEditModeChanged = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onEditModeChanged();\n}\n\nself.onDestroy = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onDestroy();\n}\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '400px',\n previewHeight: '300px',\n embedTitlePanel: true,\n hasAdditionalLatestDataKeys: true,\n defaultDataKeysFunction: function() {\n return [\n { name: 'leaf', label: 'Leaf wetness', type: 'timeseries', color: 'rgba(0, 0, 0, 0.87)', units: '%', decimals: 0 }\n ];\n },\n defaultLatestDataKeysFunction: function(configComponent, configData) {\n return configComponent.createDefaultAggregatedValueLatestDataKeys(configData, 'leaf', '%', 0);\n }\n };\n}\n", + "settingsSchema": "{}", + "dataKeySettingsSchema": "{}", + "latestDataKeySettingsSchema": "{}", + "settingsDirective": "tb-aggregated-value-card-widget-settings", + "dataKeySettingsDirective": "", + "latestDataKeySettingsDirective": "tb-aggregated-value-card-key-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-aggregated-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"Main building\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Leaf wetness\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{\"showLines\":true,\"fillLines\":true,\"showPoints\":false},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 7;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"#4caf50\",\"settings\":{\"position\":\"center\",\"font\":{\"size\":52,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"1\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":0,\"to\":10,\"color\":\"#4B70DD\"},{\"from\":10,\"to\":50,\"color\":\"#FFA600\"},{\"from\":50,\"to\":90,\"color\":\"#F36900\"},{\"from\":90,\"to\":null,\"color\":\"#D81838\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.9408410830697858,\"funcBody\":\"var value = prevValue + Math.random() * 7;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta percent\",\"color\":\"#f44336\",\"settings\":{\"position\":\"rightTop\",\"font\":{\"size\":14,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"20px\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[{\"from\":null,\"to\":0,\"color\":\"#198038\"},{\"from\":0,\"to\":0,\"color\":\"rgba(0, 0, 0, 0.87)\"},{\"from\":0,\"to\":null,\"color\":\"#D12730\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":true},\"_hash\":0.06392321853157967,\"funcBody\":\"var value = prevValue + Math.random() * 6 - 3;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < -25) {\\n\\tvalue = -25;\\n} else if (value > 25) {\\n\\tvalue = 25;\\n} \\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta absolute\",\"color\":\"#607d8b\",\"settings\":{\"position\":\"rightBottom\",\"font\":{\"size\":11,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.44695098620509865,\"funcBody\":\"var value = prevValue + Math.random() * 4 - 2;\\nif (value < -6) {\\n\\tvalue = -6;\\n} else if (value > 6) {\\n\\tvalue = 6;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":1,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1691927717318,\"endTimeMs\":1692014117318},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"stack\":false,\"fontSize\":10,\"fontColor\":\"#545454\",\"showTooltip\":true,\"tooltipIndividual\":false,\"tooltipCumulative\":false,\"hideZeros\":false,\"grid\":{\"verticalLines\":true,\"horizontalLines\":true,\"outlineWidth\":1,\"color\":\"#545454\",\"backgroundColor\":null,\"tickColor\":\"#DDDDDD\"},\"xaxis\":{\"title\":null,\"showLabels\":true,\"color\":\"#545454\"},\"yaxis\":{\"min\":null,\"max\":null,\"title\":null,\"showLabels\":true,\"color\":\"#545454\",\"tickSize\":null,\"tickDecimals\":0,\"ticksFormatter\":\"\"},\"shadowSize\":4,\"smoothLines\":false,\"comparisonEnabled\":false,\"xaxisSecond\":{\"axisPosition\":\"top\",\"title\":null,\"showLabels\":true},\"showLegend\":true,\"legendConfig\":{\"direction\":\"column\",\"position\":\"bottom\",\"sortDataKeys\":false,\"showMin\":false,\"showMax\":false,\"showAvg\":true,\"showTotal\":false,\"showLatest\":false},\"customLegendEnabled\":false,\"showSubtitle\":true,\"subtitle\":\"${entityName}\",\"subtitleFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"subtitleColor\":\"rgba(0, 0, 0, 0.38)\",\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"dateColor\":\"rgba(0, 0, 0, 0.38)\",\"showChart\":true,\"chartColor\":\"rgba(0, 0, 0, 0.87)\",\"background\":{\"type\":\"color\",\"color\":\"#fff\",\"overlay\":{\"enabled\":false,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Leaf wetness\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"mdi:leaf\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"24px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":false,\"displayTimewindow\":true,\"decimals\":0,\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"24px\",\"icon\":null,\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":false},\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "leaf", + "wetness" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/leaf_wetness_chart_card_with_background.json b/application/src/main/data/json/system/widget_types/leaf_wetness_chart_card_with_background.json new file mode 100644 index 0000000000..6a162ff6ba --- /dev/null +++ b/application/src/main/data/json/system/widget_types/leaf_wetness_chart_card_with_background.json @@ -0,0 +1,32 @@ +{ + "fqn": "leaf_wetness_chart_card_with_background", + "name": "Leaf wetness chart card with background", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays a leaf wetness data as a combination of the latest and aggregated values with background. Optionally may display the corresponding historical values as a simplified chart.", + "descriptor": { + "type": "timeseries", + "sizeX": 4.5, + "sizeY": 3.5, + "resources": [], + "templateHtml": "\n\n", + "templateCss": ".legend {\n font-size: 13px;\n line-height: 10px;\n}\n\n.legend table { \n border-spacing: 0px;\n border-collapse: separate;\n}\n\n.mouse-events .flot-overlay {\n cursor: crosshair; \n}\n\n", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onDataUpdated();\n};\n\nself.onLatestDataUpdated = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onLatestDataUpdated();\n}\n\nself.onResize = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onResize();\n}\n\nself.onEditModeChanged = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onEditModeChanged();\n}\n\nself.onDestroy = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onDestroy();\n}\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '400px',\n previewHeight: '300px',\n embedTitlePanel: true,\n hasAdditionalLatestDataKeys: true,\n defaultDataKeysFunction: function() {\n return [\n { name: 'leaf', label: 'Leaf wetness', type: 'timeseries', color: 'rgba(0, 0, 0, 0.87)', units: '%', decimals: 0 }\n ];\n },\n defaultLatestDataKeysFunction: function(configComponent, configData) {\n return configComponent.createDefaultAggregatedValueLatestDataKeys(configData, 'leaf', '%', 0);\n }\n };\n}\n", + "settingsSchema": "{}", + "dataKeySettingsSchema": "{}", + "latestDataKeySettingsSchema": "{}", + "settingsDirective": "tb-aggregated-value-card-widget-settings", + "dataKeySettingsDirective": "", + "latestDataKeySettingsDirective": "tb-aggregated-value-card-key-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-aggregated-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"Main building\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Leaf wetness\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{\"showLines\":true,\"fillLines\":true,\"showPoints\":false},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 7;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"#4caf50\",\"settings\":{\"position\":\"center\",\"font\":{\"size\":52,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"1\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":0,\"to\":10,\"color\":\"#4369DD\"},{\"from\":10,\"to\":50,\"color\":\"#F89E0D\"},{\"from\":50,\"to\":90,\"color\":\"#F77410\"},{\"from\":90,\"to\":null,\"color\":\"#DE2343\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.9408410830697858,\"funcBody\":\"var value = prevValue + Math.random() * 7;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta percent\",\"color\":\"#f44336\",\"settings\":{\"position\":\"rightTop\",\"font\":{\"size\":14,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"20px\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[{\"from\":null,\"to\":0,\"color\":\"#198038\"},{\"from\":0,\"to\":0,\"color\":\"rgba(0, 0, 0, 0.87)\"},{\"from\":0,\"to\":null,\"color\":\"#D12730\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":true},\"_hash\":0.06392321853157967,\"funcBody\":\"var value = prevValue + Math.random() * 6 - 3;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < -25) {\\n\\tvalue = -25;\\n} else if (value > 25) {\\n\\tvalue = 25;\\n} \\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta absolute\",\"color\":\"#607d8b\",\"settings\":{\"position\":\"rightBottom\",\"font\":{\"size\":11,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.44695098620509865,\"funcBody\":\"var value = prevValue + Math.random() * 4 - 2;\\nif (value < -6) {\\n\\tvalue = -6;\\n} else if (value > 6) {\\n\\tvalue = 6;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":1,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1691927717318,\"endTimeMs\":1692014117318},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"stack\":false,\"fontSize\":10,\"fontColor\":\"#545454\",\"showTooltip\":true,\"tooltipIndividual\":false,\"tooltipCumulative\":false,\"hideZeros\":false,\"grid\":{\"verticalLines\":true,\"horizontalLines\":true,\"outlineWidth\":1,\"color\":\"#545454\",\"backgroundColor\":null,\"tickColor\":\"#DDDDDD\"},\"xaxis\":{\"title\":null,\"showLabels\":true,\"color\":\"#545454\"},\"yaxis\":{\"min\":null,\"max\":null,\"title\":null,\"showLabels\":true,\"color\":\"#545454\",\"tickSize\":null,\"tickDecimals\":0,\"ticksFormatter\":\"\"},\"shadowSize\":4,\"smoothLines\":false,\"comparisonEnabled\":false,\"xaxisSecond\":{\"axisPosition\":\"top\",\"title\":null,\"showLabels\":true},\"showLegend\":true,\"legendConfig\":{\"direction\":\"column\",\"position\":\"bottom\",\"sortDataKeys\":false,\"showMin\":false,\"showMax\":false,\"showAvg\":true,\"showTotal\":false,\"showLatest\":false},\"customLegendEnabled\":false,\"showSubtitle\":true,\"subtitle\":\"${entityName}\",\"subtitleFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"subtitleColor\":\"rgba(0, 0, 0, 0.38)\",\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"dateColor\":\"rgba(0, 0, 0, 0.38)\",\"showChart\":true,\"chartColor\":\"rgba(0, 0, 0, 0.87)\",\"background\":{\"type\":\"image\",\"imageBase64\":\"data:image/png;base64,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\",\"imageUrl\":null,\"color\":\"#fff\",\"overlay\":{\"enabled\":true,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Leaf wetness\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"mdi:leaf\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"24px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":false,\"displayTimewindow\":true,\"decimals\":0,\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"24px\",\"icon\":null,\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":false},\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "leaf", + "wetness" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/leaf_wetness_progress_bar.json b/application/src/main/data/json/system/widget_types/leaf_wetness_progress_bar.json new file mode 100644 index 0000000000..7193fd4568 --- /dev/null +++ b/application/src/main/data/json/system/widget_types/leaf_wetness_progress_bar.json @@ -0,0 +1,30 @@ +{ + "fqn": "leaf_wetness_progress_bar", + "name": "Leaf wetness progress bar", + "deprecated": false, + "image": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAMgAAACgCAMAAAB+IdObAAAAn1BMVEXg4ODf39/g4ODg4OAAAAD////19fXg4OAhISFLcN3j4+M9PT2srKxYWFh0dHTx8fGQkJDo7fsvLy/Hx8e6urqCgoKenp7v7++7yfKGhob09v2Opup4k+WXl5fS2/fV1dX39/dhguG5ubmpqanH0vVsiuPLy8tmZmZKSkre5PewwPClt+6aruzCwsJWed/c3Nx+fn6Dnejm5ubU1NSxsbH6cLmjAAAABXRSTlPvIL+vAC9A4IoAAAQySURBVHja7M/BEQBABAPAOIynp/47vTbCZDtYhD3Udm4Bw+R6DYN3HjAPlSfgSqQUIaMIG0XYKMJGETaKsFGEjSKf3TJYdRyGoehKcLFk2cixt4Fskv//wpHShkzn8TpvFQKvFxor1ln4oNb0bvmI3C2/XiQlulfeiCxSvtXIQKNb5Y0II33XUqzyZiSj0n9zD5GMmd6EQT/J9SKpquz10rsQlcrogyJjxOvsnerA3J1z2lAbSS1DpQS1aJ9ibV2HY1RGbFwvMhkY7C8bmJEpMcD5OZpCE/RRCOBkmaM9fIcNyDtkrkbeNy/dmrEx9HKRwi4x0I8TN38cjgMLKYwo/A6OGBRMpWQOihdl8yI+DStNwWTMV4vs5yfjx63bIX+JzOjEG1pDjfPt3CESjLr2FoUgZiQl7u0FOVFJ5WqRikeIhgF4ESHLDc36QDu4LyKGPZVmBrJ4qzulia4WGVglQoI1UX0VUVMm3VYLYQ1s+ioikXn/tTNGDFZW8OUTacj+LHGqxR+vIgJTJ2w9uX9FMtq+X1R8cWioQx3tOpFePYkyVKp1Gtik4lWkwO2KxebBRVHbKdLAQxQzsUnr0JhsmxjpOpE9jZICyOn53UbfRU6qPK+gkxNATxFaGLDh/Rx9x6sBJnSJyGtKKs/1p1ysZ1I6+8fGmc/f+I/IH/bnkApgGAigGBoYrIH5lzlUejjt+3EQWRFNEU0RTRFNEU0RTRFNEU0RTRFNEU0RTRFNEU0RTRFNEU0RzRhZ2+ObIuvdDphMke+WyM9+HaxaCEJRGB6tYA2diW7kCDpII+j9X+5ysrhwB96a7ciPHqAf3aWJrHbnoF4vpJAznqIXspB4jF7IxhXOPGBb/RciXIVktGhUJ/VCIg8FXz6L4pHphfiYg5sruToAQRA2GIFOLaTLtyUJHrPAJ+h0ISSRHoCLaVmsh1IXQkwLganFiNp/fCckeT8fJ5UFjbehKt1bnRBL1mNGLHYmm2izhUadELeSxblCRoNdNLYi6RyTS6ffhF2psMv30ah/sRKSlACcXNyiznnvhgAuhD/vrfXs9Y47+5OMEG1GiDYjRJsRos0I0WaEaPOCECNs8jwpcj8k8ySTIp/bIfw1aXI7RHjKkyL3V8RkNqJpRj4v/mo9zAjRZoT8tHfHqg0DMQCGz0l+Z2s9HBEaBAaDt8Mm9vs/W2uo14KznOLoh9v1cYNGeSsg3voHUjrLVK4vAyBmJvtAhyGigk1UrdVVgaEwGpP2MstxyPKAXP1LZIOo0M6UFYbxOGQc3EC+2F7OAfECUYGZ8iJE5pbHQs12iE0sxmSgz+MQsnZG1XbIU20TrF2XeQFC3+Ml+Rvoszf7exUQbwXEWwHxVkC8FRBvBcRbAfFWQLwVEG8FxFsngiRO0T1dTnB6Gr6vqUknOD4tv4xbc72/e+nS3H4AH4urRIckSugAAAAASUVORK5CYII=", + "description": "Displays leaf wetness reading as a horizontal progress bar. Allows to configure value range, bar colors, and other settings.", + "descriptor": { + "type": "latest", + "sizeX": 3, + "sizeY": 2, + "resources": [], + "templateHtml": "\n", + "templateCss": "", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.progressBarWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.progressBarWidget.onDataUpdated();\n};\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '280px',\n previewHeight: '180px',\n embedTitlePanel: true,\n defaultDataKeysFunction: function() {\n return [{ name: 'leaf', label: 'Leaf wetness', type: 'timeseries' }];\n }\n };\n};\n\n\nself.onDestroy = function() {\n};\n", + "settingsSchema": "", + "dataKeySettingsSchema": "", + "settingsDirective": "tb-progress-bar-widget-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-progress-bar-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"function\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"humidity\",\"color\":\"#2196f3\",\"settings\":{},\"_hash\":0.2392660816082064,\"funcBody\":\"var value = prevValue + Math.random() * 7;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]}}],\"timewindow\":{\"realtime\":{\"timewindowMs\":60000}},\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"padding\":\"0px\",\"settings\":{\"layout\":\"default\",\"autoScale\":true,\"showValue\":true,\"valueFont\":{\"family\":\"Roboto\",\"size\":24,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\",\"lineHeight\":\"32px\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":0,\"to\":10,\"color\":\"#4B70DD\"},{\"from\":10,\"to\":50,\"color\":\"#FFA600\"},{\"from\":50,\"to\":90,\"color\":\"#F36900\"},{\"from\":90,\"to\":null,\"color\":\"#D81838\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"tickMin\":0,\"tickMax\":100,\"showTicks\":true,\"ticksFont\":{\"family\":\"Roboto\",\"size\":11,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"ticksColor\":\"rgba(0,0,0,0.54)\",\"background\":{\"type\":\"color\",\"color\":\"#fff\",\"overlay\":{\"enabled\":false,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"barColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\",\"rangeList\":[{\"from\":0,\"to\":10,\"color\":\"#4B70DD\"},{\"from\":10,\"to\":50,\"color\":\"#FFA600\"},{\"from\":50,\"to\":90,\"color\":\"#F36900\"},{\"from\":90,\"to\":null,\"color\":\"#D81838\"}]},\"barBackground\":\"rgba(0, 0, 0, 0.04)\"},\"title\":\"Leaf wetness\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"units\":\"%\",\"decimals\":0,\"useDashboardTimewindow\":true,\"showLegend\":false,\"widgetStyle\":{},\"actions\":{},\"configMode\":\"basic\",\"displayTimewindow\":true,\"margin\":\"0px\",\"borderRadius\":\"0px\",\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"showTitleIcon\":false,\"titleTooltip\":\"\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"titleIcon\":\"mdi:leaf\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"iconSize\":\"18px\",\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"14px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1\"},\"color\":null},\"titleColor\":\"rgba(0, 0, 0, 0.87)\"}" + }, + "externalId": null, + "tags": [ + "progress", + "weather", + "environment", + "leaf", + "wetness" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/leaf_wetness_progress_bar_with_background.json b/application/src/main/data/json/system/widget_types/leaf_wetness_progress_bar_with_background.json new file mode 100644 index 0000000000..8e04636f0c --- /dev/null +++ b/application/src/main/data/json/system/widget_types/leaf_wetness_progress_bar_with_background.json @@ -0,0 +1,30 @@ +{ + "fqn": "leaf_wetness_progress_bar_with_background", + "name": "Leaf wetness progress bar with background", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays leaf wetness reading as a horizontal progress bar with background. Allows to configure value range, bar colors, and other settings.", + "descriptor": { + "type": "latest", + "sizeX": 3, + "sizeY": 2, + "resources": [], + "templateHtml": "\n", + "templateCss": "", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.progressBarWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.progressBarWidget.onDataUpdated();\n};\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '280px',\n previewHeight: '180px',\n embedTitlePanel: true,\n defaultDataKeysFunction: function() {\n return [{ name: 'leaf', label: 'Leaf wetness', type: 'timeseries' }];\n }\n };\n};\n\n\nself.onDestroy = function() {\n};\n", + "settingsSchema": "", + "dataKeySettingsSchema": "", + "settingsDirective": "tb-progress-bar-widget-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-progress-bar-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"function\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"humidity\",\"color\":\"#2196f3\",\"settings\":{},\"_hash\":0.2392660816082064,\"funcBody\":\"var value = prevValue + Math.random() * 7;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]}}],\"timewindow\":{\"realtime\":{\"timewindowMs\":60000}},\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"padding\":\"0px\",\"settings\":{\"layout\":\"default\",\"autoScale\":true,\"showValue\":true,\"valueFont\":{\"family\":\"Roboto\",\"size\":24,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\",\"lineHeight\":\"32px\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":0,\"to\":10,\"color\":\"#4369DD\"},{\"from\":10,\"to\":50,\"color\":\"#F89E0D\"},{\"from\":50,\"to\":90,\"color\":\"#F77410\"},{\"from\":90,\"to\":null,\"color\":\"#DE2343\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"tickMin\":0,\"tickMax\":100,\"showTicks\":true,\"ticksFont\":{\"family\":\"Roboto\",\"size\":11,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"ticksColor\":\"rgba(0,0,0,0.54)\",\"background\":{\"type\":\"image\",\"imageBase64\":\"data:image/png;base64,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\",\"imageUrl\":null,\"color\":\"#fff\",\"overlay\":{\"enabled\":true,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"barColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\",\"rangeList\":[{\"from\":0,\"to\":10,\"color\":\"#4369DD\"},{\"from\":10,\"to\":50,\"color\":\"#F89E0D\"},{\"from\":50,\"to\":90,\"color\":\"#F77410\"},{\"from\":90,\"to\":null,\"color\":\"#DE2343\"}]},\"barBackground\":\"rgba(0, 0, 0, 0.04)\"},\"title\":\"Leaf wetness\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"units\":\"%\",\"decimals\":0,\"useDashboardTimewindow\":true,\"showLegend\":false,\"widgetStyle\":{},\"actions\":{},\"configMode\":\"basic\",\"displayTimewindow\":true,\"margin\":\"0px\",\"borderRadius\":\"0px\",\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"showTitleIcon\":false,\"titleTooltip\":\"\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"titleIcon\":\"mdi:leaf\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"iconSize\":\"18px\",\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"14px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1\"},\"color\":null},\"titleColor\":\"rgba(0, 0, 0, 0.87)\"}" + }, + "externalId": null, + "tags": [ + "progress", + "weather", + "environment", + "leaf", + "wetness" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/simple_leaf_wetness_chart_card.json b/application/src/main/data/json/system/widget_types/simple_leaf_wetness_chart_card.json new file mode 100644 index 0000000000..9dc2ce8fe3 --- /dev/null +++ b/application/src/main/data/json/system/widget_types/simple_leaf_wetness_chart_card.json @@ -0,0 +1,32 @@ +{ + "fqn": "simple_leaf_wetness_chart_card", + "name": "Simple leaf wetness chart card", + "deprecated": false, + "image": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAMgAAACgCAMAAAB+IdObAAAAllBMVEUAAADf39/g4ODf39/f39/g4OD////k5OQhISHg4ODi4uJLcN2QkJDy8vLHx8c9PT1YWFgvLy90dHQ8PDysrKxhguHV1dVKSkqCgoLo7furq6u6urr19/2enp5mZma7yfK5ubl4lOWdnZ3S2/alt+6ar+yOpepWed/H0vSwwPBti+OOpuqDnefd5PmwwfAtLS3FxcWcnJygPPf3AAAABnRSTlMAIL9AEN/GQiaNAAAEwUlEQVR42uzPyw2AIBQAsMdHDCRs4P5zmjiBRyDtBg0AAAAAAID/atpc/Rolj3tz4yoRaTxte3OUyLMdYObo7QhdZDEiqxF52a23VTthKArDd4PBZM4cNCSiKOILtH3/l6u69truU2lLi0TwR0QzycVHLrS2bkht3ZDauiG1dUNq698gOaOW/hQydPjcxIJa+iXk+w9dM7ykHp8S9vgqKn7fSZAcuDd/hDhNBsioA6xj47alEVgErt+nAmUYTPOoAtioad+l8rLr6AyIRD5KHyAamzZAYtMw2cRpgw40oWKa9qlHw9IL90eUtmk7pNhN0cSvu0YcnQAp/Bpi7JHpJAGlgdA9Fl2KAbHfpkYH6j4aKOu1KqwpMM2OGek4kjMgmWuTJ+neQxyj90ym6/0VgjCGJTpKfkyfEEdReu8puY0hAQ3LaHh2BsSRHD3X8ntIZhIRS1EQDogWWpgK5DF9A1mYRQRirqMzkT52eHYGREjtuNbigLg1tCW7ybqYnT8gjgELGyCUnCdDbOwFYrETpwiTZc5LFAsBr50AQWjtG9cUzxa/FiCFUbd72U7EO+yVHuZnQAJjByibbZS9YG4ZR0jZ1zsyCI5OgMg8kKzoc/e3kKM+8pviQt0/jbV1Q2rrhtTWDamtG1JbN+T/Z9k5uzzENHArpGtDXGRYZjdrSy8XhiiLw6O+jfmykIGN4Zm0US4KEd++e43hohCl4G09x0tCfrJvd7uNwkAYhs8+jTw2mIADBlJCEshv9/4vb5fSirAJC2wqQSWeO3gzmLEiIWiFNu2pnxiyIoG2NUU/MKQZSEOS8/NCmoE0lK9nH+JspEzU/UAkHm1pM++QwKWKK+9evQJPaE9NHqKk9sjTgcCDiPRWAc7q6yLiuB17XFA0dUjikY5kFJKbPJ5hiVrsk5Yy0uQ3Hf3n/fWQ1GKo+OvaJHyK0bK7Ow4iDok8vVPooHxXvR6SmVpRZ9yYzQmDCAoVair0RPvqEWIEh3SrZB0EiRgbcuBaicqVi7M5poC16PPmi8dLU3Osx9g1N3qVrDyquIEYFXLjfF+xqFwMkHEGGNM/kLjrOdckMM7WJx04Yr2pXh5RIIQTa6K3ZERIzgc0TF6H/OJs3HZTviuaqA3GEju/nkPk4JNY+eSuxNCQC5/RqB6rA5+sKcdeN9aeG6AiNEn8j7UTbAVatm9EOhkWwnwo8luG2pnNlQ2uxo6+bojq95ORJq9nHmMnFQ4KSbl2SfEhy01pMz6jh3JX+FusPaJQKnwvNSzkwsVpX/L9SUmNQZ+AHEyieyGm9ZE/3r+RrS2uhcU/uBoT6N/sGbPFJ8sHezxe2KToJCnBYFOFGJMWfMKeD+gSU4RJdIeUbD73e4patUJyBiyX6BBRqDCJ7pAT8xmwhnPUPlbIjVO8d4UELkUTdPRvds7zY/Nk2dxWAyrei+fL3QlJO5hAX0ha8h9mj5aC+elAHE3+RBn9hz2tb4xt73v7PCPG5JqQkZoMT87hA8AXQ+RMMl4OiWaSMYc/6JaQJWTelpC5WULmZgmZmyVkbpaQ3+3cMQ0AIAwAwUDDUg341wkSGEtz5+ANfDVCqmkU0ma5E9mgZOe4W6r1/5ZqRqdRGAAAAAAAwJMDbJv6K5dRMTYAAAAASUVORK5CYII=", + "description": "Displays historical leaf wetness values as a simplified chart. Optionally may display the corresponding latest leaf wetness value.", + "descriptor": { + "type": "timeseries", + "sizeX": 4.5, + "sizeY": 2, + "resources": [], + "templateHtml": "\n\n", + "templateCss": ".legend {\n font-size: 13px;\n line-height: 10px;\n}\n\n.legend table { \n border-spacing: 0px;\n border-collapse: separate;\n}\n\n.mouse-events .flot-overlay {\n cursor: crosshair; \n}\n\n", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueChartCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueChartCardWidget.onDataUpdated();\n};\n\nself.onLatestDataUpdated = function() {\n self.ctx.$scope.valueChartCardWidget.onLatestDataUpdated();\n}\n\nself.onEditModeChanged = function() {\n self.ctx.$scope.valueChartCardWidget.onEditModeChanged();\n}\n\nself.onDestroy = function() {\n self.ctx.$scope.valueChartCardWidget.onDestroy();\n}\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '300px',\n previewHeight: '150px',\n embedTitlePanel: true,\n hasAdditionalLatestDataKeys: true,\n defaultDataKeysFunction: function() {\n return [\n { name: 'leaf', label: 'Leaf wetness', type: 'timeseries', color: 'rgba(0, 0, 0, 0.87)'}\n ];\n },\n defaultLatestDataKeysFunction: function(configComponent) {\n return [{ name: 'leaf', label: 'Latest', type: 'timeseries'}];\n }\n };\n}\n", + "settingsSchema": "{}", + "dataKeySettingsSchema": "{}", + "latestDataKeySettingsSchema": "{}", + "settingsDirective": "tb-value-chart-card-widget-settings", + "dataKeySettingsDirective": "", + "latestDataKeySettingsDirective": "", + "hasBasicMode": true, + "basicModeDirective": "tb-value-chart-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Leaf wetness\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 7;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 7;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"layout\":\"left\",\"autoScale\":true,\"showValue\":true,\"valueFont\":{\"family\":\"Roboto\",\"size\":28,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\",\"lineHeight\":\"32px\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":0,\"to\":10,\"color\":\"#4B70DD\"},{\"from\":10,\"to\":50,\"color\":\"#FFA600\"},{\"from\":50,\"to\":90,\"color\":\"#F36900\"},{\"from\":90,\"to\":null,\"color\":\"#D81838\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"color\",\"color\":\"#fff\",\"overlay\":{\"enabled\":false,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}}},\"title\":\"Leaf wetness\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":null,\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"mdi:leaf\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"18px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":true,\"decimals\":0,\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null,\"units\":\"%\",\"displayTimewindow\":true,\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1697382151041,\"endTimeMs\":1697468551041},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"timewindowStyle\":{\"showIcon\":false,\"iconSize\":\"24px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":true}}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "leaf", + "wetness" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/simple_leaf_wetness_chart_card_with_background.json b/application/src/main/data/json/system/widget_types/simple_leaf_wetness_chart_card_with_background.json new file mode 100644 index 0000000000..9a2fc593e0 --- /dev/null +++ b/application/src/main/data/json/system/widget_types/simple_leaf_wetness_chart_card_with_background.json @@ -0,0 +1,32 @@ +{ + "fqn": "simple_leaf_wetness_chart_card_with_background", + "name": "Simple leaf wetness chart card with background", + "deprecated": false, + "image": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAMgAAACgCAMAAAB+IdObAAADAFBMVEUAAAAhLgEOEAhTbiA7UA58kFcbJQcXGgwYHQ1ScwBUcwAYLADHxsbFxsLP08LLzcLJy8LJycLQ1cLMz8PHyMLn7NvO0cLHx8fT18LR0sLl7M3u89/O0MPT1MLo7tjU2sINEADp7tvt89nr8NskNAHX38Lm7NUZFhcQEgAeHxsnNgLt89zT18UiMQAfKwDl7cnO0sQcJQHW3MMUEhPr8N7v9dvm7Nns8tXV2cUdKADm7c/R1cTo79Xm7sbv9OHU2Mnk7cQbGBns8d7X28fP08Tc4dHh6sTl7NPi6s3q8czMy8LZ3cjR1MfZ4cLMzcTb48MTEBEgLgDw9d8pOgIYHgHq8Njh6cvk6djo79Hk6tDW28sXFRYaIgHn7s3t89Df58ft8eDc4czm69ra38vo78k3TQTa3tDh5tDNz8U2NzHY3c3Jycbf480LDgAjKwPl6dTh5tTp7t1Dad3f58ocHBklLwTd48fP0cZdegkTFQEtPQLe5sNXdQVMYSU2SAPf49MrKygxRwLq8dDV08ZjfRU9UAg0Pxjk6M1qfksWGQHx9uO5va1ecz9ATh1hggna4cXS08TLy8ZPbgXt9NVqgxw6SBlnhRPr8shmeUYoJyUWExTSzsQxQgNTZjAvPAtqbGB2ilfT08s2SA8rQQFHWCNpjAg6VQLM07cuNBkkJxhDYgNRbCIqKQdGaQPX2M51eGxvglNvjxeanoufopWEh3tGSEFYaTmPkYJacDM9XgJGXRc9UBVtiNZ+kl8/VhDOzspSdNq7wMiZqm+Nn2ZfYFhtiCUiIgXFyre0uqF1lxOjsXmhtGiFl2WAk1AtMApecAZ0jCpRXQGCl9K/wrKAhHVTVUxcZAdAQDmjtYOFnFdpizZ6jzJQWTGBniRQUUddeit3lyaOollagSNvhkdiezlTdx2wvYRYedqmrZSaqc2bslt3jkeqrqA+OxuRotCst8qxxJmkp5mPpHilsM1/nkOKqju0yGWsv2W/0Z/Dw4ZWUR3A0m17eV3HzZIlIyDM4YP7HxgfAAAADHRSTlMAICAfIB+/QN+/QECoNnDuAAAhrUlEQVR42uzBgQAAAACAoP2pF6kCAAAAmJ2yV3kbhsJw+kNb6E1k0BAEEnj0ZQhl9Oqx3jzEFIMGBzJkKWRzPVgfGUq6FtpAxowpvZ3Soc9R3C/9oEMvIC+WZJ8k8nn0npO77rrrrrvuuuuu/9eLZ+jlVdP6QoZMz/7odvePCN/8O/ac8U89f5xvC29Ms+j5f+vJti8SxttXzmjf9GXXle1xjO1x248Pp+7h45ft9tj13mtdD0orZZT3SummabQiSoSLsM0HY5R2uXNVXdsst9a62nJfMYmqqspEy6JgZuS1tXlurDWGXYxvmhi6T9/HzXz+bj6fL2RhTDcLltV5w8wlY7E6Hw4H2djmKHvzejZ7Zp1T2vdtCUd72rYh9FrHstyfjmPgofeDviZNsoNpNAhMiqAnJlIsO2OYbSWZs7ura2UhqhhEJpCiWBYMYbEJN+ftTstpRB/D1/fd5gqyYLmJZ3Jf/P28OR8u9aWu8uu+y9cz/FCACEnZhrLsfd+QYhT5EGLTt2EQAxCWCNMWiF4cIa7c4MywdpyLgdWRXcYxZcbZzOIKBDavEkqOHemlS3CyOockZ0oHyYmsh7789v7neTGd+lOUKUZQVrA2WHLdVLYrXs2ccYBwyH1oA/LNOA4eOOR322MfhW4AQT38+qLUsFbekfLYeIVIwDhn8UIM0diDASZLhjtbOcmVWksg3MCyRIUo5zNkFZ7oVLNlt//QLR9r6t27Kw12IG6YE4loVRwul0udZ7IbNDPSkOKQLmlQ0M1xOw5qoJ6UHo9jH8tvp7bEkrx5GKV+VOT8nDd+9MpPzSIAa+WSrNUXK6fNRDitlYVFnKKuBCTBVILimK1lI0hiCPvP3XkyAxBWRqJYrVjkRi552GSQSM0mDkBEqU04c2HSIZSN2gmND2X0Ou73Xdu2uokxkD7lLG+Nhk9ofijIQrqdXQblNGaSe1WTH6etHAA80vYIEN57LpIrMFkjNUnxOdnHUOBh/+PHITHclLjoEYHDHa4NILQJJGwpFTs5oiR/rVmsM9IfykXM0MbDYQQnQBL2p6Dodywg2PP1UVrF7fidlIcz2FE7s3bKSiFJF2SWsssFDCUSYcmWk1J5ceGiazQgI38ynz5cSP0JiAgCwo+Vlkiktmh3ruVMqWtlsOCMBQsum/sYjgOd44k2Ica27cdT16j0V6WVeOfhESO9gLCH3jL4rRvWu92QbJeackySLX1ur92Z+lMupkwo+Qj3+LHbxTKc9j+G1Q3gBoINU6sjymu1TI4gceQ3IXb3mlQYxwHcP6BWrYwxZWE26SkDibGVyoTmcPRK1ExH0SqWOzLKWGwUTE/QC3ES6yIoqKQXOr2MBF+SCoJAchR1s0k30k0QXayLLoOCvr/fedQsat+WebY2/fj9Pc85bs9pLIfdvFCwkGu5+uLFi3v3kslqNXmVkpyamko+T3KuJqtXq1dlcJTEf+GPavXpzWuf3r17+/Pnd+Tzm+KP6legzjfn6wPkPN3wnUauUu49f/788dnkg4cLZ//F6ffTaJglJsz56dNrNmDBJXNLa1lCWS5Dd1wuv8u1EndWyrgofr/H6RuKHu1PxPYdNttsHR2OQDgcCDg6bAiOwuHg+ERq48ZNTsTj8WynTE6Oju5Eli6TWfr749JDtLS2trhGdy5bsfj/+fbg2PTrGgRjc/o0Jn3z+dmljSzhSAhLyMEQNvmBIIZzU1/0UH9iHxwn+Kk7AgGCkAQHx8MRQDoh6duE+IzAIjF4pGVLmyBS0tLqskK6kGT26zQq4ZhGsEnFbwCCPpokHDAo3ASrYNhuxEmKviNHDlEdh20nTpywkaMOMXfjKByhSlKpbfVEhxCf73a9Geb8LfGjkoU7yeJShXet/aY9d3ERAsfm2WaItMhQFzUGXtMhpG/bNigOjUVix6mPri7qICAhSDdDwgPjkFCOTByq50g0OvQEmts1TROFe4fEurBkdu80hgvb1l7TOtqrKL8bmmup/WxmYE1Ejx7tP0QZG4uA4eg227oQewPCEhyEDQhnfHxsfAzfgSQSif7+/qNHo09Yg0EjzJLflydLeJ38n3Jx//T0Md61kuff7+YzwO8FNEw1iFUqhqL9/YlELBaLIMePOxzdWA0nurYMb9nSBYh0OLwdXAccA8FxZIJugsGBCxfC4eMU/IAEwhoaNAPDj9yQYLwWWigXcVpEJ4A8rVaNq9vly3fSgjCG6rdmpIMV2KAIsY/iAKIbawFtbDFi7/A6yOGl8FhxgkEYyEEH2NQcHMlhTFRiyFJ/SEhovBaQ4GQCCUGmnlaTuMq6cwuviWsUGm6geWZHJ8FgBSO6KR2EsNvtpBgeHpYQbyAQ8koIOTiSQ5D2djfaopCljuE5G6LtbJRfTFkKS/47XoBguKgS07Pnz1/E43fuPd2+3e8HxtqQMGMnMVjRH6OzBQIGrwJy2MlhoQAy6PWGpAMkdztXEKCwih2AdhgSmUYxkrKzIUEpC4zXKUiOvZ8G5NGjZ3Hk3s3tHP+klV4TTnMZzMAmyxsrAkq5TJBhQCgECTFkEIHJ3d5ODqwYWjAMcbsD3gYEQGkhzBg2M0mBhWIsFD+X8k8Ihgunxb2A3B+h3HcigKBMKzZaRoxOTkrFtwwmymzuoths3cZzKImCDRBW9EoIAggnRBI8cUSqBvhYSjB8coczLJEIJES5TRQpsdJ4+f+ze12kSmgPNj16RpD4/WfyKsLf4lq50mrNzWWQZb4nUOCMl1fAsEGB5YDdiSUrRa6DCiEGYlk/OMgOkWdHTyh0gAuQEJbUYQ2IDEMgaVD+2L0MyaJFi5ohcJzCZfC06f5I/Ny5c/GR+20UjweXOS0t84WTnJxc3915xWwjh5bPJYa7PMX8vONIRqQ1+5ZhLWuxZId6tdz61Vo+q4fyojI/li8X8/oBd2dxLotnPZOf091uvTj3ZcDthtXh5Wnj/dmgBIxCUttIAgqvek59oVwxSnnVDNl7ERTauUxnzsRHAImPtBrxtHo82nVmCJFFGbj+OAwInS268mpaqQz71HRa5I6URGkefcyLmE/ke0ul9fRVZTAtCrk2QXcPtH9Q0krGm1UzJbVTV/BdRXQUcuMGkdtzmBMJjk3wlQxTWAKKHC8XSeR4/XUeMYbrtWkkDgT93kFC4HB+YAWShYK3KTQCSELkepcKzZfrshfSHS0ChVh6Y0LLqRWLmouI3OCY0FaL/Oo2MRP6InR8BLLqRLrgTs3NzggtmP0CBA9Z42QZ5IxPwJHq7DQk2/o2OS/ztiPHy+WanORS/l7skEADCAoZIUkLQg6nc4YUFQU3Ghg2Wx2iCVVRRC6Wx23a3io0FNLbW8lWsqom2srGV2uQGaHPCQWf0WcV9WN2IJgWH4qd0hGUZ8qDtcABBq6TN5KlDxfLTo/furxeSl3yB4XeX5Fkr+kcO7BMWiioY1PfPAhFcoiy2Yz91mw+DAgmqyxyPp8zllPb7JW0vQ0QWub5gohUSoWeNpHDKosAMighRTGr63pIT81kxEynrmPGiNEe5KCOgxO76tnBDhmCOC/7Xc0SGq8/SsE7RTBotKamXr4AgyF+1NG37VBZiLkMORQzQYzR0pBhpVDWSomMWtaU9Hqn0Mhh0URldVGke3oqhXK5FFmtpidaDcgONaPPzLk/llKz4ktR1Td+/BgOow/pwDjtSqV2UHbhLztW4Q/9AwhJGp0QhU7zW5tLwdtehuw1Xbo0de/ly5fnRlo9zKD3Fx+VqEqQvJkDSFFBKhZfQah5e1tBFCppyyZFI4dlfSE3OKHM9/S0VYSaWd2TF+lWZSY0q+gHvihCLbbrBXw+GMRr81EfQBp9kGSHDDeyqhZ0y5KVoLAEpYDyl2QtgrUOyC8+7OUlyiiM4/j8BRUtgrIGnFmFCzdNszGIosA2gTAlQWoXiGnVYogiopCCblSUVC6EFkJQgWaZXbDFvN3QGVIqc5KooZDoshDsQqu+z3OeOUdnol/NKLOaj8/znHPe099/4kzvIyoiz0nbeNxjuV3y7Zs4BtXAi9TXMw96DkkmM4lEokE3D90+GhIJ2TbSfCq/p9OdnZ2trel0urVz+/ZlmsbGxi0b29s5bhHeJQwIDkoiAoHgCAoCZcX5pcvnSggrwNz20osiJCdjw1cL/b3Hybb1e3ft2LBnny5Ut4/ypxeHJc4Wbo4M4Rubo6VOJEQUDamUQkhaIhBzrN24EYlbonTJBbKfGEQCxDtYdZSyYoVICJAgWURRPAQJFCD9w1ce9tJbKI7skc0PBwGhED2ux+M4SEMyE4/PdZxqkd6CAqIOVKoBiAVIs5PgEMghJGQLDoOI49y/HUaxmmiChKIYRS8eRRIbPnPibm8vtz2cRHT3EwcrlUXPh9ZY4miKN2WSwUFaWpDwSYsEiEkokZaEuIoAQdIeIL6zIGhMgcPiShIkTLw8zs8tijJEErv66czd3p6eM5ExVMIhl/1D3lcjYUJWdcg4UI+mJiDBoZK6VKoOByQkqYQPkFYCZfcagziJjchmHDrjDjHPoZsaAYIEikFwiMRNChYuUV1i927c6DncU5z+udU5eAei4WxFaRh3cZCOpEgyGdpMEM4BxIXfHIWYg7QyL83Nu3c3NjIjxElIe/shIDgUEhhEHcQsJvEVMcrCTULxF4+x+9fvP7hX/jH6pQaCo4OXHLI6FFLHqMOgswIkSCqglEYgF2VMBEJEIgbDwDhkjFAQRVg9QnAoRYPDPqW/hKJ38wZ5UPr1e3aqDEQc8yGER3IcCuGBFoVNSDXEOwyC4iJJt3mJ7R7KqHHUFmQJCZL5kMVK4b6IctiM3P86+uHWjy/5PApiw+4lGnNY2EKQaKoZKR8EQCRtbUDI9sZluokYwxw26fMhCwxSK7FPQssd9MM++mvs7NlLl57ktwYIUQ0Qn3UEAAgpCRFNbS0sCQAWKtLW3EZJkMjxhJKIIxTEIM+ezzx/VgUhAlm89Px5L1mwlA9YBQiU7zcP2rD/Gn17ISoVR/JbJTB85EmqYliVJCIRiMU8KYlTJOgoY9BSFiuISLarpFKRyg4ijmt97lFucMhD+MrOgQSKxEmAIMEhGf/z/amDlItRVCyXozzjQbSx3PlKJYqQG+kMY86wwEhYkDhWqAO5aPEOimEQJFCQkP0SKA7yOZsbvDMwM9CXzWVPVyD6qkhWmEQgRBzah+PjE1AOAilFxagwXBwbQREgOIg+FeKIa4AQHEHiClTLIIERILubhcKYEL1/pL1E0pd789nmfSjb/Q2IIXx0PyEGAUYcxCixj09Kn8Zmo8lJKhLOJ7IRqoRBqRdIk0HM4SEMTahHoGhrdc4vyGUgzVDc8iWD3+6WroHc42t+3Tqd7T7tR4Q3v6GYhFeQGGQCSizKF4vl0uTkiFt6V5vDhe4iSEh9pSApF+0st5hVS9ISKwgQEJLLxC1fZBnZggTKy2z2ml+3kHQPUhJPCRAnqYXgePFiIhaV8lFhcqRY2CnhuxvDJK67BMPlKFfVrpFYoxSChHA8AeMloggSB4EBRKPbPOEEpseWQ69yL6W/HIQM5YaQ4PgfBIlSJnAI5EWsVIzyhULh7SgATUDY0sXEr5JVi58y7Aaxdcuf5lvqaiXmMImPSfQkCSX7WvorSBYPZqtKggMIOV8jwYFCIO8LH0ei4aj8owoS1uAOAgUHqVSEGU8Sq4p1mNoqks509aIVIGs0a/VwP5B7ToN5CZCZ3CsrhEGCpBYiFem5NzYV+1h4/7YcTU5/2VlxSH/hAME/3UwCxX1RvjGODHESxYQdxpfEHNVFwWEQkWTfUBWZend21JJ0PzOIOWwHrKJIa41PvJ8am3r37l2sUPg6OzsyPToNxCh+a68nQMxB5KyVIOZo0iOkXcf71Er0CAzEKKEgZGDlwEYSioJkJtfnm0sY/AdimQ/p6jp24Nixrqmuv5zb709bVRgH8P4BrOgwgKabUYOmCcnIXhFnomRODdP6arpJ9oJoHJUlmmvDmlgjkSaaVDtsarNKTGeyBo2ZjDLWxNTYshKg07AUCCqC+AsGKqjoNjN/fZ/nnNOnFyY6v7RdIcvoZ89z7j2959Tx5dAQ6rEwNASIREE4ArnNFjhwCRcSvbIggVUgL5JjPyAH4eCQQyTTXnoEpbwoKImcTFgiEJHAUTseiQYpUcfQB2cXCkPfDZ3dCCGEBMVRgluNZDsg2/kpJELh9lOWFyn7VQ7iDPLEE6N9ib5ULymUZNSdUpXhouBUTxIuiZYwhKZX20QijsZxPxTDUX/QUfjkbGHh4/lf5zc4bhEHigEHR0qiTvj4gaao1R6C2CXGgffuF3CVyYv7pClJnRcFEQm9ZWQKlWSrDHc1K5FoByB+fywQiwQCEUcBU63Cd78sF9Y7eHiIYd92hCXaAwiHf6IoOM0gh0Lp06dDsIiDILjGOOmeG31ox46JBC5w7SBI3bT7wj2oDUMQzMEeZkkIJYHERFfAHkBuvvnkyfHIyQgkjk9//XJhofBRwQ7hVyjZXso+HXr129Fb/PdkJgbQ6U43xXuaIOIAJOXu0xeH0m5vYrT3wmRnZwoMSknynJLk46GtiEhwu4pjZ2B8PBjwBwJ+x1ChMFQYwo2OV3RuN+G1csldvOhML5yXaVAi+hk/R3jYUw5PuadCh1EVrC4cvksaC+ntnGMHpTdBWBTmHoGwBP3FY34knq/VEClJt93RiKurkUAEDj8gXy4UCoVz5859+ihPtp625/6naTEJX/er3G7Cq4B6MRoOAjFkCmsLuBKJZ2n31H6C0HLIQcqgtxcOQ6kbTY3W7UCDCUQkPCNOK0l1SdLNYUVXV1d9YyPeAIyPB/z+aDiMipzjLF96phTam3Do6jlw6ABFM/k5URiCdts34E7vM0m7U1wMDZl0pzDghUIBxFDsEhRlOp5iCSjIQCI/mJ8M9fQoEUNIEo2e70fm+x3nlpcvXvzrypUrexBa736y9cnWx03UzpG7P2xVOVyKhj3LWxlQGF0kr5dXdFWm5qindEV63YmDGmI0yvNPkolpXz7EECiwhOb14mEw1UMWgnQxJBIMhv3hWH+/48qlS0Mf/56Ym35P5TFkbVGl2LgbOZKxrMVVPNnLESKHTbpGt+OscDv6jJtv//6UGwtUJpir04DHAjXd8bSsNDYJIHrGksAL70tPJry++NRPI3jxoTTeQaZdPa6eHobs3rkzEENb+WPhmOMdt1sttL2l8iCyYqkUd1GKVnElm22rr6+p4Sv2IEkAg8mUKOGlhkPLqcx1YlTceeAAXnzCPapF+AkguAsFYYlQdFHytAgYH5wcUd2EaqSnm7yJkKenpxu9RZBAEJQwIL4mlTs+5LRhcb0tY2VWKTmnE6vVi9nq6iVryenMZmlhrh6LVmVpJIziYIUoYeu9EW9n6iVqvt4596RhAGIiErFIe+kzCtpLjYoegjQ3D+SbmvKhNpKgt3DMilBBYo4mHzOamtrb21/jeDwZq9jGVygbqpFspqoKkOoV3J33Psjr8Vj71dEcbsK0b6JscEEzMuf25if75rDcQ3Uxo0MgKlejyDQSi+b1XZQegiChfNN0MyQECQRx6A2iJA6fkdTU1MDCnEVrpQ1xNSDVrmx2S1XRWssBVE3bGClOWQMuA3mnidNIKjOYBtAdnXOTtYcOvYTcdOCmcox90D9BEQtJmEKrcOUO7IIMTTQ3u7p3AQJHMOYPRwHxqYIQxFgwOoqZzBJ2cEDiWrGyGStblcnmqrSEz1MCMaiffGmsl9XW44ExzNGDCAFF5QEjKakOUsrnxkI5ehT/NdrRzA6VZteN2wChaXw4Fk6itZp0SaDQlpylslhDEpdrKZPN5JasFXQbJM5SGIIvswiQj4/IGg0sKtCYVuMYDg4G4mCISISCi19YrLY5NMRTva2WIDEce5PJpILcIRAkt2gVl9YyqAv1F91drhuyWbXdlC/SUBSFHao6IV9eKViCsEP6TM5EvG5lq06ZRI8WM4nswKq7OK6XVLpuxG/w49h7fmZ+dgwQpEVBhEIthn7yQIE7UrRyuWKmSN2F4JECyb3kQPDY5wvZIZxSkz1FFsXpoMCjNWXnSJP7HmEFwvXotpUDyyJUEoYMB1GT4ejMvAPV8FFBDESCs0lOH8baclYxl80uWhj3sqCndlPBwZKULwHARsnNjWLZawtQeuhIzGaIDlIcRTUamSEKcly/BRJAMP2N0mCPRWNRQIDA3QapqMBQIUg7BZZstgIHrqpVqyh7mmnAAOJUSce9I0q0DoLfpi2soQdpObJAo9JxuKOjtaP16NHWvSAAsZu2P3T3uHQ1BIJoyHgAk8ZgdHhYtRZJhIGeqkCKgFRUMAWnkNcylseTszIKgi+zL9vZgLPNSN43HdIkA5FAQiEBB4c2PmArjERZmUqGbZjrYnh6jEIk+MLxdxf+4aAfCYajqAhKwnetQC2WLGuloiKXtTL4BqIanEJoyGx5bdXKeHRJKnV/cSbj8T4eM7aalNeGXnWJYQ7ZhLm76+6u+i6V7q5uCdalSVG5jsHfUGdVGkiUJEFVEeou4+CSWJlMlgpCDpgyOSpQcbVoLXk4tGlTBcuUA9O+wRCqwxGIhCGcWiiQ0jJOwxETlz48Suh/qxk3gTSrqOdV1Vt1a4WDM7EYQ9RgF0kuYyHZNRgkkMAn8xiPpkzkfd6BSia5WKJi9+ySbMXOPlr1V/FQeFerRPZRN+O7Zglc3A2goLOc2wDBu9zhIILWotgGO9dgbQ1FWJdV/KydwxxVlz501YR8SENZShy7BAc4jChGlL32st7nlL69DjfEINSGFJeicEEAiUT8mPoGo3TU4rTYIJtFLMiAF12l97mJhKMhpg6EQCX0C7EJbtDZojeYiIYw1xGC62b+dfV7nHAQJBLAqX34vEPVA7E7/psm0eQdUJvzpSQu7n2ncQjDrtBHH4lWCMXE9JqGINTETowQuvhwMhKgw+88Q5BrhHAA6ZtoN7/MoxkNDXyexNySGTzrx1kT1WCGOJiyiQQUpSnb3I6oaqOvwGBIBI0V7Udr6TCCvq4p0PB/3nUYMvSmTM/z6yUMMQO8UkOEYpfom8RURSjMUOWo21kXiGC4B0tjpAU3qcg1hweMh/ZtY/+5zmMInwB5gzdJGlwk2ZwisVsMhyXsAIPC1+eCfj78sgSDnRH/S0IOvE3GO371+nfj4Sl8/gBbkXezCkCSNOjmsmNE8u8kkujRobbdhXExHhPgYNCB2UkTOQC5JsQW/qLUwMEMXIPBy38S23b34lM/fHEJn6gyEqawxWCEUsbZXAYJD3NicJIYH7DwpFH1VkvF/xgjojAMvH7M1clBG9le2MMSoai62DBisYVNV4WUHA8jyVj/eQSHX1IwhBHsgOgaBodRAAEFlQEOQGg3upGIhUfLEcYIRWm0xwbbCEFnobHYwZB+ZHhmZhgQxECUYRPHFvNAXrsCBGZgbBgIJHseF4lQsBsZGCmLLZtJ8L7QaQoikPn5mRkDaWmZMINk07EiDBkYokDIwRIFeQHDhKI10mJHZLwoyjqRTNnXdxYNdAOpY8gYJA4YmlgyUKNjWmszDTuYIQopiC6JQGwSQEBBWKItm5RmXWfVaghLLo8l+8dmxyAhiCqKdwICRCqyuYMZpFCfKhSJcqjeEohY6neBYiSISJCNEqSssxhShzCkbhYKTj8gprk6v5d5479CjAMMhqwbI3hUn/Tbw5Cn8CCQB42kwUgqJRshyD9A/phNjs1CkkyOoSImLW+0/NlpT7wzHqc/1qdzMPHbxYvLy8c/wgapD7AB5MfLly9//PUHx08dp7x8/NTLp06dev7db7/9Cnn35WPfDH/2xbFjr3zx1WfHzvz8ydl3nz9z5sybb554/sSJz08g/NnyV/FBcPxJnwZ/9e3XT7yKj4j/wHdb3v8WJ43+aCyIy1nJcDJJEkDmZ/9m53xanAYCKL7ifz+HFwMNBE8e/QaWetNrDl72FpDQKRSsjJDtIawSpSml1iAZivESpinNQamgu5W9iG1cCdumIhZBinoS8c3EUtSDX6Av03Sbw+78ePNCd7vzthBzQEg9eHDtIs7QxbWuYORaPV9++2T/097k69dRQClmfTRbjsfPkpQFgeM41KEWTpYVdrxer9vt2nFISLc8J6FLCMpW9hesG5Odw87hjh63+zgajaZp3g3vqkpeH1FU1IJZun77sagOUK8ahtjFL7YkYOi+/OgTqtfBIUiA8l5mJOfADfiiRFhxiHmvUCTECuMHPt+aDAYt+tuBxOHpFEqDFg1cxwktYGBYbV2ieCEQGHFdAedGPd/vRjt6tXNI9hOv3e737wIFBS8No6T0+wWwGM3Pqolai6uqqB1pGtvYjXAHNDj0ng8Q/MGhfHNF8lSgfNvKDQGGZLgGGhxi7utDnnJduHGYvRsJjGDwfDCwCMmA4nbt+TSxaCCcoPCEBo5rOaHugcPXSchdyCJc0IDNj6Oe7XViH1/VZB1LtWF6PipZ9IpposvELGkVQ1HUZvM6PDmvvrgqpOGh+75vd/Fr4c1bWF33wCFX2MtvcGSli4AQFLkN0NqTXNfuvxnMUmb7jM5GMxiyPx7v8wyJcNg8ozx0LKwrCkuwyChMIcISr2+53OLcYiwirBvhUq0fL8e8WuvaUU3HZjUdhThokkF7hAmQvlIwa7JGY9s0t3dQfYIiDBCpmqFd8mAo1is+qNo9GAKlXgdI/VH9pQCRQc8BJIj0Y6WVGQ8u33CO9o6WsyxJMW3EnIYM/3m3mActOGA5GKFluVHEqSNfU0oj3fOqHc4Z4yljjEBRhGh3omfP0hoqfbCZqI3RqFUr7Waj2W4qJeI0CgrKGwyjqMKU8wDZ1rZL2uumqmlNHX76ANkdvjsY7g4Bcq9+E/483TqFG1YedGCsp5/D5FBgefDzcHH06ej58ovQZM5adPSc83mSTKfWzKEDEXI4AZtmzIVH4JpRi3t63CFAcGMuciLkRrhb+WXb9hH0EBh69WFFr7YrZlX4oeheFbU4ovVGNUS1igE/NK14HV1E2vVCyfOhrn0LIHirOERYyiIyZ7dOIx5Swg+Q5DSrcOR2AGO0932CUHwExocxQByaJKnF7Ppw6rSok2Q0dBGS5fjLhwXLKM2SaZZxTiIixVnIA5e41IlquNTxsDx6lSjuVatIiNgI2UA4MM4ryAlC3wZJUbkkim40WQ31WisCRDvvYWkCZI43ihKkDBIMNFOdPiNvvRBArvzBARKBcR8Ye4sWEt5avno2mqXz+ZzjbrWgAZsmM1xtWYG1HJDASSeTr/V6yhlnqQiJRZByDjcQdzuOeLZYeDEhcYy82u2a7ke6DDv2b9MW/KigYAkcZojTTqFodJqXVGSkqKm4gYmvFK8nYmLb04Pd4cHurbKQffZcXhT2n06u4yeFcJZPueSr9dUT4spxvPxXJ3Bg5MLzuoUM5WA4yQeKwvBNjuFHrXvIjuOEx986IZXPYTWXrY022mijjTbaaKONfrUHBwIAAAAAgvytVxigAgAAALYAPifEuSqUT70AAAAASUVORK5CYII=", + "description": "Displays historical leaf wetness values as a simplified chart with background. Optionally may display the corresponding latest leaf wetness value.", + "descriptor": { + "type": "timeseries", + "sizeX": 4.5, + "sizeY": 2, + "resources": [], + "templateHtml": "\n\n", + "templateCss": ".legend {\n font-size: 13px;\n line-height: 10px;\n}\n\n.legend table { \n border-spacing: 0px;\n border-collapse: separate;\n}\n\n.mouse-events .flot-overlay {\n cursor: crosshair; \n}\n\n", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueChartCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueChartCardWidget.onDataUpdated();\n};\n\nself.onLatestDataUpdated = function() {\n self.ctx.$scope.valueChartCardWidget.onLatestDataUpdated();\n}\n\nself.onEditModeChanged = function() {\n self.ctx.$scope.valueChartCardWidget.onEditModeChanged();\n}\n\nself.onDestroy = function() {\n self.ctx.$scope.valueChartCardWidget.onDestroy();\n}\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '300px',\n previewHeight: '150px',\n embedTitlePanel: true,\n hasAdditionalLatestDataKeys: true,\n defaultDataKeysFunction: function() {\n return [\n { name: 'leaf', label: 'Leaf wetness', type: 'timeseries', color: 'rgba(0, 0, 0, 0.87)'}\n ];\n },\n defaultLatestDataKeysFunction: function(configComponent) {\n return [{ name: 'leaf', label: 'Latest', type: 'timeseries'}];\n }\n };\n}\n", + "settingsSchema": "{}", + "dataKeySettingsSchema": "{}", + "latestDataKeySettingsSchema": "{}", + "settingsDirective": "tb-value-chart-card-widget-settings", + "dataKeySettingsDirective": "", + "latestDataKeySettingsDirective": "", + "hasBasicMode": true, + "basicModeDirective": "tb-value-chart-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Leaf wetness\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 7;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 7;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"layout\":\"left\",\"autoScale\":true,\"showValue\":true,\"valueFont\":{\"family\":\"Roboto\",\"size\":28,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\",\"lineHeight\":\"32px\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":0,\"to\":10,\"color\":\"#4369DD\"},{\"from\":10,\"to\":50,\"color\":\"#F89E0D\"},{\"from\":50,\"to\":90,\"color\":\"#F77410\"},{\"from\":90,\"to\":null,\"color\":\"#DE2343\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"image\",\"imageBase64\":\"data:image/png;base64,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\",\"imageUrl\":null,\"color\":\"#fff\",\"overlay\":{\"enabled\":true,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}}},\"title\":\"Leaf wetness\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":null,\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"mdi:leaf\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"18px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":true,\"decimals\":0,\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null,\"units\":\"%\",\"displayTimewindow\":true,\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1697382151041,\"endTimeMs\":1697468551041},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"timewindowStyle\":{\"showIcon\":false,\"iconSize\":\"24px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":true}}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "leaf", + "wetness" + ] +} \ No newline at end of file From 5a9f352f60d788f7cea60d1440846077c893dbf2 Mon Sep 17 00:00:00 2001 From: Igor Kulikov Date: Wed, 25 Oct 2023 15:54:05 +0300 Subject: [PATCH 38/43] UI: Outdoor Environment: Snow depth widgets. --- .../widget_bundles/outdoor_environment.json | 10 +++++- .../horizontal_snow_depth_card.json | 28 +++++++++++++++++ ...ontal_snow_depth_card_with_background.json | 28 +++++++++++++++++ .../simple_snow_depth_chart_card.json | 31 +++++++++++++++++++ ...snow_depth_chart_card_with_background.json | 31 +++++++++++++++++++ .../system/widget_types/snow_depth_card.json | 28 +++++++++++++++++ .../snow_depth_card_with_background.json | 28 +++++++++++++++++ .../widget_types/snow_depth_chart_card.json | 31 +++++++++++++++++++ ...snow_depth_chart_card_with_background.json | 31 +++++++++++++++++++ 9 files changed, 245 insertions(+), 1 deletion(-) create mode 100644 application/src/main/data/json/system/widget_types/horizontal_snow_depth_card.json create mode 100644 application/src/main/data/json/system/widget_types/horizontal_snow_depth_card_with_background.json create mode 100644 application/src/main/data/json/system/widget_types/simple_snow_depth_chart_card.json create mode 100644 application/src/main/data/json/system/widget_types/simple_snow_depth_chart_card_with_background.json create mode 100644 application/src/main/data/json/system/widget_types/snow_depth_card.json create mode 100644 application/src/main/data/json/system/widget_types/snow_depth_card_with_background.json create mode 100644 application/src/main/data/json/system/widget_types/snow_depth_chart_card.json create mode 100644 application/src/main/data/json/system/widget_types/snow_depth_chart_card_with_background.json diff --git a/application/src/main/data/json/system/widget_bundles/outdoor_environment.json b/application/src/main/data/json/system/widget_bundles/outdoor_environment.json index f66977a66a..2d6c8b4247 100644 --- a/application/src/main/data/json/system/widget_bundles/outdoor_environment.json +++ b/application/src/main/data/json/system/widget_bundles/outdoor_environment.json @@ -129,6 +129,14 @@ "simple_leaf_wetness_chart_card", "simple_leaf_wetness_chart_card_with_background", "leaf_wetness_progress_bar", - "leaf_wetness_progress_bar_with_background" + "leaf_wetness_progress_bar_with_background", + "snow_depth_card", + "snow_depth_card_with_background", + "horizontal_snow_depth_card", + "horizontal_snow_depth_card_with_background", + "snow_depth_chart_card", + "snow_depth_chart_card_with_background", + "simple_snow_depth_chart_card", + "simple_snow_depth_chart_card_with_background" ] } \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/horizontal_snow_depth_card.json b/application/src/main/data/json/system/widget_types/horizontal_snow_depth_card.json new file mode 100644 index 0000000000..690a99c3f0 --- /dev/null +++ b/application/src/main/data/json/system/widget_types/horizontal_snow_depth_card.json @@ -0,0 +1,28 @@ +{ + "fqn": "horizontal_snow_depth_card", + "name": "Horizontal snow depth card", + "deprecated": false, + "image": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAMgAAACgCAMAAAB+IdObAAAAxlBMVEUAAADf39/f39/g4ODg4ODf39/////k5OQwWtfg4OCXrOsjTMfl6/qxwfDx8fFKb9zOzs5+mObz8/O7u7tYWFjy9f3k6fjj4+PIyMisrKw+Ys48PDz5+fnL1vXb29vV1dVaedXCwsKQkJA9ZNkwV8u2trZkg+Hn5+eKoul2j9zY4Pe+zPPW3fWCgoKkt+51j9x0dHSRpuMvLy9wjuRXed9mZmbt7e1KSkr39/dMbdGenp7I0vG6x+2fsebJyclLS0udnZ0hISFSqBZZAAAABnRSTlMAIEDfv1C6kOEmAAADuklEQVR42u3aeXOaQBjHcdukT1ZuOQKogIBXtRrrEdv0fv9vqvuANU7GsZVOMsT5fSZRZP1jv1k2OqMNAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJf05tVrsLdXN6+df/VOdtx8olfPvnnbuLbpAny6bjTpIjQRUjMIqRuE1A1C6gYhdXMkxCO6U4luac94yHw6YvZ41qcgpAqeMeS2/ZFDPvS/0R/uQ/CDDMMgeVP8kE987Pp/HhmdJOTYSqa6RlI0V6Ye7UWKMq0ewt6rH+/UD/327WNI5vu0XHQSZ+s+OLPANbZE/naz9DO3E2TbzcJZzkJ341IVuhA6ESlCMjUqaevioVc55PaWS/pq0fGVSkbYyahDi9BNqGO4M9eZEclf1++Es0UW0pI6fshPqUAzi5BI5NFkLIZUWomWNlmLceWQz+2iRC3vvlBhQXKiHLKRIeRuwk5AFHLI0gn8/wwZC5NDFNEi8oQgiQ9yvuaESTvedKrxneZ5ER9N9Oh0SHlJ9dSi4yOVsh/ugjgkcN2Mspnxi5dp6y79n52Nk7mubFpUDJmI8ZBD5mJ8GKJPeZvsF2ieCyHGRa4pj/SVvFmfDClL7tSDDmY8PWBGeZOF5X01pqkVIV6e69qYJ/uoxQNlbT6fmkLhjaRwhanLtOmJkLter622e32191nt93q9D/R3TkDVKUInDuHJSkM6MN9fWSt+hiYfKmJVrJvGl6RyImQoQ2RBm0PUIuR5abwzOIT3fEsxDyc3yXONSrmY8JO1cieREMWfQKlwaT0XOXNdX4vWlFrFHsmFt2/k2e/wErBTIac3+zPTxI5JQxHRbnEYr5D+2Hs85Ox/vzYdYd8/PWHT2SK2FuMJrYp5mZyjlR3K4a5XuHr9JOTsF8RBGWPTfUyFbpe6TYtPNKlLRKNwRN04LgfkifOShuULotwjQ2HyHm9xUd5i0W67lBvoSci5b1E4JEms+Pt3Sx6llMap0x2kVpIElnNvOV0ia2Q7Tky2VQxYgXN2COkm/9fSdq8oYkenQiQH8zmdFeIdvGk8DBnYgTWyypBREstjeW4UW2lQhDTjWIYEziiwZW5q0/k0zSPmHR+s+jbeo73QilNrkASpzStiOXE6sAeBJc/dy4lbxCFdXpGRE/JAkqb00jjkbPHoxGASxPQv6hDS7Z4atOlf1CKkjhBSNwipG4TUDULqptm4voCP2Ynsa/mFgQv4oP2T/MJA492Vf/PaXb29pC/VAAAAAAAAAAAAAAAAAAAAAAAAAAAAALyQ32C4FBab7K0VAAAAAElFTkSuQmCC", + "description": "Displays a latest snow depth telemetry data in a horizontal layout.", + "descriptor": { + "type": "latest", + "sizeX": 5, + "sizeY": 1, + "resources": [], + "templateHtml": "\n", + "templateCss": "", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueCardWidget.onDataUpdated();\n};\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n horizontal: true,\n previewWidth: '420px',\n previewHeight: '90px',\n embedTitlePanel: true,\n defaultDataKeysFunction: function() {\n return [{ name: 'snow', label: 'Snow depth', type: 'timeseries' }];\n }\n };\n};\n\nself.onDestroy = function() {\n};\n", + "settingsSchema": "", + "dataKeySettingsSchema": "", + "settingsDirective": "tb-value-card-widget-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"function\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Snow depth\",\"color\":\"#2196f3\",\"settings\":{},\"_hash\":0.2392660816082064,\"funcBody\":\"var value = prevValue + Math.random() * 20 - 10;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 120) {\\n\\tvalue = 120;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]}}],\"timewindow\":{\"realtime\":{\"timewindowMs\":60000}},\"showTitle\":false,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"padding\":\"0px\",\"settings\":{\"labelPosition\":\"top\",\"layout\":\"horizontal\",\"showLabel\":true,\"labelFont\":{\"family\":\"Roboto\",\"size\":16,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"labelColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showIcon\":true,\"iconSize\":40,\"iconSizeUnit\":\"px\",\"icon\":\"ac_unit\",\"iconColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":0,\"to\":1,\"color\":\"#7191EF\"},{\"from\":1,\"to\":10,\"color\":\"#4B70DD\"},{\"from\":10,\"to\":30,\"color\":\"#305AD7\"},{\"from\":30,\"to\":60,\"color\":\"#234CC7\"},{\"from\":60,\"to\":90,\"color\":\"#F36900\"},{\"from\":90,\"to\":null,\"color\":\"#D81838\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"valueFont\":{\"size\":36,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\",\"rangeList\":[{\"from\":0,\"to\":1,\"color\":\"#7191EF\"},{\"from\":1,\"to\":10,\"color\":\"#4B70DD\"},{\"from\":10,\"to\":30,\"color\":\"#305AD7\"},{\"from\":30,\"to\":60,\"color\":\"#234CC7\"},{\"from\":60,\"to\":90,\"color\":\"#F36900\"},{\"from\":90,\"to\":null,\"color\":\"#D81838\"}]},\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"dateColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"color\",\"color\":\"#fff\",\"overlay\":{\"enabled\":false,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Horizontal snow depth card\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"units\":\"cm\",\"decimals\":1,\"useDashboardTimewindow\":true,\"showLegend\":false,\"widgetStyle\":{},\"actions\":{},\"configMode\":\"basic\",\"displayTimewindow\":true,\"margin\":\"0px\",\"borderRadius\":\"0px\",\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"showTitleIcon\":false,\"titleTooltip\":\"\",\"titleFont\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1.6\"},\"titleIcon\":\"\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"iconSize\":\"14px\",\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"14px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1\"},\"color\":null}}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "snow" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/horizontal_snow_depth_card_with_background.json b/application/src/main/data/json/system/widget_types/horizontal_snow_depth_card_with_background.json new file mode 100644 index 0000000000..76fcd31a5e --- /dev/null +++ b/application/src/main/data/json/system/widget_types/horizontal_snow_depth_card_with_background.json @@ -0,0 +1,28 @@ +{ + "fqn": "horizontal_snow_depth_card_with_background", + "name": "Horizontal snow depth card with background", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays a latest snow depth telemetry data in a horizontal layout with background.", + "descriptor": { + "type": "latest", + "sizeX": 5, + "sizeY": 1, + "resources": [], + "templateHtml": "\n", + "templateCss": "", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueCardWidget.onDataUpdated();\n};\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n horizontal: true,\n previewWidth: '420px',\n previewHeight: '90px',\n embedTitlePanel: true,\n defaultDataKeysFunction: function() {\n return [{ name: 'snow', label: 'Snow depth', type: 'timeseries' }];\n }\n };\n};\n\nself.onDestroy = function() {\n};\n", + "settingsSchema": "", + "dataKeySettingsSchema": "", + "settingsDirective": "tb-value-card-widget-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"function\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Snow depth\",\"color\":\"#2196f3\",\"settings\":{},\"_hash\":0.2392660816082064,\"funcBody\":\"var value = prevValue + Math.random() * 20 - 10;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 120) {\\n\\tvalue = 120;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]}}],\"timewindow\":{\"realtime\":{\"timewindowMs\":60000}},\"showTitle\":false,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"padding\":\"0px\",\"settings\":{\"labelPosition\":\"top\",\"layout\":\"horizontal\",\"showLabel\":true,\"labelFont\":{\"family\":\"Roboto\",\"size\":16,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"labelColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showIcon\":true,\"iconSize\":40,\"iconSizeUnit\":\"px\",\"icon\":\"ac_unit\",\"iconColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":0,\"to\":1,\"color\":\"#6083EC\"},{\"from\":1,\"to\":10,\"color\":\"#4369DD\"},{\"from\":10,\"to\":30,\"color\":\"#2B54CE\"},{\"from\":30,\"to\":60,\"color\":\"#224AC2\"},{\"from\":60,\"to\":90,\"color\":\"#F77410\"},{\"from\":90,\"to\":null,\"color\":\"#DE2343\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"valueFont\":{\"size\":36,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\",\"rangeList\":[{\"from\":0,\"to\":1,\"color\":\"#6083EC\"},{\"from\":1,\"to\":10,\"color\":\"#4369DD\"},{\"from\":10,\"to\":30,\"color\":\"#2B54CE\"},{\"from\":30,\"to\":60,\"color\":\"#224AC2\"},{\"from\":60,\"to\":90,\"color\":\"#F77410\"},{\"from\":90,\"to\":null,\"color\":\"#DE2343\"}]},\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"dateColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"image\",\"imageBase64\":\"data:image/png;base64,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\",\"imageUrl\":null,\"color\":\"#fff\",\"overlay\":{\"enabled\":true,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Horizontal snow depth card\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"units\":\"cm\",\"decimals\":1,\"useDashboardTimewindow\":true,\"showLegend\":false,\"widgetStyle\":{},\"actions\":{},\"configMode\":\"basic\",\"displayTimewindow\":true,\"margin\":\"0px\",\"borderRadius\":\"0px\",\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"showTitleIcon\":false,\"titleTooltip\":\"\",\"titleFont\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1.6\"},\"titleIcon\":\"\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"iconSize\":\"14px\",\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"14px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1\"},\"color\":null}}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "snow" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/simple_snow_depth_chart_card.json b/application/src/main/data/json/system/widget_types/simple_snow_depth_chart_card.json new file mode 100644 index 0000000000..664cb5fe86 --- /dev/null +++ b/application/src/main/data/json/system/widget_types/simple_snow_depth_chart_card.json @@ -0,0 +1,31 @@ +{ + "fqn": "simple_snow_depth_chart_card", + "name": "Simple snow depth chart card", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays historical snow depth values as a simplified chart. Optionally may display the corresponding latest snow depth value.", + "descriptor": { + "type": "timeseries", + "sizeX": 4.5, + "sizeY": 2, + "resources": [], + "templateHtml": "\n\n", + "templateCss": ".legend {\n font-size: 13px;\n line-height: 10px;\n}\n\n.legend table { \n border-spacing: 0px;\n border-collapse: separate;\n}\n\n.mouse-events .flot-overlay {\n cursor: crosshair; \n}\n\n", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueChartCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueChartCardWidget.onDataUpdated();\n};\n\nself.onLatestDataUpdated = function() {\n self.ctx.$scope.valueChartCardWidget.onLatestDataUpdated();\n}\n\nself.onEditModeChanged = function() {\n self.ctx.$scope.valueChartCardWidget.onEditModeChanged();\n}\n\nself.onDestroy = function() {\n self.ctx.$scope.valueChartCardWidget.onDestroy();\n}\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '300px',\n previewHeight: '150px',\n embedTitlePanel: true,\n hasAdditionalLatestDataKeys: true,\n defaultDataKeysFunction: function() {\n return [\n { name: 'snow', label: 'Snow depth', type: 'timeseries', color: 'rgba(0, 0, 0, 0.87)'}\n ];\n },\n defaultLatestDataKeysFunction: function(configComponent) {\n return [{ name: 'snow', label: 'Latest', type: 'timeseries'}];\n }\n };\n}\n", + "settingsSchema": "{}", + "dataKeySettingsSchema": "{}", + "latestDataKeySettingsSchema": "{}", + "settingsDirective": "tb-value-chart-card-widget-settings", + "dataKeySettingsDirective": "", + "latestDataKeySettingsDirective": "", + "hasBasicMode": true, + "basicModeDirective": "tb-value-chart-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Snow depth\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 20 - 10;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 120) {\\n\\tvalue = 120;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 20 - 10;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 120) {\\n\\tvalue = 120;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"layout\":\"left\",\"autoScale\":true,\"showValue\":true,\"valueFont\":{\"family\":\"Roboto\",\"size\":28,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\",\"lineHeight\":\"32px\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":0,\"to\":1,\"color\":\"#7191EF\"},{\"from\":1,\"to\":10,\"color\":\"#4B70DD\"},{\"from\":10,\"to\":30,\"color\":\"#305AD7\"},{\"from\":30,\"to\":60,\"color\":\"#234CC7\"},{\"from\":60,\"to\":90,\"color\":\"#F36900\"},{\"from\":90,\"to\":null,\"color\":\"#D81838\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"color\",\"color\":\"#fff\",\"overlay\":{\"enabled\":false,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}}},\"title\":\"Snow depth\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":null,\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"ac_unit\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"18px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":true,\"decimals\":1,\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null,\"units\":\"cm\",\"displayTimewindow\":true,\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1697382151041,\"endTimeMs\":1697468551041},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"timewindowStyle\":{\"showIcon\":false,\"iconSize\":\"24px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":true}}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "snow" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/simple_snow_depth_chart_card_with_background.json b/application/src/main/data/json/system/widget_types/simple_snow_depth_chart_card_with_background.json new file mode 100644 index 0000000000..f12e8d75a9 --- /dev/null +++ b/application/src/main/data/json/system/widget_types/simple_snow_depth_chart_card_with_background.json @@ -0,0 +1,31 @@ +{ + "fqn": "simple_snow_depth_chart_card_with_background", + "name": "Simple snow depth chart card with background", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays historical snow depth values as a simplified chart with background. Optionally may display the corresponding latest snow depth value.", + "descriptor": { + "type": "timeseries", + "sizeX": 4.5, + "sizeY": 2, + "resources": [], + "templateHtml": "\n\n", + "templateCss": ".legend {\n font-size: 13px;\n line-height: 10px;\n}\n\n.legend table { \n border-spacing: 0px;\n border-collapse: separate;\n}\n\n.mouse-events .flot-overlay {\n cursor: crosshair; \n}\n\n", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueChartCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueChartCardWidget.onDataUpdated();\n};\n\nself.onLatestDataUpdated = function() {\n self.ctx.$scope.valueChartCardWidget.onLatestDataUpdated();\n}\n\nself.onEditModeChanged = function() {\n self.ctx.$scope.valueChartCardWidget.onEditModeChanged();\n}\n\nself.onDestroy = function() {\n self.ctx.$scope.valueChartCardWidget.onDestroy();\n}\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '300px',\n previewHeight: '150px',\n embedTitlePanel: true,\n hasAdditionalLatestDataKeys: true,\n defaultDataKeysFunction: function() {\n return [\n { name: 'snow', label: 'Snow depth', type: 'timeseries', color: 'rgba(0, 0, 0, 0.87)'}\n ];\n },\n defaultLatestDataKeysFunction: function(configComponent) {\n return [{ name: 'snow', label: 'Latest', type: 'timeseries'}];\n }\n };\n}\n", + "settingsSchema": "{}", + "dataKeySettingsSchema": "{}", + "latestDataKeySettingsSchema": "{}", + "settingsDirective": "tb-value-chart-card-widget-settings", + "dataKeySettingsDirective": "", + "latestDataKeySettingsDirective": "", + "hasBasicMode": true, + "basicModeDirective": "tb-value-chart-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Snow depth\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 20 - 10;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 120) {\\n\\tvalue = 120;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 20 - 10;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 120) {\\n\\tvalue = 120;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"layout\":\"left\",\"autoScale\":true,\"showValue\":true,\"valueFont\":{\"family\":\"Roboto\",\"size\":28,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\",\"lineHeight\":\"32px\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":0,\"to\":1,\"color\":\"#6083EC\"},{\"from\":1,\"to\":10,\"color\":\"#4369DD\"},{\"from\":10,\"to\":30,\"color\":\"#2B54CE\"},{\"from\":30,\"to\":60,\"color\":\"#224AC2\"},{\"from\":60,\"to\":90,\"color\":\"#F77410\"},{\"from\":90,\"to\":null,\"color\":\"#DE2343\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"image\",\"imageBase64\":\"data:image/png;base64,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\",\"imageUrl\":null,\"color\":\"#fff\",\"overlay\":{\"enabled\":true,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}}},\"title\":\"Snow depth\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":null,\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"ac_unit\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"18px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":true,\"decimals\":1,\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null,\"units\":\"cm\",\"displayTimewindow\":true,\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1697382151041,\"endTimeMs\":1697468551041},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"timewindowStyle\":{\"showIcon\":false,\"iconSize\":\"24px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":true}}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "snow" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/snow_depth_card.json b/application/src/main/data/json/system/widget_types/snow_depth_card.json new file mode 100644 index 0000000000..af275581c6 --- /dev/null +++ b/application/src/main/data/json/system/widget_types/snow_depth_card.json @@ -0,0 +1,28 @@ +{ + "fqn": "snow_depth_card", + "name": "Snow depth card", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays a latest snow depth telemetry data in a box layout.", + "descriptor": { + "type": "latest", + "sizeX": 3, + "sizeY": 3, + "resources": [], + "templateHtml": "\n", + "templateCss": "", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueCardWidget.onDataUpdated();\n};\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '250px',\n previewHeight: '250px',\n embedTitlePanel: true,\n defaultDataKeysFunction: function() {\n return [{ name: 'snow', label: 'Snow depth', type: 'timeseries' }];\n }\n };\n};\n\nself.onDestroy = function() {\n};\n", + "settingsSchema": "", + "dataKeySettingsSchema": "", + "settingsDirective": "tb-value-card-widget-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"function\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Snow depth\",\"color\":\"#2196f3\",\"settings\":{},\"_hash\":0.2392660816082064,\"funcBody\":\"var value = prevValue + Math.random() * 20 - 10;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 120) {\\n\\tvalue = 120;\\n}\\nreturn value;\\n\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]}}],\"timewindow\":{\"realtime\":{\"timewindowMs\":60000}},\"showTitle\":false,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"padding\":\"0px\",\"settings\":{\"labelPosition\":\"top\",\"layout\":\"square\",\"showLabel\":true,\"labelFont\":{\"family\":\"Roboto\",\"size\":16,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"labelColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showIcon\":true,\"iconSize\":40,\"iconSizeUnit\":\"px\",\"icon\":\"ac_unit\",\"iconColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":0,\"to\":1,\"color\":\"#7191EF\"},{\"from\":1,\"to\":10,\"color\":\"#4B70DD\"},{\"from\":10,\"to\":30,\"color\":\"#305AD7\"},{\"from\":30,\"to\":60,\"color\":\"#234CC7\"},{\"from\":60,\"to\":90,\"color\":\"#F36900\"},{\"from\":90,\"to\":null,\"color\":\"#D81838\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"valueFont\":{\"size\":36,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\",\"rangeList\":[{\"from\":0,\"to\":1,\"color\":\"#7191EF\"},{\"from\":1,\"to\":10,\"color\":\"#4B70DD\"},{\"from\":10,\"to\":30,\"color\":\"#305AD7\"},{\"from\":30,\"to\":60,\"color\":\"#234CC7\"},{\"from\":60,\"to\":90,\"color\":\"#F36900\"},{\"from\":90,\"to\":null,\"color\":\"#D81838\"}]},\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"dateColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"color\",\"color\":\"#fff\",\"overlay\":{\"enabled\":false,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Snow depth card\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"units\":\"cm\",\"decimals\":1,\"useDashboardTimewindow\":true,\"showLegend\":false,\"widgetStyle\":{},\"actions\":{},\"configMode\":\"basic\",\"displayTimewindow\":true,\"margin\":\"0px\",\"borderRadius\":\"0px\",\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"showTitleIcon\":false,\"titleTooltip\":\"\",\"titleFont\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1.6\"},\"titleIcon\":\"\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"iconSize\":\"14px\",\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"14px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1\"},\"color\":null}}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "snow" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/snow_depth_card_with_background.json b/application/src/main/data/json/system/widget_types/snow_depth_card_with_background.json new file mode 100644 index 0000000000..1505e705e7 --- /dev/null +++ b/application/src/main/data/json/system/widget_types/snow_depth_card_with_background.json @@ -0,0 +1,28 @@ +{ + "fqn": "snow_depth_card_with_background", + "name": "Snow depth card with background", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays a latest snow depth telemetry data in a box layout with background.", + "descriptor": { + "type": "latest", + "sizeX": 3, + "sizeY": 3, + "resources": [], + "templateHtml": "\n", + "templateCss": "", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueCardWidget.onDataUpdated();\n};\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '250px',\n previewHeight: '250px',\n embedTitlePanel: true,\n defaultDataKeysFunction: function() {\n return [{ name: 'snow', label: 'Snow depth', type: 'timeseries' }];\n }\n };\n};\n\nself.onDestroy = function() {\n};\n", + "settingsSchema": "", + "dataKeySettingsSchema": "", + "settingsDirective": "tb-value-card-widget-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"function\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Snow depth\",\"color\":\"#2196f3\",\"settings\":{},\"_hash\":0.2392660816082064,\"funcBody\":\"var value = prevValue + Math.random() * 20 - 10;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 120) {\\n\\tvalue = 120;\\n}\\nreturn value;\\n\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]}}],\"timewindow\":{\"realtime\":{\"timewindowMs\":60000}},\"showTitle\":false,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"padding\":\"0px\",\"settings\":{\"labelPosition\":\"top\",\"layout\":\"square\",\"showLabel\":true,\"labelFont\":{\"family\":\"Roboto\",\"size\":16,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"labelColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showIcon\":true,\"iconSize\":40,\"iconSizeUnit\":\"px\",\"icon\":\"ac_unit\",\"iconColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":0,\"to\":1,\"color\":\"#6083EC\"},{\"from\":1,\"to\":10,\"color\":\"#4369DD\"},{\"from\":10,\"to\":30,\"color\":\"#2B54CE\"},{\"from\":30,\"to\":60,\"color\":\"#224AC2\"},{\"from\":60,\"to\":90,\"color\":\"#F77410\"},{\"from\":90,\"to\":null,\"color\":\"#DE2343\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"valueFont\":{\"size\":36,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\",\"rangeList\":[{\"from\":0,\"to\":1,\"color\":\"#6083EC\"},{\"from\":1,\"to\":10,\"color\":\"#4369DD\"},{\"from\":10,\"to\":30,\"color\":\"#2B54CE\"},{\"from\":30,\"to\":60,\"color\":\"#224AC2\"},{\"from\":60,\"to\":90,\"color\":\"#F77410\"},{\"from\":90,\"to\":null,\"color\":\"#DE2343\"}]},\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"dateColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"image\",\"imageBase64\":\"data:image/png;base64,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\",\"imageUrl\":null,\"color\":\"#fff\",\"overlay\":{\"enabled\":true,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Snow depth card\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"units\":\"cm\",\"decimals\":1,\"useDashboardTimewindow\":true,\"showLegend\":false,\"widgetStyle\":{},\"actions\":{},\"configMode\":\"basic\",\"displayTimewindow\":true,\"margin\":\"0px\",\"borderRadius\":\"0px\",\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"showTitleIcon\":false,\"titleTooltip\":\"\",\"titleFont\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1.6\"},\"titleIcon\":\"\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"iconSize\":\"14px\",\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"14px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1\"},\"color\":null}}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "snow" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/snow_depth_chart_card.json b/application/src/main/data/json/system/widget_types/snow_depth_chart_card.json new file mode 100644 index 0000000000..f63e6fd7dc --- /dev/null +++ b/application/src/main/data/json/system/widget_types/snow_depth_chart_card.json @@ -0,0 +1,31 @@ +{ + "fqn": "snow_depth_chart_card", + "name": "Snow depth chart card", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays a snow depth data as a combination of the latest and aggregated values. Optionally may display the corresponding historical values as a simplified chart.", + "descriptor": { + "type": "timeseries", + "sizeX": 4.5, + "sizeY": 3.5, + "resources": [], + "templateHtml": "\n\n", + "templateCss": ".legend {\n font-size: 13px;\n line-height: 10px;\n}\n\n.legend table { \n border-spacing: 0px;\n border-collapse: separate;\n}\n\n.mouse-events .flot-overlay {\n cursor: crosshair; \n}\n\n", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onDataUpdated();\n};\n\nself.onLatestDataUpdated = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onLatestDataUpdated();\n}\n\nself.onResize = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onResize();\n}\n\nself.onEditModeChanged = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onEditModeChanged();\n}\n\nself.onDestroy = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onDestroy();\n}\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '400px',\n previewHeight: '300px',\n embedTitlePanel: true,\n hasAdditionalLatestDataKeys: true,\n defaultDataKeysFunction: function() {\n return [\n { name: 'snow', label: 'Snow depth', type: 'timeseries', color: 'rgba(0, 0, 0, 0.87)', units: 'cm', decimals: 1 }\n ];\n },\n defaultLatestDataKeysFunction: function(configComponent, configData) {\n return configComponent.createDefaultAggregatedValueLatestDataKeys(configData, 'snow', 'cm', 1);\n }\n };\n}\n", + "settingsSchema": "{}", + "dataKeySettingsSchema": "{}", + "latestDataKeySettingsSchema": "{}", + "settingsDirective": "tb-aggregated-value-card-widget-settings", + "dataKeySettingsDirective": "", + "latestDataKeySettingsDirective": "tb-aggregated-value-card-key-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-aggregated-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"Main building\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Snow depth\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{\"showLines\":true,\"fillLines\":true,\"showPoints\":false},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 20 - 10;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 120) {\\n\\tvalue = 120;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"cm\",\"decimals\":1,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"#4caf50\",\"settings\":{\"position\":\"center\",\"font\":{\"size\":52,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"1\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":0,\"to\":1,\"color\":\"#7191EF\"},{\"from\":1,\"to\":10,\"color\":\"#4B70DD\"},{\"from\":10,\"to\":30,\"color\":\"#305AD7\"},{\"from\":30,\"to\":60,\"color\":\"#234CC7\"},{\"from\":60,\"to\":90,\"color\":\"#F36900\"},{\"from\":90,\"to\":null,\"color\":\"#D81838\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.9408410830697858,\"funcBody\":\"var value = prevValue + Math.random() * 20 - 10;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 120) {\\n\\tvalue = 120;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"cm\",\"decimals\":1,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta percent\",\"color\":\"#f44336\",\"settings\":{\"position\":\"rightTop\",\"font\":{\"size\":14,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"20px\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[{\"from\":null,\"to\":0,\"color\":\"#198038\"},{\"from\":0,\"to\":0,\"color\":\"rgba(0, 0, 0, 0.87)\"},{\"from\":0,\"to\":null,\"color\":\"#D12730\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":true},\"_hash\":0.06392321853157967,\"funcBody\":\"var value = prevValue + Math.random() * 6 - 3;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < -25) {\\n\\tvalue = -25;\\n} else if (value > 25) {\\n\\tvalue = 25;\\n} \\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta absolute\",\"color\":\"#607d8b\",\"settings\":{\"position\":\"rightBottom\",\"font\":{\"size\":11,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.44695098620509865,\"funcBody\":\"var value = prevValue + Math.random() * 6 - 3;\\nif (value < -10) {\\n\\tvalue = -10;\\n} else if (value > 10) {\\n\\tvalue = 10;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"cm\",\"decimals\":1,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1691927717318,\"endTimeMs\":1692014117318},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"stack\":false,\"fontSize\":10,\"fontColor\":\"#545454\",\"showTooltip\":true,\"tooltipIndividual\":false,\"tooltipCumulative\":false,\"hideZeros\":false,\"grid\":{\"verticalLines\":true,\"horizontalLines\":true,\"outlineWidth\":1,\"color\":\"#545454\",\"backgroundColor\":null,\"tickColor\":\"#DDDDDD\"},\"xaxis\":{\"title\":null,\"showLabels\":true,\"color\":\"#545454\"},\"yaxis\":{\"min\":null,\"max\":null,\"title\":null,\"showLabels\":true,\"color\":\"#545454\",\"tickSize\":null,\"tickDecimals\":0,\"ticksFormatter\":\"\"},\"shadowSize\":4,\"smoothLines\":false,\"comparisonEnabled\":false,\"xaxisSecond\":{\"axisPosition\":\"top\",\"title\":null,\"showLabels\":true},\"showLegend\":true,\"legendConfig\":{\"direction\":\"column\",\"position\":\"bottom\",\"sortDataKeys\":false,\"showMin\":false,\"showMax\":false,\"showAvg\":true,\"showTotal\":false,\"showLatest\":false},\"customLegendEnabled\":false,\"showSubtitle\":true,\"subtitle\":\"${entityName}\",\"subtitleFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"subtitleColor\":\"rgba(0, 0, 0, 0.38)\",\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"dateColor\":\"rgba(0, 0, 0, 0.38)\",\"showChart\":true,\"chartColor\":\"rgba(0, 0, 0, 0.87)\",\"background\":{\"type\":\"color\",\"color\":\"#fff\",\"overlay\":{\"enabled\":false,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Snow depth\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"ac_unit\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"24px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":false,\"displayTimewindow\":true,\"decimals\":0,\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"24px\",\"icon\":null,\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":false},\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "snow" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/snow_depth_chart_card_with_background.json b/application/src/main/data/json/system/widget_types/snow_depth_chart_card_with_background.json new file mode 100644 index 0000000000..3be7f02c98 --- /dev/null +++ b/application/src/main/data/json/system/widget_types/snow_depth_chart_card_with_background.json @@ -0,0 +1,31 @@ +{ + "fqn": "snow_depth_chart_card_with_background", + "name": "Snow depth chart card with background", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays a snow depth data as a combination of the latest and aggregated values with background. Optionally may display the corresponding historical values as a simplified chart.", + "descriptor": { + "type": "timeseries", + "sizeX": 4.5, + "sizeY": 3.5, + "resources": [], + "templateHtml": "\n\n", + "templateCss": ".legend {\n font-size: 13px;\n line-height: 10px;\n}\n\n.legend table { \n border-spacing: 0px;\n border-collapse: separate;\n}\n\n.mouse-events .flot-overlay {\n cursor: crosshair; \n}\n\n", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onDataUpdated();\n};\n\nself.onLatestDataUpdated = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onLatestDataUpdated();\n}\n\nself.onResize = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onResize();\n}\n\nself.onEditModeChanged = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onEditModeChanged();\n}\n\nself.onDestroy = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onDestroy();\n}\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '400px',\n previewHeight: '300px',\n embedTitlePanel: true,\n hasAdditionalLatestDataKeys: true,\n defaultDataKeysFunction: function() {\n return [\n { name: 'snow', label: 'Snow depth', type: 'timeseries', color: 'rgba(0, 0, 0, 0.87)', units: 'cm', decimals: 1 }\n ];\n },\n defaultLatestDataKeysFunction: function(configComponent, configData) {\n return configComponent.createDefaultAggregatedValueLatestDataKeys(configData, 'snow', 'cm', 1);\n }\n };\n}\n", + "settingsSchema": "{}", + "dataKeySettingsSchema": "{}", + "latestDataKeySettingsSchema": "{}", + "settingsDirective": "tb-aggregated-value-card-widget-settings", + "dataKeySettingsDirective": "", + "latestDataKeySettingsDirective": "tb-aggregated-value-card-key-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-aggregated-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"Main building\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Snow depth\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{\"showLines\":true,\"fillLines\":true,\"showPoints\":false},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 20 - 10;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 120) {\\n\\tvalue = 120;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"cm\",\"decimals\":1,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"#4caf50\",\"settings\":{\"position\":\"center\",\"font\":{\"size\":52,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"1\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":0,\"to\":1,\"color\":\"#6083EC\"},{\"from\":1,\"to\":10,\"color\":\"#4369DD\"},{\"from\":10,\"to\":30,\"color\":\"#2B54CE\"},{\"from\":30,\"to\":60,\"color\":\"#224AC2\"},{\"from\":60,\"to\":90,\"color\":\"#F77410\"},{\"from\":90,\"to\":null,\"color\":\"#DE2343\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.9408410830697858,\"funcBody\":\"var value = prevValue + Math.random() * 20 - 10;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 120) {\\n\\tvalue = 120;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"cm\",\"decimals\":1,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta percent\",\"color\":\"#f44336\",\"settings\":{\"position\":\"rightTop\",\"font\":{\"size\":14,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"20px\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[{\"from\":null,\"to\":0,\"color\":\"#198038\"},{\"from\":0,\"to\":0,\"color\":\"rgba(0, 0, 0, 0.87)\"},{\"from\":0,\"to\":null,\"color\":\"#D12730\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":true},\"_hash\":0.06392321853157967,\"funcBody\":\"var value = prevValue + Math.random() * 6 - 3;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < -25) {\\n\\tvalue = -25;\\n} else if (value > 25) {\\n\\tvalue = 25;\\n} \\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta absolute\",\"color\":\"#607d8b\",\"settings\":{\"position\":\"rightBottom\",\"font\":{\"size\":11,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.44695098620509865,\"funcBody\":\"var value = prevValue + Math.random() * 6 - 3;\\nif (value < -10) {\\n\\tvalue = -10;\\n} else if (value > 10) {\\n\\tvalue = 10;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"cm\",\"decimals\":1,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1691927717318,\"endTimeMs\":1692014117318},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"stack\":false,\"fontSize\":10,\"fontColor\":\"#545454\",\"showTooltip\":true,\"tooltipIndividual\":false,\"tooltipCumulative\":false,\"hideZeros\":false,\"grid\":{\"verticalLines\":true,\"horizontalLines\":true,\"outlineWidth\":1,\"color\":\"#545454\",\"backgroundColor\":null,\"tickColor\":\"#DDDDDD\"},\"xaxis\":{\"title\":null,\"showLabels\":true,\"color\":\"#545454\"},\"yaxis\":{\"min\":null,\"max\":null,\"title\":null,\"showLabels\":true,\"color\":\"#545454\",\"tickSize\":null,\"tickDecimals\":0,\"ticksFormatter\":\"\"},\"shadowSize\":4,\"smoothLines\":false,\"comparisonEnabled\":false,\"xaxisSecond\":{\"axisPosition\":\"top\",\"title\":null,\"showLabels\":true},\"showLegend\":true,\"legendConfig\":{\"direction\":\"column\",\"position\":\"bottom\",\"sortDataKeys\":false,\"showMin\":false,\"showMax\":false,\"showAvg\":true,\"showTotal\":false,\"showLatest\":false},\"customLegendEnabled\":false,\"showSubtitle\":true,\"subtitle\":\"${entityName}\",\"subtitleFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"subtitleColor\":\"rgba(0, 0, 0, 0.38)\",\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"dateColor\":\"rgba(0, 0, 0, 0.38)\",\"showChart\":true,\"chartColor\":\"rgba(0, 0, 0, 0.87)\",\"background\":{\"type\":\"image\",\"imageBase64\":\"data:image/png;base64,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\",\"imageUrl\":null,\"color\":\"#fff\",\"overlay\":{\"enabled\":true,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Snow depth\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"ac_unit\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"24px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":false,\"displayTimewindow\":true,\"decimals\":0,\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"24px\",\"icon\":null,\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":false},\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "snow" + ] +} \ No newline at end of file From ba79b58d9eca439481d04428de886e6fd1813fdf Mon Sep 17 00:00:00 2001 From: Igor Kulikov Date: Wed, 25 Oct 2023 16:38:40 +0300 Subject: [PATCH 39/43] UI: Outdoor Environment: CO2 widgets. --- .../widget_bundles/outdoor_environment.json | 10 +++++- .../json/system/widget_types/co2_card.json | 28 +++++++++++++++++ .../co2_card_with_background.json | 28 +++++++++++++++++ .../system/widget_types/co2_chart_card.json | 31 +++++++++++++++++++ .../co2_chart_card_with_background.json | 31 +++++++++++++++++++ .../widget_types/horizontal_co2_card.json | 28 +++++++++++++++++ .../horizontal_co2_card_with_background.json | 28 +++++++++++++++++ .../widget_types/simple_co2_chart_card.json | 31 +++++++++++++++++++ ...simple_co2_chart_card_with_background.json | 31 +++++++++++++++++++ 9 files changed, 245 insertions(+), 1 deletion(-) create mode 100644 application/src/main/data/json/system/widget_types/co2_card.json create mode 100644 application/src/main/data/json/system/widget_types/co2_card_with_background.json create mode 100644 application/src/main/data/json/system/widget_types/co2_chart_card.json create mode 100644 application/src/main/data/json/system/widget_types/co2_chart_card_with_background.json create mode 100644 application/src/main/data/json/system/widget_types/horizontal_co2_card.json create mode 100644 application/src/main/data/json/system/widget_types/horizontal_co2_card_with_background.json create mode 100644 application/src/main/data/json/system/widget_types/simple_co2_chart_card.json create mode 100644 application/src/main/data/json/system/widget_types/simple_co2_chart_card_with_background.json diff --git a/application/src/main/data/json/system/widget_bundles/outdoor_environment.json b/application/src/main/data/json/system/widget_bundles/outdoor_environment.json index 2d6c8b4247..ed52d20f5e 100644 --- a/application/src/main/data/json/system/widget_bundles/outdoor_environment.json +++ b/application/src/main/data/json/system/widget_bundles/outdoor_environment.json @@ -137,6 +137,14 @@ "snow_depth_chart_card", "snow_depth_chart_card_with_background", "simple_snow_depth_chart_card", - "simple_snow_depth_chart_card_with_background" + "simple_snow_depth_chart_card_with_background", + "co2_card", + "co2_card_with_background", + "horizontal_co2_card", + "horizontal_co2_card_with_background", + "co2_chart_card", + "co2_chart_card_with_background", + "simple_co2_chart_card", + "simple_co2_chart_card_with_background" ] } \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/co2_card.json b/application/src/main/data/json/system/widget_types/co2_card.json new file mode 100644 index 0000000000..908bb82c03 --- /dev/null +++ b/application/src/main/data/json/system/widget_types/co2_card.json @@ -0,0 +1,28 @@ +{ + "fqn": "co2_card", + "name": "CO2 card", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays a latest CO2 level telemetry data in a box layout.", + "descriptor": { + "type": "latest", + "sizeX": 3, + "sizeY": 3, + "resources": [], + "templateHtml": "\n", + "templateCss": "", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueCardWidget.onDataUpdated();\n};\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '250px',\n previewHeight: '250px',\n embedTitlePanel: true,\n defaultDataKeysFunction: function() {\n return [{ name: 'co2', label: 'CO2 level', type: 'timeseries' }];\n }\n };\n};\n\nself.onDestroy = function() {\n};\n", + "settingsSchema": "", + "dataKeySettingsSchema": "", + "settingsDirective": "tb-value-card-widget-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"function\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"CO2 level\",\"color\":\"#2196f3\",\"settings\":{},\"_hash\":0.2392660816082064,\"funcBody\":\"var value = prevValue + Math.random() * 160 - 80;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < 400) {\\n\\tvalue = 400;\\n} else if (value > 1600) {\\n\\tvalue = 1600;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]}}],\"timewindow\":{\"realtime\":{\"timewindowMs\":60000}},\"showTitle\":false,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"padding\":\"0px\",\"settings\":{\"labelPosition\":\"top\",\"layout\":\"square\",\"showLabel\":true,\"labelFont\":{\"family\":\"Roboto\",\"size\":16,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"labelColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showIcon\":true,\"iconSize\":40,\"iconSizeUnit\":\"px\",\"icon\":\"co2\",\"iconColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":600,\"color\":\"#3FA71A\"},{\"from\":600,\"to\":1000,\"color\":\"#80C32C\"},{\"from\":1000,\"to\":1500,\"color\":\"#F36900\"},{\"from\":1500,\"to\":null,\"color\":\"#D81838\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"valueFont\":{\"size\":36,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\",\"rangeList\":[{\"from\":null,\"to\":600,\"color\":\"#3FA71A\"},{\"from\":600,\"to\":1000,\"color\":\"#80C32C\"},{\"from\":1000,\"to\":1500,\"color\":\"#F36900\"},{\"from\":1500,\"to\":null,\"color\":\"#D81838\"}]},\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"dateColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"color\",\"color\":\"#fff\",\"overlay\":{\"enabled\":false,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"CO2 card\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"units\":\"ppm\",\"decimals\":0,\"useDashboardTimewindow\":true,\"showLegend\":false,\"widgetStyle\":{},\"actions\":{},\"configMode\":\"basic\",\"displayTimewindow\":true,\"margin\":\"0px\",\"borderRadius\":\"0px\",\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"showTitleIcon\":false,\"titleTooltip\":\"\",\"titleFont\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1.6\"},\"titleIcon\":\"\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"iconSize\":\"14px\",\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"14px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1\"},\"color\":null}}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "co2" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/co2_card_with_background.json b/application/src/main/data/json/system/widget_types/co2_card_with_background.json new file mode 100644 index 0000000000..f897d0d7a0 --- /dev/null +++ b/application/src/main/data/json/system/widget_types/co2_card_with_background.json @@ -0,0 +1,28 @@ +{ + "fqn": "co2_card_with_background", + "name": "CO2 card with background", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays a latest CO2 level telemetry data in a box layout with background.", + "descriptor": { + "type": "latest", + "sizeX": 3, + "sizeY": 3, + "resources": [], + "templateHtml": "\n", + "templateCss": "", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueCardWidget.onDataUpdated();\n};\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '250px',\n previewHeight: '250px',\n embedTitlePanel: true,\n defaultDataKeysFunction: function() {\n return [{ name: 'co2', label: 'CO2 level', type: 'timeseries' }];\n }\n };\n};\n\nself.onDestroy = function() {\n};\n", + "settingsSchema": "", + "dataKeySettingsSchema": "", + "settingsDirective": "tb-value-card-widget-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"function\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"CO2 level\",\"color\":\"#2196f3\",\"settings\":{},\"_hash\":0.2392660816082064,\"funcBody\":\"var value = prevValue + Math.random() * 160 - 80;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < 400) {\\n\\tvalue = 400;\\n} else if (value > 1600) {\\n\\tvalue = 1600;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]}}],\"timewindow\":{\"realtime\":{\"timewindowMs\":60000}},\"showTitle\":false,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"padding\":\"0px\",\"settings\":{\"labelPosition\":\"top\",\"layout\":\"square\",\"showLabel\":true,\"labelFont\":{\"family\":\"Roboto\",\"size\":16,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"labelColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showIcon\":true,\"iconSize\":40,\"iconSizeUnit\":\"px\",\"icon\":\"co2\",\"iconColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":600,\"color\":\"#3B911C\"},{\"from\":600,\"to\":1000,\"color\":\"#7CC322\"},{\"from\":1000,\"to\":1500,\"color\":\"#F77410\"},{\"from\":1500,\"to\":null,\"color\":\"#DE2343\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"valueFont\":{\"size\":36,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\",\"rangeList\":[{\"from\":null,\"to\":600,\"color\":\"#3B911C\"},{\"from\":600,\"to\":1000,\"color\":\"#7CC322\"},{\"from\":1000,\"to\":1500,\"color\":\"#F77410\"},{\"from\":1500,\"to\":null,\"color\":\"#DE2343\"}]},\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"dateColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"image\",\"imageBase64\":\"data:image/png;base64,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\",\"imageUrl\":null,\"color\":\"#fff\",\"overlay\":{\"enabled\":true,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"CO2 card\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"units\":\"ppm\",\"decimals\":0,\"useDashboardTimewindow\":true,\"showLegend\":false,\"widgetStyle\":{},\"actions\":{},\"configMode\":\"basic\",\"displayTimewindow\":true,\"margin\":\"0px\",\"borderRadius\":\"0px\",\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"showTitleIcon\":false,\"titleTooltip\":\"\",\"titleFont\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1.6\"},\"titleIcon\":\"\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"iconSize\":\"14px\",\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"14px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1\"},\"color\":null}}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "co2" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/co2_chart_card.json b/application/src/main/data/json/system/widget_types/co2_chart_card.json new file mode 100644 index 0000000000..b4b6fe348f --- /dev/null +++ b/application/src/main/data/json/system/widget_types/co2_chart_card.json @@ -0,0 +1,31 @@ +{ + "fqn": "co2_chart_card", + "name": "CO2 chart card", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays a CO2 level data as a combination of the latest and aggregated values. Optionally may display the corresponding historical values as a simplified chart.", + "descriptor": { + "type": "timeseries", + "sizeX": 4.5, + "sizeY": 3.5, + "resources": [], + "templateHtml": "\n\n", + "templateCss": ".legend {\n font-size: 13px;\n line-height: 10px;\n}\n\n.legend table { \n border-spacing: 0px;\n border-collapse: separate;\n}\n\n.mouse-events .flot-overlay {\n cursor: crosshair; \n}\n\n", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onDataUpdated();\n};\n\nself.onLatestDataUpdated = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onLatestDataUpdated();\n}\n\nself.onResize = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onResize();\n}\n\nself.onEditModeChanged = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onEditModeChanged();\n}\n\nself.onDestroy = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onDestroy();\n}\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '400px',\n previewHeight: '300px',\n embedTitlePanel: true,\n hasAdditionalLatestDataKeys: true,\n defaultDataKeysFunction: function() {\n return [\n { name: 'co2', label: 'CO2 level', type: 'timeseries', color: 'rgba(0, 0, 0, 0.87)', units: 'ppm', decimals: 0 }\n ];\n },\n defaultLatestDataKeysFunction: function(configComponent, configData) {\n return configComponent.createDefaultAggregatedValueLatestDataKeys(configData, 'co2', 'ppm', 0);\n }\n };\n}\n", + "settingsSchema": "{}", + "dataKeySettingsSchema": "{}", + "latestDataKeySettingsSchema": "{}", + "settingsDirective": "tb-aggregated-value-card-widget-settings", + "dataKeySettingsDirective": "", + "latestDataKeySettingsDirective": "tb-aggregated-value-card-key-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-aggregated-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"Main building\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"CO2 level\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{\"showLines\":true,\"fillLines\":true,\"showPoints\":false},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 160 - 80;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < 400) {\\n\\tvalue = 400;\\n} else if (value > 1600) {\\n\\tvalue = 1600;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"ppm\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"#4caf50\",\"settings\":{\"position\":\"center\",\"font\":{\"size\":52,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"1\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":600,\"color\":\"#3FA71A\"},{\"from\":600,\"to\":1000,\"color\":\"#80C32C\"},{\"from\":1000,\"to\":1500,\"color\":\"#F36900\"},{\"from\":1500,\"to\":null,\"color\":\"#D81838\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.9408410830697858,\"funcBody\":\"var value = prevValue + Math.random() * 160 - 80;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < 400) {\\n\\tvalue = 400;\\n} else if (value > 1600) {\\n\\tvalue = 1600;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"ppm\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta percent\",\"color\":\"#f44336\",\"settings\":{\"position\":\"rightTop\",\"font\":{\"size\":14,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"20px\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[{\"from\":null,\"to\":0,\"color\":\"#198038\"},{\"from\":0,\"to\":0,\"color\":\"rgba(0, 0, 0, 0.87)\"},{\"from\":0,\"to\":null,\"color\":\"#D12730\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":true},\"_hash\":0.06392321853157967,\"funcBody\":\"var value = prevValue + Math.random() * 6 - 3;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < -25) {\\n\\tvalue = -25;\\n} else if (value > 25) {\\n\\tvalue = 25;\\n} \\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta absolute\",\"color\":\"#607d8b\",\"settings\":{\"position\":\"rightBottom\",\"font\":{\"size\":11,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.44695098620509865,\"funcBody\":\"var value = prevValue + Math.random() * 4 - 2;\\nif (value < -6) {\\n\\tvalue = -6;\\n} else if (value > 6) {\\n\\tvalue = 6;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"ppm\",\"decimals\":1,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1691927717318,\"endTimeMs\":1692014117318},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"stack\":false,\"fontSize\":10,\"fontColor\":\"#545454\",\"showTooltip\":true,\"tooltipIndividual\":false,\"tooltipCumulative\":false,\"hideZeros\":false,\"grid\":{\"verticalLines\":true,\"horizontalLines\":true,\"outlineWidth\":1,\"color\":\"#545454\",\"backgroundColor\":null,\"tickColor\":\"#DDDDDD\"},\"xaxis\":{\"title\":null,\"showLabels\":true,\"color\":\"#545454\"},\"yaxis\":{\"min\":null,\"max\":null,\"title\":null,\"showLabels\":true,\"color\":\"#545454\",\"tickSize\":null,\"tickDecimals\":0,\"ticksFormatter\":\"\"},\"shadowSize\":4,\"smoothLines\":false,\"comparisonEnabled\":false,\"xaxisSecond\":{\"axisPosition\":\"top\",\"title\":null,\"showLabels\":true},\"showLegend\":true,\"legendConfig\":{\"direction\":\"column\",\"position\":\"bottom\",\"sortDataKeys\":false,\"showMin\":false,\"showMax\":false,\"showAvg\":true,\"showTotal\":false,\"showLatest\":false},\"customLegendEnabled\":false,\"showSubtitle\":true,\"subtitle\":\"${entityName}\",\"subtitleFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"subtitleColor\":\"rgba(0, 0, 0, 0.38)\",\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"dateColor\":\"rgba(0, 0, 0, 0.38)\",\"showChart\":true,\"chartColor\":\"rgba(0, 0, 0, 0.87)\",\"background\":{\"type\":\"color\",\"color\":\"#fff\",\"overlay\":{\"enabled\":false,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"CO2 level\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"co2\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"24px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":false,\"displayTimewindow\":true,\"decimals\":0,\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"24px\",\"icon\":null,\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":false},\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "co2" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/co2_chart_card_with_background.json b/application/src/main/data/json/system/widget_types/co2_chart_card_with_background.json new file mode 100644 index 0000000000..e4cc301fb6 --- /dev/null +++ b/application/src/main/data/json/system/widget_types/co2_chart_card_with_background.json @@ -0,0 +1,31 @@ +{ + "fqn": "co2_chart_card_with_background", + "name": "CO2 chart card with background", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays a CO2 level data as a combination of the latest and aggregated values with background. Optionally may display the corresponding historical values as a simplified chart.", + "descriptor": { + "type": "timeseries", + "sizeX": 4.5, + "sizeY": 3.5, + "resources": [], + "templateHtml": "\n\n", + "templateCss": ".legend {\n font-size: 13px;\n line-height: 10px;\n}\n\n.legend table { \n border-spacing: 0px;\n border-collapse: separate;\n}\n\n.mouse-events .flot-overlay {\n cursor: crosshair; \n}\n\n", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onDataUpdated();\n};\n\nself.onLatestDataUpdated = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onLatestDataUpdated();\n}\n\nself.onResize = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onResize();\n}\n\nself.onEditModeChanged = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onEditModeChanged();\n}\n\nself.onDestroy = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onDestroy();\n}\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '400px',\n previewHeight: '300px',\n embedTitlePanel: true,\n hasAdditionalLatestDataKeys: true,\n defaultDataKeysFunction: function() {\n return [\n { name: 'co2', label: 'CO2 level', type: 'timeseries', color: 'rgba(0, 0, 0, 0.87)', units: 'ppm', decimals: 0 }\n ];\n },\n defaultLatestDataKeysFunction: function(configComponent, configData) {\n return configComponent.createDefaultAggregatedValueLatestDataKeys(configData, 'co2', 'ppm', 0);\n }\n };\n}\n", + "settingsSchema": "{}", + "dataKeySettingsSchema": "{}", + "latestDataKeySettingsSchema": "{}", + "settingsDirective": "tb-aggregated-value-card-widget-settings", + "dataKeySettingsDirective": "", + "latestDataKeySettingsDirective": "tb-aggregated-value-card-key-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-aggregated-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"Main building\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"CO2 level\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{\"showLines\":true,\"fillLines\":true,\"showPoints\":false},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 160 - 80;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < 400) {\\n\\tvalue = 400;\\n} else if (value > 1600) {\\n\\tvalue = 1600;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"ppm\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"#4caf50\",\"settings\":{\"position\":\"center\",\"font\":{\"size\":52,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"1\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":600,\"color\":\"#3B911C\"},{\"from\":600,\"to\":1000,\"color\":\"#7CC322\"},{\"from\":1000,\"to\":1500,\"color\":\"#F77410\"},{\"from\":1500,\"to\":null,\"color\":\"#DE2343\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.9408410830697858,\"funcBody\":\"var value = prevValue + Math.random() * 160 - 80;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < 400) {\\n\\tvalue = 400;\\n} else if (value > 1600) {\\n\\tvalue = 1600;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"ppm\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta percent\",\"color\":\"#f44336\",\"settings\":{\"position\":\"rightTop\",\"font\":{\"size\":14,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"20px\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[{\"from\":null,\"to\":0,\"color\":\"#198038\"},{\"from\":0,\"to\":0,\"color\":\"rgba(0, 0, 0, 0.87)\"},{\"from\":0,\"to\":null,\"color\":\"#D12730\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":true},\"_hash\":0.06392321853157967,\"funcBody\":\"var value = prevValue + Math.random() * 6 - 3;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < -25) {\\n\\tvalue = -25;\\n} else if (value > 25) {\\n\\tvalue = 25;\\n} \\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta absolute\",\"color\":\"#607d8b\",\"settings\":{\"position\":\"rightBottom\",\"font\":{\"size\":11,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.44695098620509865,\"funcBody\":\"var value = prevValue + Math.random() * 4 - 2;\\nif (value < -6) {\\n\\tvalue = -6;\\n} else if (value > 6) {\\n\\tvalue = 6;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"ppm\",\"decimals\":1,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1691927717318,\"endTimeMs\":1692014117318},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"stack\":false,\"fontSize\":10,\"fontColor\":\"#545454\",\"showTooltip\":true,\"tooltipIndividual\":false,\"tooltipCumulative\":false,\"hideZeros\":false,\"grid\":{\"verticalLines\":true,\"horizontalLines\":true,\"outlineWidth\":1,\"color\":\"#545454\",\"backgroundColor\":null,\"tickColor\":\"#DDDDDD\"},\"xaxis\":{\"title\":null,\"showLabels\":true,\"color\":\"#545454\"},\"yaxis\":{\"min\":null,\"max\":null,\"title\":null,\"showLabels\":true,\"color\":\"#545454\",\"tickSize\":null,\"tickDecimals\":0,\"ticksFormatter\":\"\"},\"shadowSize\":4,\"smoothLines\":false,\"comparisonEnabled\":false,\"xaxisSecond\":{\"axisPosition\":\"top\",\"title\":null,\"showLabels\":true},\"showLegend\":true,\"legendConfig\":{\"direction\":\"column\",\"position\":\"bottom\",\"sortDataKeys\":false,\"showMin\":false,\"showMax\":false,\"showAvg\":true,\"showTotal\":false,\"showLatest\":false},\"customLegendEnabled\":false,\"showSubtitle\":true,\"subtitle\":\"${entityName}\",\"subtitleFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"subtitleColor\":\"rgba(0, 0, 0, 0.38)\",\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"dateColor\":\"rgba(0, 0, 0, 0.38)\",\"showChart\":true,\"chartColor\":\"rgba(0, 0, 0, 0.87)\",\"background\":{\"type\":\"image\",\"imageBase64\":\"data:image/png;base64,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\",\"imageUrl\":null,\"color\":\"#fff\",\"overlay\":{\"enabled\":true,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"CO2 level\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"co2\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"24px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":false,\"displayTimewindow\":true,\"decimals\":0,\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"24px\",\"icon\":null,\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":false},\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "co2" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/horizontal_co2_card.json b/application/src/main/data/json/system/widget_types/horizontal_co2_card.json new file mode 100644 index 0000000000..85b8ef899f --- /dev/null +++ b/application/src/main/data/json/system/widget_types/horizontal_co2_card.json @@ -0,0 +1,28 @@ +{ + "fqn": "horizontal_co2_card", + "name": "Horizontal CO2 card", + "deprecated": false, + "image": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAMgAAACgCAMAAAB+IdObAAAAllBMVEUAAADf39/f39/g4ODg4ODf39/////k5OSAwyzg4OCQy0bQ6a/v9+Wv2XvIyMjf8Mqg0mD3+/LOzs6/4ZX09PT5+flYWFiIxznY7L3b29u3t7fV1dXCwsK8vLzx8fHn5+fn9NiQkJDH5aN0dHS43Yitra2YzlOenp6CgoJmZmY5OTnU1NS33Yio1m7t7e1KSkqn1m243YlPJUzgAAAABnRSTlMAIEDfv1C6kOEmAAADiElEQVR42u3a647aMBAFYNpuJyYX554QkkAId3ZZtu//cp1xUHoVpbS0gM4nYYaMf/jIGITIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOBfenf3BuL9B+veDT985BxWSncvsd4PnhJ6AOnTYEgPYYggNwZBbg2C3BoEuTUIcmvOC7KelUR6tpShltclfaXc0P93VpDNRh/0cqu3S70tdxOiuabJhCwiS551RhcJ29hxSfhtPKK+ul6Qw4RKK9Okt7zsLkidZevNWM+tw3Z9YZBYMbvpK7evwmsF2RHLSiozotmMJEg2Wx/0fDOeb5a7y4K4SvlNrGypbL95UQGRL9WbWlwrSKZppjdrWs4lhwmynWlNu4zm/HxZEEe98Zgrl15k5WGuQvKUw5XKyQjdMByNXFNR6Pgm/rEKfW6cCuI7js9THefraWWWZRNrlx0svcuyWoKU2XZNszm3OMqFQQITJKRAybFYqYYfslpbuccZ+1zxHhEH3Js3n/Q8qRqbx/ZUELUKchrlgf3t9k76oTfpny8T2qp1PymPOIhPZuwi8Ogfg6h45Kk8JB5iZ6UC6dmOwykW0jgZxCWXnIBij66tUWwVngryZq47HKQ1b76m67XHzXTPCxIodcU0siNvsa3iU0E8IjlB3dmhPY/SOzbs00GCVU6OeWuFbhvQ9bRmNbnyfxEk5rEL4v1OkJE57Dy69MkOWrqefb84eZjDLsfehAu/2ZG4myHdM4L8KPA4k5HQTySv319I6HwSYWFWM6JW7c2XCVEs1xqpjp9axxmeimWGci8KsgiCFzLGXZiEXgsy0pTSYSQXhpQS0XQ5pbQoukYqM3/NV8qLA2Wb0+J1pyXMTeUcg/QzPKl4Fl0URPRByjIqtI64qqgqqjodV1FZ6qh+jeqUKJomdV1QEplGpGv6tZF8FwSyGJerfEGskar98k3DL1euBHnhKgj/QpDn53Gio2nUBZk+F1zztWkRVdoEGRYFB9H1VCcct0roDKEb/lC5fSXr5ZfUnSSpTjgvyDIqqmhc6iqRHYnqohonYx3xtVdeeEQSJJUdmdZLaZRVRX/OBBEmyFV+WBXTE81nXfB4H0HS9FQzob+k6X+ajOIGP3XvDYLcGgS5NQhyax4oyNMD/M1OlDzxDQMP8Ed7yjcMDD5+GFr37sP7R7qpBgAAAAAAAAAAAAAAAAAAAAAAAAAAAOAf+QwerQBC9f0WmwAAAABJRU5ErkJggg==", + "description": "Displays a latest CO2 level telemetry data in a horizontal layout.", + "descriptor": { + "type": "latest", + "sizeX": 5, + "sizeY": 1, + "resources": [], + "templateHtml": "\n", + "templateCss": "", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueCardWidget.onDataUpdated();\n};\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n horizontal: true,\n previewWidth: '420px',\n previewHeight: '90px',\n embedTitlePanel: true,\n defaultDataKeysFunction: function() {\n return [{ name: 'co2', label: 'CO2 level', type: 'timeseries' }];\n }\n };\n};\n\nself.onDestroy = function() {\n};\n", + "settingsSchema": "", + "dataKeySettingsSchema": "", + "settingsDirective": "tb-value-card-widget-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"function\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"CO2 level\",\"color\":\"#2196f3\",\"settings\":{},\"_hash\":0.2392660816082064,\"funcBody\":\"var value = prevValue + Math.random() * 160 - 80;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < 400) {\\n\\tvalue = 400;\\n} else if (value > 1600) {\\n\\tvalue = 1600;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]}}],\"timewindow\":{\"realtime\":{\"timewindowMs\":60000}},\"showTitle\":false,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"padding\":\"0px\",\"settings\":{\"labelPosition\":\"top\",\"layout\":\"horizontal\",\"showLabel\":true,\"labelFont\":{\"family\":\"Roboto\",\"size\":16,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"labelColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showIcon\":true,\"iconSize\":40,\"iconSizeUnit\":\"px\",\"icon\":\"co2\",\"iconColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":600,\"color\":\"#3FA71A\"},{\"from\":600,\"to\":1000,\"color\":\"#80C32C\"},{\"from\":1000,\"to\":1500,\"color\":\"#F36900\"},{\"from\":1500,\"to\":null,\"color\":\"#D81838\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"valueFont\":{\"size\":36,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\",\"rangeList\":[{\"from\":null,\"to\":600,\"color\":\"#3FA71A\"},{\"from\":600,\"to\":1000,\"color\":\"#80C32C\"},{\"from\":1000,\"to\":1500,\"color\":\"#F36900\"},{\"from\":1500,\"to\":null,\"color\":\"#D81838\"}]},\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"dateColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"color\",\"color\":\"#fff\",\"overlay\":{\"enabled\":false,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Horizontal CO2 card\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"units\":\"ppm\",\"decimals\":0,\"useDashboardTimewindow\":true,\"showLegend\":false,\"widgetStyle\":{},\"actions\":{},\"configMode\":\"basic\",\"displayTimewindow\":true,\"margin\":\"0px\",\"borderRadius\":\"0px\",\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"showTitleIcon\":false,\"titleTooltip\":\"\",\"titleFont\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1.6\"},\"titleIcon\":\"\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"iconSize\":\"14px\",\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"14px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1\"},\"color\":null}}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "co2" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/horizontal_co2_card_with_background.json b/application/src/main/data/json/system/widget_types/horizontal_co2_card_with_background.json new file mode 100644 index 0000000000..be668528e9 --- /dev/null +++ b/application/src/main/data/json/system/widget_types/horizontal_co2_card_with_background.json @@ -0,0 +1,28 @@ +{ + "fqn": "horizontal_co2_card_with_background", + "name": "Horizontal CO2 card with background", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays a latest CO2 level telemetry data in a horizontal layout with background.", + "descriptor": { + "type": "latest", + "sizeX": 5, + "sizeY": 1, + "resources": [], + "templateHtml": "\n", + "templateCss": "", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueCardWidget.onDataUpdated();\n};\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n horizontal: true,\n previewWidth: '420px',\n previewHeight: '90px',\n embedTitlePanel: true,\n defaultDataKeysFunction: function() {\n return [{ name: 'co2', label: 'CO2 level', type: 'timeseries' }];\n }\n };\n};\n\nself.onDestroy = function() {\n};\n", + "settingsSchema": "", + "dataKeySettingsSchema": "", + "settingsDirective": "tb-value-card-widget-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"function\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"CO2 level\",\"color\":\"#2196f3\",\"settings\":{},\"_hash\":0.2392660816082064,\"funcBody\":\"var value = prevValue + Math.random() * 160 - 80;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < 400) {\\n\\tvalue = 400;\\n} else if (value > 1600) {\\n\\tvalue = 1600;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]}}],\"timewindow\":{\"realtime\":{\"timewindowMs\":60000}},\"showTitle\":false,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"padding\":\"0px\",\"settings\":{\"labelPosition\":\"top\",\"layout\":\"horizontal\",\"showLabel\":true,\"labelFont\":{\"family\":\"Roboto\",\"size\":16,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"labelColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showIcon\":true,\"iconSize\":40,\"iconSizeUnit\":\"px\",\"icon\":\"co2\",\"iconColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":600,\"color\":\"#3B911C\"},{\"from\":600,\"to\":1000,\"color\":\"#7CC322\"},{\"from\":1000,\"to\":1500,\"color\":\"#F77410\"},{\"from\":1500,\"to\":null,\"color\":\"#DE2343\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"valueFont\":{\"size\":36,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\",\"rangeList\":[{\"from\":null,\"to\":600,\"color\":\"#3B911C\"},{\"from\":600,\"to\":1000,\"color\":\"#7CC322\"},{\"from\":1000,\"to\":1500,\"color\":\"#F77410\"},{\"from\":1500,\"to\":null,\"color\":\"#DE2343\"}]},\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"dateColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"image\",\"imageBase64\":\"data:image/png;base64,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\",\"imageUrl\":null,\"color\":\"#fff\",\"overlay\":{\"enabled\":true,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Horizontal CO2 card\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"units\":\"ppm\",\"decimals\":0,\"useDashboardTimewindow\":true,\"showLegend\":false,\"widgetStyle\":{},\"actions\":{},\"configMode\":\"basic\",\"displayTimewindow\":true,\"margin\":\"0px\",\"borderRadius\":\"0px\",\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"showTitleIcon\":false,\"titleTooltip\":\"\",\"titleFont\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1.6\"},\"titleIcon\":\"\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"iconSize\":\"14px\",\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"14px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1\"},\"color\":null}}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "co2" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/simple_co2_chart_card.json b/application/src/main/data/json/system/widget_types/simple_co2_chart_card.json new file mode 100644 index 0000000000..9a541665ee --- /dev/null +++ b/application/src/main/data/json/system/widget_types/simple_co2_chart_card.json @@ -0,0 +1,31 @@ +{ + "fqn": "simple_co2_chart_card", + "name": "Simple CO2 chart card", + "deprecated": false, + "image": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAMgAAACgCAMAAAB+IdObAAAAkFBMVEUAAAAAAAD19fUAAABvb2/9/f36+vrx8fHk5OTU1NT///+AwywhISHj4+N0dHTx8fGv2XtYWFjHx8eQy0bv9+Xf8Mq/4ZU8PDwvLy/3+/KQkJCCgoKIxzmsrKyQykbV1dWg0mCg0mGenp643Yi6urrP6bDn9NhKSkpmZmaYzlOdnZ2rq6vX7L3H5aPH5aKo1m5LZ5BzAAAACnRSTlMAH8cQMfHjso9z2hGKZwAABOpJREFUeNrsz0kRwCAQADBuKP4Fd+qgT9hJHCQBAAAAAAD8VvP16tdoq+/L9dlqymMHMFp6dggrlR3CjBIpIocROc3Lbr2s1goEURieL+pC1aQbm6ZBBEXf//2OtkJOSGBvCIQK9A+6QBz4DRQHJFoDEq0BidaARGtAovU+ZJayXFvv1UkK48oE3+TE+MXeh1guQjNQsmzXpjSlpMBfg1RiYMpwWs4ldWpo5MAN0Xlm+AK0Cvi8RIGI1H58VDIA9mepgp9n7RBOZpkrKTY7uVvagkCMF95c8JGk/5cmAJwEVyb9qhXNFXQoHXBqMSAr+wVhSw29zxClGdB1VQAdsiazbDBZSJ1WW6nGgBSZVeTQXRx3e1ZgMd3pXCe/SIyeCZK5e4Nn2dBodneNAXliq4o7zUVbsnO31lICSnZmBTpkyqx7g+Z8nCdhlVgQrZXxtCQiY4DvZboSoENUiFZ+PgktEZUgL/u3sd6riq8pf73z541flD/cgERrQKI1INEakGgNSLQGJFoD8hu5mBXHG4WGsFE2yySKl0WGcMrHtRMZXhYZItTQ26niVZEh/9gzt+VkYSAA328CgoRDOIhURWk9vP/b/etmmf50pgQbZ8yF30xhMbnYj81GikUITGwvicci9JLZUEprl3gsUkkYCeQHWPBYJI8Blq8t70TWYVwFpgpfAMvXlm8ipSximQfAv8csX1ueiaxliVkXebvaFyeAB9bWq0VWVS6PDTD820WbS/Mm+YG19WKRIC/CMpbH8VJW5rz/XP+YiKWaZUZEKz2NR5SCZ3Gidvgcswx/f4EfF4ExapqJo1Xk3Akhut5k3tVCJAcgLhjXkQY3pj0c5+ayCOdqV7bBOpZI3gBjFzlgtgmqpBhrDBJM/wJIZgY6eAZ72fLD1No0QjAjHUqkKINgf5QhT7SLJCLRoGpK+EI+O1FrACVERp8c4AmEBbd8XjRtUMlqvn77Zr3i1s/R3C5C+V7hnrzA4yAiPGpKPhM1IFtx+24enaZ6jFWach+Nse5TBb9wPI05niRSPbBJyI+FInTLMxJBKVOkHcANa0SGGyAyscFJIrlgHIkouse9mdxRfK7xFOm5FiHaplk9tG0vEaEqdNQcEUshdLElEWPIgRi2ppkijmuFk/G0xTjBE8bZTIu4YBfpsUmiWiTqW2T7i8gVqJlIpAdIhdhRjylamje6KwP8hFvEgrMI5YBcwS7CJ40iGzNvw+WDlCrFA1O4RSy4itAelR0iIS7LRM5YDMqXP7KL2J8E3UVMBufxRo8iw4wIZcz5HpaKVDIAC84inB856OmuNfCuNRX5Q0VaGYIFd5ELloILMyalxu8RDVSYiUg06ZFhiciXzFdgwVmEtx59E0JR8njcUdzTQEpSLJKhZMK71plW1s4mQh5Hq4e7CCWVdDVmyc9aXUIx+SQD/gGwiLkWir9H7mPKLlLaPNxFmAwzF/WVYnWjmAdQT2w1IFyRBAfPJt/dfUyBVaS0vwZ1Fxn5/xlJU8z0PWuMPdLjIOdLEy2QB9hxF1kOiTAksohSVvB3PBL5/AAHPBJx5/ki9D8H06c9vA6/3mu9Rd4iHvIW8Y23iG+8RXzjLfKvnTuoASCEASDYgyZw+BeMBZ7QzDhYA3sbIbdpMVYJLeYq4Y+sMUH6oud4f0s1s9cZhQEAAAAAAJzZz8keC0HEP5QAAAAASUVORK5CYII=", + "description": "Displays historical CO2 level values as a simplified chart. Optionally may display the corresponding latest CO2 level value.", + "descriptor": { + "type": "timeseries", + "sizeX": 4.5, + "sizeY": 2, + "resources": [], + "templateHtml": "\n\n", + "templateCss": ".legend {\n font-size: 13px;\n line-height: 10px;\n}\n\n.legend table { \n border-spacing: 0px;\n border-collapse: separate;\n}\n\n.mouse-events .flot-overlay {\n cursor: crosshair; \n}\n\n", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueChartCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueChartCardWidget.onDataUpdated();\n};\n\nself.onLatestDataUpdated = function() {\n self.ctx.$scope.valueChartCardWidget.onLatestDataUpdated();\n}\n\nself.onEditModeChanged = function() {\n self.ctx.$scope.valueChartCardWidget.onEditModeChanged();\n}\n\nself.onDestroy = function() {\n self.ctx.$scope.valueChartCardWidget.onDestroy();\n}\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '300px',\n previewHeight: '150px',\n embedTitlePanel: true,\n hasAdditionalLatestDataKeys: true,\n defaultDataKeysFunction: function() {\n return [\n { name: 'co2', label: 'CO2 level', type: 'timeseries', color: 'rgba(0, 0, 0, 0.87)'}\n ];\n },\n defaultLatestDataKeysFunction: function(configComponent) {\n return [{ name: 'co2', label: 'Latest', type: 'timeseries'}];\n }\n };\n}\n", + "settingsSchema": "{}", + "dataKeySettingsSchema": "{}", + "latestDataKeySettingsSchema": "{}", + "settingsDirective": "tb-value-chart-card-widget-settings", + "dataKeySettingsDirective": "", + "latestDataKeySettingsDirective": "", + "hasBasicMode": true, + "basicModeDirective": "tb-value-chart-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"CO2 level\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 160 - 80;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < 400) {\\n\\tvalue = 400;\\n} else if (value > 1600) {\\n\\tvalue = 1600;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 160 - 80;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < 400) {\\n\\tvalue = 400;\\n} else if (value > 1600) {\\n\\tvalue = 1600;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"layout\":\"left\",\"autoScale\":true,\"showValue\":true,\"valueFont\":{\"family\":\"Roboto\",\"size\":28,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\",\"lineHeight\":\"32px\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":600,\"color\":\"#3FA71A\"},{\"from\":600,\"to\":1000,\"color\":\"#80C32C\"},{\"from\":1000,\"to\":1500,\"color\":\"#F36900\"},{\"from\":1500,\"to\":null,\"color\":\"#D81838\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"color\",\"color\":\"#fff\",\"overlay\":{\"enabled\":false,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}}},\"title\":\"CO2 level\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":null,\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"co2\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"18px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":true,\"decimals\":0,\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null,\"units\":\"ppm\",\"displayTimewindow\":true,\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1697382151041,\"endTimeMs\":1697468551041},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"timewindowStyle\":{\"showIcon\":false,\"iconSize\":\"24px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":true}}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "co2" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/simple_co2_chart_card_with_background.json b/application/src/main/data/json/system/widget_types/simple_co2_chart_card_with_background.json new file mode 100644 index 0000000000..a498ba3501 --- /dev/null +++ b/application/src/main/data/json/system/widget_types/simple_co2_chart_card_with_background.json @@ -0,0 +1,31 @@ +{ + "fqn": "simple_co2_chart_card_with_background", + "name": "Simple CO2 chart card with background", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays historical CO2 level values as a simplified chart with background. Optionally may display the corresponding latest CO2 level value.", + "descriptor": { + "type": "timeseries", + "sizeX": 4.5, + "sizeY": 2, + "resources": [], + "templateHtml": "\n\n", + "templateCss": ".legend {\n font-size: 13px;\n line-height: 10px;\n}\n\n.legend table { \n border-spacing: 0px;\n border-collapse: separate;\n}\n\n.mouse-events .flot-overlay {\n cursor: crosshair; \n}\n\n", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueChartCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueChartCardWidget.onDataUpdated();\n};\n\nself.onLatestDataUpdated = function() {\n self.ctx.$scope.valueChartCardWidget.onLatestDataUpdated();\n}\n\nself.onEditModeChanged = function() {\n self.ctx.$scope.valueChartCardWidget.onEditModeChanged();\n}\n\nself.onDestroy = function() {\n self.ctx.$scope.valueChartCardWidget.onDestroy();\n}\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '300px',\n previewHeight: '150px',\n embedTitlePanel: true,\n hasAdditionalLatestDataKeys: true,\n defaultDataKeysFunction: function() {\n return [\n { name: 'co2', label: 'CO2 level', type: 'timeseries', color: 'rgba(0, 0, 0, 0.87)'}\n ];\n },\n defaultLatestDataKeysFunction: function(configComponent) {\n return [{ name: 'co2', label: 'Latest', type: 'timeseries'}];\n }\n };\n}\n", + "settingsSchema": "{}", + "dataKeySettingsSchema": "{}", + "latestDataKeySettingsSchema": "{}", + "settingsDirective": "tb-value-chart-card-widget-settings", + "dataKeySettingsDirective": "", + "latestDataKeySettingsDirective": "", + "hasBasicMode": true, + "basicModeDirective": "tb-value-chart-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"CO2 level\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 160 - 80;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < 400) {\\n\\tvalue = 400;\\n} else if (value > 1600) {\\n\\tvalue = 1600;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 160 - 80;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < 400) {\\n\\tvalue = 400;\\n} else if (value > 1600) {\\n\\tvalue = 1600;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"layout\":\"left\",\"autoScale\":true,\"showValue\":true,\"valueFont\":{\"family\":\"Roboto\",\"size\":28,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\",\"lineHeight\":\"32px\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":600,\"color\":\"#3B911C\"},{\"from\":600,\"to\":1000,\"color\":\"#7CC322\"},{\"from\":1000,\"to\":1500,\"color\":\"#F77410\"},{\"from\":1500,\"to\":null,\"color\":\"#DE2343\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"image\",\"imageBase64\":\"data:image/png;base64,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\",\"imageUrl\":null,\"color\":\"#fff\",\"overlay\":{\"enabled\":true,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}}},\"title\":\"CO2 level\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":null,\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"co2\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"18px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":true,\"decimals\":0,\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null,\"units\":\"ppm\",\"displayTimewindow\":true,\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1697382151041,\"endTimeMs\":1697468551041},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"timewindowStyle\":{\"showIcon\":false,\"iconSize\":\"24px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":true}}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "co2" + ] +} \ No newline at end of file From 98cc9ee188e081f3e319ffd0fb91f0a3418e2013 Mon Sep 17 00:00:00 2001 From: Igor Kulikov Date: Wed, 25 Oct 2023 17:11:44 +0300 Subject: [PATCH 40/43] UI: Outdoor Environment: Flooding level widgets. --- .../widget_bundles/outdoor_environment.json | 12 ++++++- .../widget_types/flooding_level_card.json | 29 +++++++++++++++++ .../flooding_level_card_with_background.json | 29 +++++++++++++++++ .../flooding_level_chart_card.json | 32 +++++++++++++++++++ ...ding_level_chart_card_with_background.json | 32 +++++++++++++++++++ .../flooding_level_progress_bar.json | 30 +++++++++++++++++ ...ng_level_progress_bar_with_background.json | 30 +++++++++++++++++ .../horizontal_flooding_level_card.json | 29 +++++++++++++++++ ...l_flooding_level_card_with_background.json | 29 +++++++++++++++++ .../simple_flooding_level_chart_card.json | 32 +++++++++++++++++++ ...ding_level_chart_card_with_background.json | 32 +++++++++++++++++++ 11 files changed, 315 insertions(+), 1 deletion(-) create mode 100644 application/src/main/data/json/system/widget_types/flooding_level_card.json create mode 100644 application/src/main/data/json/system/widget_types/flooding_level_card_with_background.json create mode 100644 application/src/main/data/json/system/widget_types/flooding_level_chart_card.json create mode 100644 application/src/main/data/json/system/widget_types/flooding_level_chart_card_with_background.json create mode 100644 application/src/main/data/json/system/widget_types/flooding_level_progress_bar.json create mode 100644 application/src/main/data/json/system/widget_types/flooding_level_progress_bar_with_background.json create mode 100644 application/src/main/data/json/system/widget_types/horizontal_flooding_level_card.json create mode 100644 application/src/main/data/json/system/widget_types/horizontal_flooding_level_card_with_background.json create mode 100644 application/src/main/data/json/system/widget_types/simple_flooding_level_chart_card.json create mode 100644 application/src/main/data/json/system/widget_types/simple_flooding_level_chart_card_with_background.json diff --git a/application/src/main/data/json/system/widget_bundles/outdoor_environment.json b/application/src/main/data/json/system/widget_bundles/outdoor_environment.json index ed52d20f5e..64f427fd69 100644 --- a/application/src/main/data/json/system/widget_bundles/outdoor_environment.json +++ b/application/src/main/data/json/system/widget_bundles/outdoor_environment.json @@ -145,6 +145,16 @@ "co2_chart_card", "co2_chart_card_with_background", "simple_co2_chart_card", - "simple_co2_chart_card_with_background" + "simple_co2_chart_card_with_background", + "flooding_level_card", + "flooding_level_card_with_background", + "horizontal_flooding_level_card", + "horizontal_flooding_level_card_with_background", + "flooding_level_chart_card", + "flooding_level_chart_card_with_background", + "simple_flooding_level_chart_card", + "simple_flooding_level_chart_card_with_background", + "flooding_level_progress_bar", + "flooding_level_progress_bar_with_background" ] } \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/flooding_level_card.json b/application/src/main/data/json/system/widget_types/flooding_level_card.json new file mode 100644 index 0000000000..6a96ac6457 --- /dev/null +++ b/application/src/main/data/json/system/widget_types/flooding_level_card.json @@ -0,0 +1,29 @@ +{ + "fqn": "flooding_level_card", + "name": "Flooding level card", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays a latest flooding level telemetry data in a box layout.", + "descriptor": { + "type": "latest", + "sizeX": 3, + "sizeY": 3, + "resources": [], + "templateHtml": "\n", + "templateCss": "", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueCardWidget.onDataUpdated();\n};\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '250px',\n previewHeight: '250px',\n embedTitlePanel: true,\n defaultDataKeysFunction: function() {\n return [{ name: 'flooding', label: 'Flooding level', type: 'timeseries' }];\n }\n };\n};\n\nself.onDestroy = function() {\n};\n", + "settingsSchema": "", + "dataKeySettingsSchema": "", + "settingsDirective": "tb-value-card-widget-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"function\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Flooding level\",\"color\":\"#2196f3\",\"settings\":{},\"_hash\":0.2392660816082064,\"funcBody\":\"var value = prevValue + Math.random() * 2 - 1;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 5) {\\n\\tvalue = 5;\\n}\\nreturn value;\\n\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]}}],\"timewindow\":{\"realtime\":{\"timewindowMs\":60000}},\"showTitle\":false,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"padding\":\"0px\",\"settings\":{\"labelPosition\":\"top\",\"layout\":\"square\",\"showLabel\":true,\"labelFont\":{\"family\":\"Roboto\",\"size\":16,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"labelColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showIcon\":true,\"iconSize\":40,\"iconSizeUnit\":\"px\",\"icon\":\"flood\",\"iconColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":1,\"color\":\"#234CC7\"},{\"from\":1,\"to\":3,\"color\":\"#F36900\"},{\"from\":3,\"to\":null,\"color\":\"#D81838\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"valueFont\":{\"size\":36,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\",\"rangeList\":[{\"from\":null,\"to\":1,\"color\":\"#234CC7\"},{\"from\":1,\"to\":3,\"color\":\"#F36900\"},{\"from\":3,\"to\":null,\"color\":\"#D81838\"}]},\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"dateColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"color\",\"color\":\"#fff\",\"overlay\":{\"enabled\":false,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Flooding level card\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"units\":\"m\",\"decimals\":1,\"useDashboardTimewindow\":true,\"showLegend\":false,\"widgetStyle\":{},\"actions\":{},\"configMode\":\"basic\",\"displayTimewindow\":true,\"margin\":\"0px\",\"borderRadius\":\"0px\",\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"showTitleIcon\":false,\"titleTooltip\":\"\",\"titleFont\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1.6\"},\"titleIcon\":\"\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"iconSize\":\"14px\",\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"14px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1\"},\"color\":null}}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "flood", + "flooding" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/flooding_level_card_with_background.json b/application/src/main/data/json/system/widget_types/flooding_level_card_with_background.json new file mode 100644 index 0000000000..351a40fe8b --- /dev/null +++ b/application/src/main/data/json/system/widget_types/flooding_level_card_with_background.json @@ -0,0 +1,29 @@ +{ + "fqn": "flooding_level_card_with_background", + "name": "Flooding level card with background", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays a latest flooding level telemetry data in a box layout with background.", + "descriptor": { + "type": "latest", + "sizeX": 3, + "sizeY": 3, + "resources": [], + "templateHtml": "\n", + "templateCss": "", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueCardWidget.onDataUpdated();\n};\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '250px',\n previewHeight: '250px',\n embedTitlePanel: true,\n defaultDataKeysFunction: function() {\n return [{ name: 'flooding', label: 'Flooding level', type: 'timeseries' }];\n }\n };\n};\n\nself.onDestroy = function() {\n};\n", + "settingsSchema": "", + "dataKeySettingsSchema": "", + "settingsDirective": "tb-value-card-widget-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"function\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Flooding level\",\"color\":\"#2196f3\",\"settings\":{},\"_hash\":0.2392660816082064,\"funcBody\":\"var value = prevValue + Math.random() * 2 - 1;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 5) {\\n\\tvalue = 5;\\n}\\nreturn value;\\n\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]}}],\"timewindow\":{\"realtime\":{\"timewindowMs\":60000}},\"showTitle\":false,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"padding\":\"0px\",\"settings\":{\"labelPosition\":\"top\",\"layout\":\"square\",\"showLabel\":true,\"labelFont\":{\"family\":\"Roboto\",\"size\":16,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"labelColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showIcon\":true,\"iconSize\":40,\"iconSizeUnit\":\"px\",\"icon\":\"flood\",\"iconColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":1,\"color\":\"#224AC2\"},{\"from\":1,\"to\":3,\"color\":\"#F77410\"},{\"from\":3,\"to\":null,\"color\":\"#DE2343\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"valueFont\":{\"size\":36,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\",\"rangeList\":[{\"from\":null,\"to\":1,\"color\":\"#224AC2\"},{\"from\":1,\"to\":3,\"color\":\"#F77410\"},{\"from\":3,\"to\":null,\"color\":\"#DE2343\"}]},\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"dateColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"image\",\"imageBase64\":\"data:image/png;base64,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\",\"imageUrl\":null,\"color\":\"#fff\",\"overlay\":{\"enabled\":true,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Flooding level card\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"units\":\"m\",\"decimals\":1,\"useDashboardTimewindow\":true,\"showLegend\":false,\"widgetStyle\":{},\"actions\":{},\"configMode\":\"basic\",\"displayTimewindow\":true,\"margin\":\"0px\",\"borderRadius\":\"0px\",\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"showTitleIcon\":false,\"titleTooltip\":\"\",\"titleFont\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1.6\"},\"titleIcon\":\"\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"iconSize\":\"14px\",\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"14px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1\"},\"color\":null}}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "flood", + "flooding" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/flooding_level_chart_card.json b/application/src/main/data/json/system/widget_types/flooding_level_chart_card.json new file mode 100644 index 0000000000..f9cb12eb81 --- /dev/null +++ b/application/src/main/data/json/system/widget_types/flooding_level_chart_card.json @@ -0,0 +1,32 @@ +{ + "fqn": "flooding_level_chart_card", + "name": "Flooding level chart card", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays a flooding level data as a combination of the latest and aggregated values. Optionally may display the corresponding historical values as a simplified chart.", + "descriptor": { + "type": "timeseries", + "sizeX": 4.5, + "sizeY": 3.5, + "resources": [], + "templateHtml": "\n\n", + "templateCss": ".legend {\n font-size: 13px;\n line-height: 10px;\n}\n\n.legend table { \n border-spacing: 0px;\n border-collapse: separate;\n}\n\n.mouse-events .flot-overlay {\n cursor: crosshair; \n}\n\n", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onDataUpdated();\n};\n\nself.onLatestDataUpdated = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onLatestDataUpdated();\n}\n\nself.onResize = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onResize();\n}\n\nself.onEditModeChanged = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onEditModeChanged();\n}\n\nself.onDestroy = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onDestroy();\n}\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '400px',\n previewHeight: '300px',\n embedTitlePanel: true,\n hasAdditionalLatestDataKeys: true,\n defaultDataKeysFunction: function() {\n return [\n { name: 'flooding', label: 'Flooding level', type: 'timeseries', color: 'rgba(0, 0, 0, 0.87)', units: 'm', decimals: 1 }\n ];\n },\n defaultLatestDataKeysFunction: function(configComponent, configData) {\n return configComponent.createDefaultAggregatedValueLatestDataKeys(configData, 'flooding', 'm', 1);\n }\n };\n}\n", + "settingsSchema": "{}", + "dataKeySettingsSchema": "{}", + "latestDataKeySettingsSchema": "{}", + "settingsDirective": "tb-aggregated-value-card-widget-settings", + "dataKeySettingsDirective": "", + "latestDataKeySettingsDirective": "tb-aggregated-value-card-key-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-aggregated-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"Main building\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Flooding level\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{\"showLines\":true,\"fillLines\":true,\"showPoints\":false},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 2 - 1;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 5) {\\n\\tvalue = 5;\\n}\\nreturn value;\\n\",\"aggregationType\":null,\"units\":\"m\",\"decimals\":1,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"#4caf50\",\"settings\":{\"position\":\"center\",\"font\":{\"size\":52,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"1\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":1,\"color\":\"#234CC7\"},{\"from\":1,\"to\":3,\"color\":\"#F36900\"},{\"from\":3,\"to\":null,\"color\":\"#D81838\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.9408410830697858,\"funcBody\":\"var value = prevValue + Math.random() * 2 - 1;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 5) {\\n\\tvalue = 5;\\n}\\nreturn value;\\n\",\"aggregationType\":null,\"units\":\"m\",\"decimals\":1,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta percent\",\"color\":\"#f44336\",\"settings\":{\"position\":\"rightTop\",\"font\":{\"size\":14,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"20px\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[{\"from\":null,\"to\":0,\"color\":\"#198038\"},{\"from\":0,\"to\":0,\"color\":\"rgba(0, 0, 0, 0.87)\"},{\"from\":0,\"to\":null,\"color\":\"#D12730\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":true},\"_hash\":0.06392321853157967,\"funcBody\":\"var value = prevValue + Math.random() * 6 - 3;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < -25) {\\n\\tvalue = -25;\\n} else if (value > 25) {\\n\\tvalue = 25;\\n} \\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta absolute\",\"color\":\"#607d8b\",\"settings\":{\"position\":\"rightBottom\",\"font\":{\"size\":11,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.44695098620509865,\"funcBody\":\"var value = prevValue + Math.random() * 1 - 0.5;\\nif (value < -1.5) {\\n\\tvalue = -1.5;\\n} else if (value > 1.5) {\\n\\tvalue = 1.5;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"m\",\"decimals\":1,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1691927717318,\"endTimeMs\":1692014117318},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"stack\":false,\"fontSize\":10,\"fontColor\":\"#545454\",\"showTooltip\":true,\"tooltipIndividual\":false,\"tooltipCumulative\":false,\"hideZeros\":false,\"grid\":{\"verticalLines\":true,\"horizontalLines\":true,\"outlineWidth\":1,\"color\":\"#545454\",\"backgroundColor\":null,\"tickColor\":\"#DDDDDD\"},\"xaxis\":{\"title\":null,\"showLabels\":true,\"color\":\"#545454\"},\"yaxis\":{\"min\":null,\"max\":null,\"title\":null,\"showLabels\":true,\"color\":\"#545454\",\"tickSize\":null,\"tickDecimals\":0,\"ticksFormatter\":\"\"},\"shadowSize\":4,\"smoothLines\":false,\"comparisonEnabled\":false,\"xaxisSecond\":{\"axisPosition\":\"top\",\"title\":null,\"showLabels\":true},\"showLegend\":true,\"legendConfig\":{\"direction\":\"column\",\"position\":\"bottom\",\"sortDataKeys\":false,\"showMin\":false,\"showMax\":false,\"showAvg\":true,\"showTotal\":false,\"showLatest\":false},\"customLegendEnabled\":false,\"showSubtitle\":true,\"subtitle\":\"${entityName}\",\"subtitleFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"subtitleColor\":\"rgba(0, 0, 0, 0.38)\",\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"dateColor\":\"rgba(0, 0, 0, 0.38)\",\"showChart\":true,\"chartColor\":\"rgba(0, 0, 0, 0.87)\",\"background\":{\"type\":\"color\",\"color\":\"#fff\",\"overlay\":{\"enabled\":false,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Flooding level\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"flood\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"24px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":false,\"displayTimewindow\":true,\"decimals\":0,\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"24px\",\"icon\":null,\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":false},\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "flood", + "flooding" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/flooding_level_chart_card_with_background.json b/application/src/main/data/json/system/widget_types/flooding_level_chart_card_with_background.json new file mode 100644 index 0000000000..c70b9d88f4 --- /dev/null +++ b/application/src/main/data/json/system/widget_types/flooding_level_chart_card_with_background.json @@ -0,0 +1,32 @@ +{ + "fqn": "flooding_level_chart_card_with_background", + "name": "Flooding level chart card with background", + "deprecated": false, + "image": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAMgAAACgCAMAAAB+IdObAAAC/VBMVEUgOk7d398nQFLe39/j5OLX2NoZNEgYMUT09fX4+Pjv8PL39/fx8vT29vbt7/Hx8fLr7fDs7vDq7O/z8/Po6u3m6ezo6+7f4+fi5urh5ejJz9Pk5+rd4eXY3eHg5Ojb4OXP1drV2t/l6OvW3OHN09fY3uPQ1tvb3+PK0NTM0tbR19zd4ufO1NnT2d7L0dXS2N3z8/Xq7O3i4+HHztLHzdEiSsHGzM/i5OLU2+DX29/Fys7s7u/Eyc3N1NnW1tjn6e3e3dzv7/DU2t7T2NzY19jL0tje3t3g397U1dfS09Xk5OLQ0dQsRlkqQlUjOkzq6+ve3+Dg4N/U1NTs7e7h4eAmP1IiPFDk5eQOJzba2drY2dsdNUe+w8gYLT3Dw8NJYXUdOU2vuMEZNEfa3uOqrbAwSV3d29u3u8A4UmYLIzG6v8SmsbsyTGASKjvi5OROZXe8vL0ySFo7OztDXG89U2YXMUMULkAgICC3wMi1vcY/WGzg4eIUKDgQJDOrtsAmQ1kiN0mlrbdbb4A5T2IKIC7IyMlWVlbCx827wsuxu8Pn6OlFX3RLYHG+xM2qs716fX9WbH1EWWszNDUbGxyZnaBUZ3k8VWqgq7Wjp6tidoUgP1TMzdHOz881TmIpPk9MTk/Bxcm3t7h3i5xneYkGHSri4OGbpa/j5eissbWFl6ba3NyzuLyUo7Kmq6+MnKxsfo1acoVfcoM9XnTKy8yep7FPaXsoKSpedoqwsbGSnqqWoah0gpEwQ1RHSEkuLy9Ucsywtbmnp6d8j59yhpdUb4NwcnSztLWdoaSVmJuLlqRpgZQ3WG4xUmgpSF7m5uaZq9ugr7uAk6OPk5UeMkIuVMSgpKiFiYuAgoRPa4BHZXuLjI03NzjV3OvJ0uXByNGFkJ1he45AQUK7xuSaqbd8ipdpa21jZWZdX2BXWVxrhtG/wcIEGSd4kNSPo9nFy9Q6XsYeHh6yv989S10RERHS2OdHaMqIndo7Xseist7HzNY7XsaDmdZgfM+ntt4vVMVrLiMEAAAACHRSTlMQILCvv7+/v1/Muq8AADv9SURBVHjatJlPaCtVFMZHVHCS6qSpPtGH4EL8AyJNEIsNxImvTpJmkUwaCAklUCgVKoSQTVsCQhfJq4W2whMqNKhd1EIVRNpF/dPiQ1rsJrhxU8EiqA9ciNiVO7/vnpl2kjFWRb/M3Hvuncmb85tzztzJq6bddY8VLVZHRkaixegINR7FPj4+MoJxlDK/WZiMVqvVkSKmosXxaLFYLRZHqlVMqpN4apHfgYUvjmM4HhUV7EKhEC2M2/ZWAfuWjbFdSG6ZlrWVtCxzpmTOmObMzEypNIZtDFs8PxYvlWiMQfF4uYwtnY6ny/HMxnPPplIpzMRTcU5TOOfuu8BhwWV4Av/Gx4tROwoi+AazEeWRApxJPfsYjo84nATBFzisAoYohMc/sFPlP1TEGTZIXBTI3lKfJGi20FnJZNI2wWGBZ2bGLJUAQtcJEgdIHpYMMIqPxVPpVDqOPZ3JvHgDJHEhSYMSICBL3aXdTccLcJduRzdmG1WMqyPK7UYU8+h3dnLCB4FByMdhypc4SQ4eAgBm0BZ20Kjvw3m4D5BCkgDJLTZJy7RNMzkTHwOIYMRLM4wAKPL5eIkItMbKqTgYMvA+nU5vZG5spNIZcsUZmTJ4Mouz8fK9Gp2KFtCgwz19LMp7zNs+Dq+YW3K/abFROEXhYWDoOHFUBNwWIgNHQIgm0ah8QkSExbYQFZMIKWtGMPjJM5MYDYaByqNPxQFCFIQjs7GRSoEngwbzZR7IbKQaO+WMxsuxHqruzWTyo+N8lbdb0otjbKQDgeIWSto01IjpqchcFu4FABQsVAcYtpBV7E0IKWVaoLHAAZZ4CU7TedYGw0EitGmJBTCoeBxNO5NJ4wOKfBpsKyuoH01cgssgGVEQUsFwilwYuD5Lg5tfpA12OM36cGxhRScGCUrI2WQhyiBsIQiQagQEzYyj0hhSDEopANR1BgAl7Kkx1gUhmFwEIcQGoRARBAYcGWQdSkZT1Uxn6Q1wlIosD3oYJYkUNNFErBGx0EkgaKDj5qqgPtCWuM5IFCwThknNWGjAwFIfo1gJ+Xg+lcqji8fHSkwqkJThLhJpt7a70RaSNlFAkUqzQp549sYN9BpusHBkjSGR6gew+2VIK7vRfSQhHQ9AaLuVSGBHm6DdpQlpYxOOItw9AzbZieXicjablR2KYDYSmWikUs+W+QwjSDTKsk7o/5mCkGfUT/d7dN/f0JBHw8PO5PLo5CQwUmXNSYOs/v+AUFdy/A0IwfCTDG9MLr6HGklpBQg1OaT/lyRdo34Y/4TEdd+D4hxYrhbTqJQVgNgkMfT/T/1ByECKq+UJhYM0LPPbuWqm/PT6omYXGvxIRP57hivzqr/r3cNhFwRSLXbMDsde3L658vsb85qdswu5QuN/iojrdF+QvwqAQyAdPB8YIIBHRJpI3Xj//cXX9rRcrpHL2f9PRMihfPWSwLw6HgIikt5dEhz/GZEBKpu6Mbu4OrWkNXKNRm7EC7L2/Vt6t8xs7wT2K6Y4Ixh0SUB8dX5FSXgiwqq4DAlMyjACxoNPPvrqa6+9/p2Ws0FCEPdR89b53K3DO7syaLcgs3Vb71a9ctzq8XrORzJn0uv7eE2GpH91CKsfpGs04EgFw6Ggth8fnfrhnTfnNSvX4GeIZalDpV/noFvvijOVObxI6ASRqJgSoHpFz9JQzSWI6YmhFwQRgYIC43taube/W94JNwAQe6F4QCmxPbqw+NvnJ19rttUgiUEMbKW5W7fOvz0/X3ZB0BDk6KB+qpv1g3pbXztsHVZut/R6q1XPZusHB3MCoo6urelrR2brAKjdIFSfxXzIR+J7YNFzRwYVEA4Mn1o929tbnXpNit3KGSxMJtad8/Pd5V9vveWCtFprADmu6+ah2TrVT1u89wQJ1o/1g9u363rbATk60k+PKnXk3e2fdIDiPEUCeQF8HEDtIRlCYXhBwBFIJAKJBxKDENx3ORCh63hmrYwuTAFEKUAMktTOb93Z/f7XO92pdfoTCwO3uYIW5s+MSIUHjsAgIK3Dev0n/RDMR7AAsiOpRI7gX4JAZOm7iBBEeT8YCodjJBAx0R5eXRqdv+mCNBoGLkmQO9/Pnattuiu1Kgd09adT/atWViLigHzVuojI2pGeNfXTOgLTwgRBnAcwmitJelxHSHw1grqIhcOhEDkMipPXp+YXlkanniYIk0uBkGS3JFtPjazVD1WNHJrB03pdUutnHMjW6/WLGmkh236eawcxefiVpJZHfpD+Gu4eyfpBklAoxNwigujB+TeWXpnc+10DhQWQAV4KF/7x+7k5tU33vGpk5akFS5nEVmqbx3XPs0oCIJaTV//8RdHPpcCwAiK7CKJiIRF56fmlpV9WF7COQDsqIjo35XSPiChi0ITYncse1A89qwxdJ4jjeM9i+C9BvEUPEgfEkPzaXlhZWln55SZBLGyG7vrnJ+EBz+iy8+vizUo85c/ECxJ0V4MQHQ3l43BAQgShlSDK8s1JgExOauSwLJs1ItL98iPR9L+qOyBsxBn+qCWJg+cl6fuEEqk1vJuDk1wHJSIB9AzJ9ZXn5peWFhc0xiNn2onujIF1xU8mIl2qJ3uQzkMqixMxBeLKQ9LngSUIziLOY14MAaH/NBARpNf1528+/8ILSwuahXDYOcuNiA8l0sXhIfQmoRAkinBZLksIKF0OCAfmetf2fiBcUuR90BASd5qSFV6W9gA5Etuzzzz66CuPrmi5Hcu07IIPxMHYz9e6UCRwhY5YXo7M8nIFl2Uu8wWb1yvXIvBFQEgicg03AF4QIZMkSjCDhEQwXBTh4GqCzN1uzjZHX599XduxCoiJRMRfJ3lb73TyHSPfqeXz+532ZluvVCrGZg0n1WBtGpHNSidYq1Wy+7ud6VoTl2zXKgO7+xXcstrx9d3j5v3tzazD0YMkfv95jRgPDJJEoQiHl4UVAuGVpZHJZGZXRueRWklweEDu98akaasm27TbwWZH37c3s/vBZjZv46TNYC1byrc7+ibN+yqdYiUxjUtPN3Yim4FmORAotwca1eNs7TK1YPhI/L9xHRBWsycMEguHAyB47YoNxrZ3T05enXxvSiOFnRQQf0jyJb1TUCB5+G/s5/PGBUgNn2S+mQ1WgrX7BcSYxqVy7ePtWqCdViDH1s8A6c4nT3j8khgJCEnov5S4kufVdzAWi4UGt1/dOzv7aPF9LUkQ2+5NLYfF2G9uZu3NioAEm+1KECCYuQApVppNggztVjoKJDDdrA1UmtMBAansE4Tyg3DsBxHJ0ifuPxCLRLCgQ2okBkDCE7HQY2+drb999tmJZjMkPSC6RxEwGRdHDTJCWeyXc7JsLLuVCCOwzbuHfWB5GMtIL0n32EvDpJJ8cuqAjoeuPfjQgxEhwSgcBhX7SDgWevzTjz/Y/fjkEw0Q/K9+f7E7heJX75x4I4mNgCg/JAvYDADEr/7x4LcERRJKgTz40EMPXQsRg2/y166FQzQiYYBcP/nyizfO1j/RTIvJZRlXOux7k3VNd8mS1x9xgggYs+3H4V/W5V4kYvjFISRuZg0iJNfCgy6HGoAjwnf6R6YW109Wzxa1JP8kSZC/L/FdfoS7Tx55o5Ob6RCIhroKWyx+3FUOjefnFTkmnPdbQ8LqoIQGVWxCSCyCoAcIzgy/PLq39/XJumZBMy4IL/O3ONTlL5cCSL1j04ELkOHhbg5x2fmOFEMg4azfHGGMGYIgJCgwCpNsVYELDwiYW+Fw5Jp6ADy8/uGnq1MLZ1xHTPxR1ZD3hz4k3jmDPuHy8IrrXGJIFi1yXIJAnB72PGjp6tBlDonPkYmYykYiKCUGMUkH5X3dmXerhRyACVMSkMEXF1dfW5+a/+UPts02pq0yiuP3o0GQtvb2JX0B2qyNIJIb9QPWgAVUCGoNJOoIwzRMp2LmjH4YTlFMUGkE32bmLFHQZAgii2EmVEzUqTPE6ECN+7AN4saiIzpfotMZNf7/z3luC8zjZi/09t7ze875n3Pu7Z2xGd8c4U9SzrcR5fox/J1VkAM6+9quBwdPPnPBLFzqyoxYhSJjZ5SAkEMbOLi0Ej1gE8OyUu6UlUgWia/q3kICv2WtpQYcNogOCNn4DuNCGrWXdyndh/E3bVAh+NKeIAUrgHyYunDHbMmtA20lbRe2jXSVAmTHaibVVjpQ3FW89eJdq4cyzdbIzKpVtLo6QJA1JAyADjOIQUq/5B0Jh5tmWYmEM5kUPxWcGyQOy+NJSNvAQFW4d8KtizSMgBz8bH6mbvSgsVm+5tYgth7zICMDKYBcn5wtQdNLtW0uubCtqX0MrW+seCv+O1Q8lunKjO1qGZmZycziZJJSNglB9GFFvBIpbqvODH8ttwUUJ9WAxucgXMqCASeRxDSlWrhwkERMA7GINazk3sxmR3uMazj9Nt3ZLhy0dSBtYyNIrYERBVLS1lZS0nbdxYe+6CoeQxffCpwugox3zKzuSoxhySWlZIzXuSWiEDbRE9+n1BkEReJEvUXuIUiWkDFS7U4IRhtBNIkOjIo+Nsazq533jLZmjclJPHvQNJncMJvmQa7/sGS2ZLbpw2QeZKBuh3WoGRhFW4sOTR7KdH0xtr1upm5b61atEJnj6fV5MzjlL3Dcha3CCdUihxSHxTSjTNAAERDhIgfUouVCDFW9FAiCuP2tlfkD27ItTC18Yd/Rvj619K1aDiepkltLUtfh/3wFb2r75MXFX3R8UXQz/ru1ZVcpthKZjKuubraoWEA0iaDofiC/5vGlzpNE5nFWW+wL8cN5Ng6nZUYibsthpYDTzgSU6TFPQqUn+DtYaDmX27u/f5uxeXKyY7KjI1kYfNYLnkm+YcyTNJEwlypfMIVmVg9tp7diogN9TQpjWxHTncTeg8bD0PuAaSWBXup0RwIRMODFTGEuTCgQe3+oxkltARH8RVbLTHbbntzrBjAmm+sKIBtr1/kXQxqkMFUjGaA9LFHe28IOxKWjdpz0F2ZyMav7P2jBEfGHA1YRO0zCHQGH24z4xjNuy0UOOyK21NX05Ua0EvGWO2+erHtj2WjqaMJDIATRtu5WwToQbglH4SqHfZAMvNKhYm2MQvEX3jUy0bcR8r0GH4A+zHFvONJeBI6LEtQ6OfzjEVWK5TjMgaTdGd2R8fEAaDOXLw9e1dwx8JbRNFnXjEeMqJHzTU+253MICZcZepXiuKYbCgTvCa5jEAEJhzalGjZLKzLuD7idpVgXat7lQV75/YGIaiqswrpaJflKkIA/7Pf7vd7BO56de7cze5WxuRmPbtW1JrWfhYhsnJHyd2HVbKvFTBDRipgklFR5aFLYhE78hhEEJVh+tkGYK26EtPQitEL2Q5OeYs1BwoCL4bAFEG8w3h2qTd9y7x0Pvj13wGjCo111iIhedvWyURGFATU/SPFFZb7C0lKUsznEuFkAkaYCIwlsbUXmMdREgh+KEh647kDqYLX9kAhVTQmuB+H7we7axsbGD369fWV+fmXewJOC4GhKXrDeBEISiSNS/osjjaEbtQaTV14sqLEUZrl0D7N3l2mZIESxc7BwLCiMGyy9pgeNxOcNegOQM3oJC7BCAAmRCOKJhOO1jbFYbMfrc/N9OxdeM1rVU2pNjMj5Rg58TIY9XWh07+YPhVlXqhdE6lGGV8tBBoUitYqFgxw04RBdyV6ipiKnxwwwn8gRDJtWvrmL4FFXOPMifKYvGKquBMjYNytzi7m5F42RbAue9Gpq/58vVtffbJVRW0CUL7KZfwPxUAD2iC0rTA/zYzA58n3fvruAzxaqKiROgUtiRawk9wEK+58C4SyWcivQeG11YyVAPnngjnvvePlR4+oZcLQ0py6mrYXItz2JJjdpa9NBNsUlDtaIh0vmbHpo70VwWx9SqnR11v2ZSyWr7jHJYWI9ULF8iAfhCMIw6LJrZjLYiUoPNTRWNjbu+P7ez+97+6G7jHuubm2ua2sRECCI2ctMDq00u/3BJDHyIFQqFMoraC2MQge0TYRhmzjv8nDu5RYV7cBBTMbD48KCo2BZQHDAEhJg5YzLnRn3b/fSSFLd0PDmKzfsP7j33gljZ+cVWTxXl2KjWkeRhIm+xKQ/57OLSLojyu0aT6Ft6LqqJ5HzTaYaS9WnBDBYY7FFEhyHPcSnOCy2b2aqNEWCIFbBYNAb9vn83rJQKNQ9Ord3356P71s0+oY7R2ey2dQa3aq7w3wyz8HlyhuVomUilg+ITKu4piCCUKhmKrmkw5ivExJDXonAadt9EjGwvBxnhkXAwakFCWYxIHbZ1SC+CPYJc6t8sHfwwFT6gNHTM3zPk6OdflFBkkYIXKjBQFLgEJBS4VgfEK4cgg8EMRlxASIqE8snHD+jLgF5Sas46nEmbKrIwkyT+ki44bPftFxaIfZogrrsx+iC+ubzBSK1O3vn04O4ZZres6dncLAnqM4FAhiWKpMJBAIZHk4gaHrWFQqaXXVdHmYAA6IgNIhKLEqMd2hp9CUPom5LqYhLhqmrENG6m2HBzgkzTBAXRJKwQdjxw17EyePiAuCT3qHB9DAfqhle2DeV6+kLOclhwYgxHvZ6OSAQRFu+qxZApFE4tUL0qK6/g2VeUQtQKksZTJHI1aN+gxzUitxrcNNFL5xkQ0xAnQ4TNTjAWPHjUqedLuiHFc2Dw7LWO8LD6aHhdPoqo7evb2piKh1XVVNA0P3jccQv4HaBjsVUAk+SjYYrPHBggTjE50FoStJUAqWgW7MuyQqEEVEmcUHyV5XF42U8L+PrVHPhuFpLB0XCxFZpHBj3+yKq9fIIZcND6YmenjPGVUNP9e7p6w3SVRcwHO2pgDceCsW9LORM8Pz9lw0ofI/hqEeEXQ46KSBSddWbPKSAOLVIdP9hksB4QqVDZIy3bFMoGgptwhIyKiaU7g0HTCK5Cv2VIQn4mIAwhiXUM7zy+uJUv/HUzsGhe55cAojcKuJKBEO1obg/4lGZKUFx0Qok0sbwCSQ4K2ZB6ScOnz18oh6OuuRoFDXidWyNyRhgITX0qmKZfeCI1tKi0dCmsir0iTIgYTHxNg+FNZAqYUn312aWT3yUSx/4IGu8u+9kf+fSzvgaEEYkzuwUp8VnnQda+KQjBYwSEKHDDv97Je3rs4yuiEBC+fuVBTvBTxOEBhQP5RGMRytgDdU1jdUNtaFuhCfaDa174JSqvsV5EBMmGGCqSB/Y15ttCBkrE1DIuTMBLruAyKAjHHltM0/4pzBQu1BkIlS5JL/KqbN5Z09bXGunEAPk6/UgjFR+UVFHMXKEANFQUV1TWV4eq6xpaKiubggJiLR1XetdXAByYCxgnSvv730q2xF60piYml7YuRSrp6sqe+hggHqjg3Yb1xlWMAfLB/qvR+MWs+7+yWD8cPaHP/D6o9ut+xjd9gmCBpGMszF4KeitikcbamqqKyqqK8svvRQojfhBQBhwu0Tqy2C7gMDXxvRSS+e2wX5j+uTJnvTQuQh2UkLQ8mRJXP/FnW5sGkOVQZ9wQDGSWu/Dy+MIw7E/AFTlLkwWzuM6EESgcV0JAQyEIxz2BjHMVlZWV0Rrq2OXgqQS0UFq+epdLL3raqTkI3sLEzR87WWt/Xuncsb0cF9Pf59qiBQJ/6pFgCkn0OYT2CCJHRaKgw74IoqDHUZJ8RhTSlXaH+k3cwtUao8T+MUxWQKYpTGQmwFyEGRTRU0sVtkQDdXWxMBRUxHqjrOFK2dkPhnYhY+PdRFEDk0bHzrzwYvPvbhs5AaXFqan9kXpuijaJRzSyhFLDCvtDC6NICr5aKroctrQj7n8SfddPEYYWz9In5BvCPgWDyqLoI0cGP5oYYA0xspjDElFI0JTGwKGF60dchWSgSd+bnE6nzg1ZppvfUofJWeCj79z/02v3PSVMT10pm9i6kAlcs4Ou5AQpBQgbo4NlpMIdq3i+QWDnZ3Oqq0f4O1vCsSB3PrbRZNC5zyLXJNVcsuIFClg4MeAn9dJsXJFEq2ojapwIFL452CTIfnOsHnX0Rbnp9+NtZq1Xx5p3Ypiohp1cO7GLVu23P2IcfLcub7XcntippKPxEVAVEAJgjtI1Jw4Ak+ojkA9xiGWkTU3BE4DxCWGavsHc8iGAeP7VSfOnv3xuOlDIoX9QKE6YMDApj8YAsilIIluQnuncUpS/wYJM+XojuaLnAB55ug3R0ORT04d8UiCWZY//fT9vz721f3GyaWh6cWefRWmyQnaDoldaGVwVp2WwxxMqRMyF478V/kU2PsaBAd6HyAiSxiO+zciwgoMnuMcqOC+cPikS5uBqk0NlQhJeWO0zItU84KkyuvLznw3k8Wd093f7CCI49SnnlO7TXP3W1+2wiHqLDg0PT/30rsrxkJvLndyIhflSTWKyyZxMDwmQHg+WETLExsYdu3LROGA/wrEQ+PmX7YWeEL8LAagE+EwQahygJDDg27tjVfUgCRWE63yRdggy8qC4cDo6vddo6jzmIEJ4tl96uajEMmRI+YRE4ZjxHrm0/tHd79rLCzkPjo4N1Xj1l2aRiJCKK9UJqnSwrPSzHqPDO02CZUDExA3TUAATTXAvmYsfjx8+ie8/nTMJwYQdCJwEIQiAQlAgj5TQDCgnNp99Jvv0GdYHx3PhIDw6pdYoFDnl60MIyJ3eW6pf3nl6V+NkwtTK3Pz05Uq6WyTduOQNaU7PpmwA2Z9vcwkMpETRcJhg7DtwgjCBeOSk+T44dO/MKbHSfJPQEDkTXVegHTjrgjqVU1tPIzTYRIuw5S069sXnm+VQo/5VC1MPswE8Xovyc0tv33/Y1uMxanFgyu5qahLJTMhaCoiLjJEiKJAoBT8Xpm6zy8gqkutB6kXEJ4IhjWXrqP0/Qv2+TugSAgm2qNP3k1ILRj7uZd3QwnicWw/1YKcQCqzjQcEXTgwoAAkHJtfmXvvqy23GROLHx1cXpnv1qoECPxQq055wDQJs4APHNiJp0DU8GKPxlT0lXolKHaWtzDocTSSiAeRv5BbARuDJr/2iUZi0gnjm3BboazK5+ajGjwgzswRWYEICUB42RsO9ez/5JWHtzxs7N/72mJuea5CIkI3AWLK0KkG5kg9FoznozB4XVtfrzQiYheBiLZOE0TUjvL7O2dTnpiZo1dRysDXFB2OHFBG14hcFqqu4YCF8gsQNpIqf71c0Uk19VCsUnFgCgTKje558bFHHgHIf1Sb3YtMcRjH5y9wZZixZ87YlzE4lhvJS9razYW85EbJciGkTcoFhWYVRhKKK0mkY5PJdNpEXotmpMzNtHFBGWRvbKxttSJSvt/n+/t5edQ4zYz9/T7neb7P8/yes67GleqRhV0h1jCt26rQMy8NQNLRmYNyAKhAXM9ChcidVhB1/QLadm1M2mHQz9gOQdpUPqAS5RCswvNhrhOnEXpiZmDJN0SxUkEDjbpUUZM/TRBE/PzKl9LgYKk/VU+Sw4fPHMhhIWyQpvs/nVe2ulKyWjdlMlOQf0ast4j7nUK20Jpii6JMbY+e6KtourX8QPyKQJWFM6MgQvRBVtxUxJzLnCJjEFiTo7Y/LRBSU3lwCZPbm3Ol8kCpVEpVKpXRZDRZaSFLEmqkA1DqsbG4tqxWQzXGzLU77pjYAz9FzLGWtZq4YpaiNCmVcfb1HLVY9ziGdDY5Od4ab86M8vkIN36GraueJaP9s7WU9nxnpI7iyl1kMYLwQNYWFm9sLQ0ODZbLqWotjq/WaqtACxRuHxrAZvCqaGAbhfj5r1TSCTobqg3kHYUxbTVxxSQ7QWUWPj36xPPGFPzwowXlTX1jYwm2icnxiV+fvlvZ88mQwWwydsMf9eN/QRSRx1d3PN31eNcO5bridQRWGX9SlXqj0QCI63rkCXqFKCp8koYErXM4w4/YIDEOYsAB760H+Tn2gkAs21TNT+ZuuARpV5+M8V9MZFpj2WYTIFEW/ad3Lw8qPBv4hyYMaX+QYw68sQQg6V2Zux17N6RBFmy/vhXuoEfi+E69HldWZtWIwCd0M0lwpQbX5Oyrvm3dSp3PSKqYZtyv7Gc2BMkYtYJzbBQRSfY1Yv88kRVIwPEP754/BP35fxX/PW7gmrgfzOYA2dt2Pb13g0byN56XBssDAKnU4npcT+Zk1YmauH3gsHsGBsIXppRG60GwhDCSWI3RoYIvk1/VT41LzJO4bGVDiDhouk9+RmRvmwhbY2GzGUXRzKxpmJnGqc+fK+1V+Z3sWY3v1mxOX+w4nr4YhAEeIS7b9RAiGRgCCKyeeBB42SvZOZUiM/GIwR9OZ8K4BVyDSGnU/mr9ajbfg01wrcnXTE15arr1HZ8w2VI16IGnwqkp7g3GdthE7k08dl5TQPDRDqBDpS3uIixiXNHbe+LD5a39+zeVU0mSVEeryWcHoiRlqZt/MYq4U5dYyKQzNn8qlucl76nh2N6V6WFWJvQFeiTCK6Xtvg0CB+GScIRFjERulxwdCDmgEANxHODCs1DYlnv71l8+evp5amSkevBgdXRVmOVN6XEDfO9Ti8xAsz+kMestMsSgYR/cAysBN82PwKkhIJ/ZeI6ABPZStJmonTfEQXKEOj/gNE7Rq2YPRhBKFG+p1aWeaNJ5bx+GLSfOX7qMk1U51Yi3jcb3qotCJxBKjTdC3WBPGzi4ehT6poIgkUovLTBMmTDwM3gLVfXsu3lZ0YxOCWXiCFHTOV4MOGmwMZEEumKF2gdKxHRl7u5hIqJ/glzvfBzETh7auXZd/8DH1LuR0aQex7PJIbX53/GUQzDfsGV4x9p8CebWQCK/YF8mdKKwGvPsD20y2hRXRHAYBhTIFzJwFHPL2tuX5ophB3sYbPrf8axLWpIq0iSFyk3geVXvnK6urvPrNq7v32MgSS3ZnaxkLpXO6BKnMZTOoNDZ3t3NXi6PkTIdj7SHbdmOvFtMr6HSntrNNHUgLVngOIxAOvkXBDvCAphicUrL8ShN+xAGeDTz55GO+R4gnFbk+hbMmzvr1p5Ne0rloaFUfWQkHqnt7sS9VKnwoyhLeRlMALtxSsAQ0C+EJhTRBpNXvDnxSyI68xiIJ3HyYD9FeqmcDuEKi7rpkUgDUj8AIQhzjsLLEiYxpvu2f1lf19zFS+6Xy0MfYSiI1Urt2J1FUBF5/7YE8B8d2GlTGpDgwJNxIIhqkQBFZldGYkKB0EOB0CKv8yjE2wThZ07tcPnS7kXtHMEHcLl2YAGmEbhAbNKcdq1gB0Eigsxasvz+R3IM9adqjVoyEtcWZHy/6cZozFDm9j4oCgceuCSftdDqwPuK+6I3H2bKpzQh8JVGnQgEVd4iS3wRvkGQXgSuZT/VRd4u9coCmQYOnYhg7ANZVYqdBFly/yM51t9ONe7cedIY3b2Uy1pBVEuYtmqRxyIcKpOkeyme/eBnIEBN7jAegGgFRT/jTPt3MWUoXvHKfVSN6g/fAkmUhwiX4omIyl0a5k4QrM3GoXLmWzs7NyGb5nN9XQtnzbpf3lTaM7D/WGq4MTx889WTA7yp1lHzuz1WfoKggPCdw7nZbIJsj7LMfiyLuLHkwFMMpTRiCUbyJ4eR6dJKCWnNFyqdSn0RQTrBIV+yblNmVDZICCKByCH6NWw1LAGy1oKuBUcuHzt3em15U6rxbvjJoZeNM4UCgzQDahuJhmwrCrn2RRw2MbioEY0f7AvcBznoD8chHXBv4tA+YbySkEgpEJYPfY5VCugcNXCy9tMd5qkXgdip1HpYmoG0EQS/wdF+4OyDt0fXAWT43ctXp97FbyRGFFfQW18JslwnH7xgJIAK2l4gB0KPWVkg5CgwYmDmn+1k8iDeRQDm23zTsIyE+zaNWMyRw83riCgSgSBrKdZpWJtGneqXanpz2xc/O3/twrGtg7+ZNJfWJqIwDOdfqMExCZOYpNpxYQiZ0iBEAi7UnSKoeGklJSoiXlBR62VRpUpkCloLGqkuFO8Bk4Uooq2KiVADGmNBLNoYXIg/wff9vjPoC2bizHTOeea7zpkEaoiRSm3yK4MN12NGYDCrz9iZHEigFeRgPRSLrILFiMpTxF1AJeEiXkaP0vAGSYgHmJIW+GXekBBkmVqOHDQFOShd1tMEpjIdGE0hrs21ChsNSs4KJXef//5jaPOtwCO4Vvvb5G8MTpP/elEgR9wS2S5MAqEeYt0PHBCjXRwjhqMoY5gFHJHT5ZtMWuhfX8UtcW2C4K80cAhCKgXhwGIDoBgKSGsfAIx0/UNihcSwRw8CZLU9kJjZPXN134atgal2ZfRz7clFU20LN1y23TEoDpewM0LS68akQ6E4Hjm04nM5DddVqohr2wwZoTAgcQWh2/4PQniaTjl4acosdhkYhoUvVA/NmFqiQnZP1EkkwysiFz88uPPo8vvtgXq70ajcewcQySip1bctjh5e6nJDEJDkMhZnQvtrB0WbkZHraXFMF484mQxJgBIjQ2wgNgAgBbEsgvi+BV+UkKBTQXRov/Nn+8zPf+soEP3ArKDIMTpyLNiXXrkyEV2+dMelm4+uDW/cGABHfWryZV7zy+J0qBCOYyrjL/qRUAiCKKFryVS0FC7GiWIQXVFz6YOQG6F4pgQGw8X/hq+cPkEYGchO7Bo0I8tDhj7oGC2CsEm1XueUR++f4ItZQ3H79vj4ypVBB+l36NjQ8M7tsEhjaHRb7dtv9etY8EUxxnHvc7ZxCyCcL5vGASYesskMcSgCRkLmxBCE0e4SZc7EPklilD4HQNq5wLbyKyXeMZLoyxLTE2ArQZSenav+qZZb479gBPNnlGRUd0XfeDCYSEbDJ69d23ho74YNgUq93h59dyev7kzJyEtDEBzfVZPoUib3YPKwAXMzj6kyrvgTqg7f/iGbLtOUpnEWYx5Wx/RJxEuQIYhoHhplvzY3Ejjp2dbiZcXxVnkWNNMf/aStIJbb6/Q7ThQvf49uO3B976adsEil8fnbhzt5eouE5X+yxFvgQMi/mD68J4ep4nsGJMhSNkR0pleYIcbfryJRh4wxM9iv1uBc6T4LpV/BfxgKSBE0CVG0ESCP/9RWnG3xRLqT++JLd7ba+ahlhqWa9Y1JC+/pBkZuXtiPTv5QoF1pIPu+/E2vsXRoTo1yxa2IwYoI/1q9Wotjb0RAYAgLIe0/9aEf5RtmUGIPxwI7IwXHZEKm7ZFlUVn6Vd8iCcNTQVheoEK1BWaNC2mIbs9Xq/Pj+CPgi8PLUFZowdKXj9dtPTT8MND+XKnVHrz6ugSkTDAQGVxSoD2htNnilmIjTN+y6VM2QEDB3A0QXJ0NP3bbaM1pRbGVaUuWwALqbFrKuW4t4gUMHljZ0JBDq7wBYXIbn6/Ozr8Gh/gJo5PFrfdD7fLhtWcAMlWpTz14lafR6BA2PV/PBACFzyw+w9hyIxZ509mCEyRlDYT8+mZFAC6ul8NBeWs+2O12pltf3vZLUyXeBrHQA+S/UoKZSoLWJ51CtbTMB/HPk+wGFq8zKDkFHy67v/DLh3t2jn47GKhUKu13M5N5TYiaVHupHvSWyWQyKiKJwZJO2PO8prjZihxqJUEwBZsRJI1AL76Fwz1byn+mS51OuVydiyL66WwgYWDFlzHlMsLpPv5izBJtKe5WS6TSPKzhDTzthUJvu2Ne5z5AcA/j2JV/OoQfMK/bQJDPU99nspJHQjE0Vz0Uel6UzkTCySfzShI2Wp7NLm95fU1vrqhtcQZVX+bgRgiBVTPURjzG9M2PlfulCwlFva5NxyaHBRe3uWTC5tTvEwHyseyrWmLRon1U5BCnhNehUXWaYNnC+IvDnhe3bdy0ff36rYHG+3qlPnNuKS+H9Qz6tsQCzJEIMlUbmwBEoyQbzRe8L9Fo4edYKZuNZsM9LsbVEpnDLYf72Aj1VKlaHiShvPYY8aZdHrEkGdIkC1hKzO8eCNLvdVolVdO2CELpA4F57lG3ZLoMNl3X1LMjl/eeOL5pz7rA8PBQ/fO9k7ZxYkY4bno0mnQSQdTOhJOkxCQ+SPKnJzu/eF4BR8KrI7aZn1JYGLbpeW/gQGYhhWnoE48wx2mWh2+xCmqbiOXQuS5zNoZndrfjBJGOkhzMoyZ2CSPfACKpc8fwwf2n9g9dDkxs316p1959tWh7/GSKUcrYIEcqhS5AlKRJKIIUxgpJ0cj82PwI0vkKcRrIMhV1EO4RtOMwFCmo0Ns/Be1EFVmeCrRpF4u0ZvvFphJlORzWxlhB/E4cseeaqiBlzUZuPX147/prlyeGAhMTw5XRemMHHgVZL/CP99y5UaQKRV9boBsQt8+7W3zdf/68hf0jIyP9fWlwk33l4LPqdDGdCsKcDDNsqY53l4dxFoWGL7xmTRj/oOXRt2ODDs5M9Y2I0qmEuX9QMpgSpfv6OQo3HC8ZoWV6rxw+fHbt9m33AsMT7xvtdn0mq8Idz+c5PB2LA+oscF0TLPSogmwduF0+Xxr7WeyhWO6p5PSf7g3L7xlpAeynymUmdw0UeRqltP/qmy2xUDJExSQZy1QnzVkDFiWdeMQvb6xS1JHJO8f2TJ28F9i1drSBfmsmDzn8MBziWWkFMTfVEY+767Xki8MdcLjinNfk6AqSZIxro0gM0yeIHG/adrWKcpqYJCWt/VyXNdGA4Fo4Rfsz9rtaqSGCsNUAiBYBNHnuxalto+9qr/bAtSr1RqOxO+84AoAP5QBIGiC0MaAg5DDunvaC5gSAZMMgaHrlIus5jPC26gGDkqcqYChHBrLvVpuYS86AgIQYnH8JAaKddURApENVED3FL9TE6MEZ5teC7JHO7ZuYmPxQG/1Ltvm1Ng1GYTyfIyhWjLWZaXoxKa64m47eqXcrBQvWWOla9cI/LSJoUMQpipN16CjIdiFjUooi6oXg6IWygRuI0CJeCII4wRs/gs/zvIlVPLq0Zm+S88v5857zJjJGtjafb32QvpRYTfuAQGgHOK+EON32hkZpoOvhvqTTje/tuTRAGOOikGNpgQQhSRKTZ4avyiie4Vv7KMzN6vzXf62yHmPyjztrPm7XwqQWkFXPyh6ZeJITCDgAElYe3O08ssKtrTCsdB4y1iL5YxCAcCLx+Z1CmO1t8EA00HcAwmSCbFvuAcONen2QAISFAvMxtYBJJg6+mx/X5A5U0MAKGHGwPD/HsdCWKwQSjqFJKDGufgkGeJ58iyC4zK3rF4/MTD99acEgnaASPiSGUTAyyPqbSG5uiMPIsN03eUdD1RGoISl/b7d/lPeMhGugqO/yqoB3Msjx1/76PeaYQKdm+sylJTTLUpUYEtDqBDsUS1ELwtQsjjR5AJLhexJfvl2oBK23n6wgCDe3Njc/2HGW8mECGqQ/lHz+vL22tt3P5nLZHEDW3sWmUUZzCQJdId2e5hIoTH+e2Ck1NXEpUoyHlV8N8W+BwGaaOObml/dFqwOMczlP3MfB/9i7iETxQwGnifYMPTD94U5Q7BTvWEEn7CBtPQQGNRxHGzzpyrOgO3fgF8M37TfDHOXdGnbGAhKCQOmT0gSWAYd8iCAsFMRBibaIh6pSmXIwORbbPXxXulJWNZJhSchCmPMmF5s168ck4DDRjlGFJ2GlGLRmrCAMAgTJCjmgZKNXG0s4Kbv/h0T7+z/W1n70c/1XQ3KYfVjHgEV4SXgBLsQ4gMdESxBQk3sYLaNsjI+5+dloYYUBnG7Mz+EoAMXtjmAyUUY4iWcmrGZRlwtk1CA5diOhueTS8ZlTnaAYWMWwWOkUgxdUDfPmujMYSzqp1AIylZTlfgnN8uY89yA4OM0SxEkyw8Qg8i0mF+1U2W4KF3EY2bH0tRpLr9dbWoJrqlCNOh6RKEZMCxY1LvJCDPMkKFwP9czga1tnwjOdStFCrJ+ZPtpcgWaQ7IJbzXpuKrWx3k9RW/yBcAOzbK/1c3QoxJBA6FkmCvbJtTAnou5VtKpJ5B0jHkHk8dwm5tsjQT1ODBCwKlWLwChWSSiHjLoQts7CBQPFXV/osZb1vJV6KZh5NnMYJcr0kcpZWEQguQW7dwB6IlISrp09NBKxyNeYDgAJJN/DNRUUe0jAKYIgJlqjF+IEtfdvUTRpeQaM6r49lBNQihUpSJRXlR5Iw4ymqli5FxyuygofP9y6K6V6vTUddKyg2WqWWsWHOQMy6H+0IZjp4GD/gagwxDSIQg5EcKxMfrcmXKmk/I8cKjdXiow6X9NOGS9DOsgbAm7AlElOsqooTCZUsPITq5eMIwqsjVXMKcTPn3o2NRLgrNTxKkqrWbHq9Xqp1WquGBBE+yGEAHRNyCL/kCg+wOHAB3ybKWuK2tDHaQHjSXzEBQEEtxSSQPLqtHVr9cUcCg6n4LMT9cbSeRgHFsmge2buhkxAYGMPXqR2yBmVS9BSFgmKZ1vHHly28GJNHdZ5LQ5mIlul7qQH98G+2b9BVEPylOznfdfTHEJTQJQ+QZKmMmrx45aSJKCQx2Xkb9qxG00xw8PcY99NoOLIj5m3ylXe0HjiTScdaMQzQinNElTEVtEKEET7o81PVukx5MYNgUBT6OmhiYKeykz/CCh5LAtFxSezCwtQKC8NoTM/2Qg4jsJW4QsS7Y4XlURCUfCCA1UeXAv679xNEC0CMN+qRFOB5bkstCOt5BkiYb9yGp3h1ub999bjn48prw2H7+GqWIajPXiIAEYGsXkoLaLJiwoybHkxoZlfeOIAAaTA7x7H8mtBT1Uh2sjj1eUUwOEk88hzSQ8gMIjKKxXulCmYDYJNKgZRXeHjMidmHmBOL4YWIASiG+57U8xCdNyUqt/YKAp0xjmUMysq/CEKAlcgvLvQGB8cQXEKDpIRmq9JZn46kFtg1c9mmiKfQrWGAzFwEn7J/OUk0liuikBM+OURdpHhRtM04kQH3z5+OQzPXD4CEIT7DYBAUXIo8eHhOg+M3UuHmjrMie8ifjwI8xbNIQDccH4wRMCBgcZraBb1CGhv2d4LxOMuFmvwADijrJUArpPYvXf/XwWvyeR0EZuiEIlKVnURt4+f6jSnw2MWQ71UKhHEdpD4kOdFkkzEPimMKE0UqF3cM7Knxqm4IEzFQEYFFR6CiHNk1JrRoAiEPQKhzjYEmS/NxKVbRHAnObHPVO5IuzCFAjFNkBGHkpYBmbr64DDUbzUtYJw9C5AcQTJ7uvvU1ukp6LgDD+Oh8ke/VlXiXrZNodxYHbdXfdmF9pETe5ywCmYNRiJiGxu2zaxoULPkEUZ/QHyPUYXhYqbRxpiz9CzV/Hcr2Jw+p1OO1hF0fkb01U6z/hgvNTL9luBbAnHHDi6g5txddvZman5ysTHmQe+GvVybdd3a6qJd66aWP5YPdLvQqzssH1iAsx3ozvrZbjnr12qEwb01BpAbRzKubpNa5+EnSGWeWf/DALgokOQq2AKE633mYTeSmKccOUWnc2VYgURrI2qH7p0Kzt64gheYYReAwCJZxHoiDZBdq7nBrsFyzwVIYnYxteBu1NbtXnew2FhcXWxslKuDXjWb7Q42AGKnsMcedAe11UG1KjeKrycSqggogmAG9ZS4HUc2Ex9GcDT9XsfYKEPjJbIJTCCuYscbZa1xYxGdmPP2vePnjhw+fGRaIIyR33SbMWvbQBTH9TlEoS5tHRPSLA4mDcpS0y14iwjIoUZxUZtYlA6noUtcOuQLCCI6hExGYLyUTJmyyVCyJPj79P/e/y5nAv1DEiuSTvrde3fv3ZMlvgeTlMgOsrvyxXV9+rrubLaixZtmq2nPs2Y7q4ZNVe6UvbJcLnZ25vViUeI+6uohfOjUWdntgotWX7MHURRLEx91EoiwVA8iCXu5r3VwxHmNH5D1W2w6EGlVo/NZfDgYDA5HQZ5/hUkURNLyJV7Wajaal9nb1XYdbrb3qv1lu4SXNRdZVd8Ny+6yWw2jYRhmdbgsO53ecm8JkCqrTrHT33xI6xDLgiCh2qdLiQhA2SGsy2dNH2Ui55xrc0SZ9DVDYRfp5CFEN0f5sXnMiyA/zotpamZsa3sxrttZnW2E4+xdVKGxelG3ynG9Fa3GWW81nnfG895qgTFzMXwTzXGRu9W4c900WVRV0RMIMBBGILoQJbMeborb1hT840B4ps5+nKFVOIdwLTWJHU+2bjDLjx8TkwyCIk+KOD26pZFhWfgo/FOTWG0NLTSYjSDMUKzLt0W2LKMzLdwrWq9cSL9KMLEgFsVXmmgRlf+gFIqxuYmHfMxfKF6UICTBWdSsKB7hWyYY/T6fTOJkZuu2SoKgJRmH3rsQIN9gHBf18TxKJS84I4YAxc+2qpC1u31g+10KQnHbah1T41Kfy0oED4fiOdic90wY9LYoinT65Udg8rQwuZkBkq191BiHkxAPJCbjB/4JCGbfWnHTwggu9oEXY/tPwU/kBin2eJJntF4MsMDQNdUGv9KmkVM6w3OI9V2EJ0jvNi+K0a9P34LCAATrEdek1kF5cy7BQLbESisRNPYTo896hhxrKXAlSuOibj27bx7H/xKeQse3+69Yl+ND//cgEfeEd3sQQbFWca5l4oPz+8CMRmmapDcs+vpivr8HjFBYhOs8W8vd1aWEpeBQUNk0zOuJiyz4zaPE2Hbf2jAAx4nWF5UDa2cmSsxPxYcppj8hNTNJnqZxHBwCxCTmUuKNPUwefdrDnZu0CGItgVSX/SOSUSSfLAWrHB7HA3lWJ4fg3EfemebDCMw2trhCCFsDEibL41r8ObiaJokxwcH550kcjy5bEA8X6eFIN9T8cBPJcndtaV8911FywUMocrAVaeB/QkdR3OAmztMBcqLflBS31aKjr9k5KDs1Q3q5s8n3K7BMg/s/f/8RbfU4jsJQOFeZE2y9xd6ATAfNFB5WioREJDQyBVAwE1NsEASZwkQU2WJ8APBoUDTKVptUWW2fdDnDnGA/86P9pIDlPL/3fbJJ/J7MW0XJb4z7MuQVk6lmN7GFkDukz70MqJgeYS0SFP7T7jOnnoLW8q3H8AXMBjs0xyETho6hUDrUwCFDA27gDKw0Md3R69HAbcThyUh+4o32WUaz7NLt2+IO+Nqv/bHop1fINCU6kdAZdJ9kDxM1/XtN8zgJQQ0B0G60h4nomD2Oa37CqAGAfOxKUGkYCkugDB0AnI0/9neD20EcdA0bGbc05r8+y88nnDI9ZV13atXHZr0OAzsM08ItijiNcXPd1Xb1/r5dufZ6HazTME2LYrtFDz64rGBip6kdx7G7XQGum8ZxkIbrwI6LotA96IM/OAwD+E9tIIxxi+3YdTEOkew0DHVwXIJAW8WFnaIFcxDaBCFiAz82m00YYiQihggCgw8laJLQMi9nr+fTlXTn82tzPLa3/Y2cPJKJLvOjaLeYG3MLD5BpOF0ta3XJSNftnk3r4eFeA/tOv/SkYL6jbR+/W8bSeXNoRbpLV1XGM8YbS2PpJzTbnxu8AlXfBBOcS+YxTml2/XP1PK9jqm4OB8lk3aimkTXj6JUs9/Y1ZzVXtWS13Ivm0CihPCE8j4MI2cvjsWE5p1wINmuj3d+lQy6nG85kt/0JRzjhbRs5u7kJztbjo7VcEI+xPIsi6lSG+WJZLw+mOTeShe8T1okESp7M+/miojTaVcsqqkilj1b4ieM4NPJyobnKQy2VUjWDGiUEycgFhC6CcSUBKGDy2DQHxXOOds4IIR4ticgFJ4iNAXme+2XuU8cTUkmYKqhGo5kZ/1qwYlW3YSga3tD+3L3aZALC2BgEDigYIecNxuaJ6G32EA8J5IH9C00LoYvHt2by0m79hn5Bj0JvsIjsSPecc49i2VHIN/P44e5VNZbGPPrP++12vwMy55A9z3OpWYexDpjMWLuwFzNJTRzqMYShcQ3QDsFOdTO6sbz0GYAPfda7qhoqBzC379fr9VvU9nSuMkBzbnDQANfOx6o6/vz8czweUQkojx9WWRmiZJemvIxExhAFShJi5LRkrTXahBr8UZzhdATp6w33kUNRQHT5Vj4eCb5+aAjlendxUJmZSEgGeKuDradgUSQJIsx2XhaLSvRTINK2pNA05/MwuObXDXGKAUZD1oPT6Y7eONZDVl8WskSQxpRTKOus6h0oj/UIodEO1dBooEaaXDI8IWAKobD/2KdpqhDCz7NkrWsMMZOGvmM1us1XFnEVJEUuP3SuVJJw+dtB4qaBIkQECy2MgWSI0RMC90/v/YxiLdZSPKWEwnA9NfUZWODv7BNkqns2unqaaJom08MSYbH4LLOPEwhJZAPq3KDMExlO9KSZ61GTKrAR3Efc+3VV6fY13SOe70jiyRbHCmfPixDe5wXzpOllsyFtAIYlZoLNovXL8jIZil43GgWYF2i/CJUUgiHN/5m8gDYLMwRbY1pVKNTbEnOAAA4Lvq6DQZeVSJhsZCCW2c7eK7+qQiIogIm7NBrlnQVS+ZjhFZh33a7rdtsubfHU975DtNuu67Zo0e/a/RMDmOJpKhpKbhAvHOVmzTL5gMfE889G62gYmSQCmb0Q87rGociC+do2zqNS9VxC/oBN5+EAXtADGgE4TMycKBhWiHjFF154EQkIZs9CALWRCWsb/dEEy4Ll35kJGr/uWyDGEdt2F3m8I+U23baA0Hbod20KJgABQngHdFBfNpt/5LnLdSEonr4AAAAASUVORK5CYII=", + "description": "Displays a flooding level data as a combination of the latest and aggregated values with background. Optionally may display the corresponding historical values as a simplified chart.", + "descriptor": { + "type": "timeseries", + "sizeX": 4.5, + "sizeY": 3.5, + "resources": [], + "templateHtml": "\n\n", + "templateCss": ".legend {\n font-size: 13px;\n line-height: 10px;\n}\n\n.legend table { \n border-spacing: 0px;\n border-collapse: separate;\n}\n\n.mouse-events .flot-overlay {\n cursor: crosshair; \n}\n\n", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onDataUpdated();\n};\n\nself.onLatestDataUpdated = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onLatestDataUpdated();\n}\n\nself.onResize = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onResize();\n}\n\nself.onEditModeChanged = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onEditModeChanged();\n}\n\nself.onDestroy = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onDestroy();\n}\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '400px',\n previewHeight: '300px',\n embedTitlePanel: true,\n hasAdditionalLatestDataKeys: true,\n defaultDataKeysFunction: function() {\n return [\n { name: 'flooding', label: 'Flooding level', type: 'timeseries', color: 'rgba(0, 0, 0, 0.87)', units: 'm', decimals: 1 }\n ];\n },\n defaultLatestDataKeysFunction: function(configComponent, configData) {\n return configComponent.createDefaultAggregatedValueLatestDataKeys(configData, 'flooding', 'm', 1);\n }\n };\n}\n", + "settingsSchema": "{}", + "dataKeySettingsSchema": "{}", + "latestDataKeySettingsSchema": "{}", + "settingsDirective": "tb-aggregated-value-card-widget-settings", + "dataKeySettingsDirective": "", + "latestDataKeySettingsDirective": "tb-aggregated-value-card-key-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-aggregated-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"Main building\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Flooding level\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{\"showLines\":true,\"fillLines\":true,\"showPoints\":false},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 2 - 1;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 5) {\\n\\tvalue = 5;\\n}\\nreturn value;\\n\",\"aggregationType\":null,\"units\":\"m\",\"decimals\":1,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"#4caf50\",\"settings\":{\"position\":\"center\",\"font\":{\"size\":52,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"1\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":1,\"color\":\"#224AC2\"},{\"from\":1,\"to\":3,\"color\":\"#F77410\"},{\"from\":3,\"to\":null,\"color\":\"#DE2343\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.9408410830697858,\"funcBody\":\"var value = prevValue + Math.random() * 2 - 1;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 5) {\\n\\tvalue = 5;\\n}\\nreturn value;\\n\",\"aggregationType\":null,\"units\":\"m\",\"decimals\":1,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta percent\",\"color\":\"#f44336\",\"settings\":{\"position\":\"rightTop\",\"font\":{\"size\":14,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"20px\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[{\"from\":null,\"to\":0,\"color\":\"#198038\"},{\"from\":0,\"to\":0,\"color\":\"rgba(0, 0, 0, 0.87)\"},{\"from\":0,\"to\":null,\"color\":\"#D12730\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":true},\"_hash\":0.06392321853157967,\"funcBody\":\"var value = prevValue + Math.random() * 6 - 3;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < -25) {\\n\\tvalue = -25;\\n} else if (value > 25) {\\n\\tvalue = 25;\\n} \\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta absolute\",\"color\":\"#607d8b\",\"settings\":{\"position\":\"rightBottom\",\"font\":{\"size\":11,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.44695098620509865,\"funcBody\":\"var value = prevValue + Math.random() * 1 - 0.5;\\nif (value < -1.5) {\\n\\tvalue = -1.5;\\n} else if (value > 1.5) {\\n\\tvalue = 1.5;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"m\",\"decimals\":1,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1691927717318,\"endTimeMs\":1692014117318},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"stack\":false,\"fontSize\":10,\"fontColor\":\"#545454\",\"showTooltip\":true,\"tooltipIndividual\":false,\"tooltipCumulative\":false,\"hideZeros\":false,\"grid\":{\"verticalLines\":true,\"horizontalLines\":true,\"outlineWidth\":1,\"color\":\"#545454\",\"backgroundColor\":null,\"tickColor\":\"#DDDDDD\"},\"xaxis\":{\"title\":null,\"showLabels\":true,\"color\":\"#545454\"},\"yaxis\":{\"min\":null,\"max\":null,\"title\":null,\"showLabels\":true,\"color\":\"#545454\",\"tickSize\":null,\"tickDecimals\":0,\"ticksFormatter\":\"\"},\"shadowSize\":4,\"smoothLines\":false,\"comparisonEnabled\":false,\"xaxisSecond\":{\"axisPosition\":\"top\",\"title\":null,\"showLabels\":true},\"showLegend\":true,\"legendConfig\":{\"direction\":\"column\",\"position\":\"bottom\",\"sortDataKeys\":false,\"showMin\":false,\"showMax\":false,\"showAvg\":true,\"showTotal\":false,\"showLatest\":false},\"customLegendEnabled\":false,\"showSubtitle\":true,\"subtitle\":\"${entityName}\",\"subtitleFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"subtitleColor\":\"rgba(0, 0, 0, 0.38)\",\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"dateColor\":\"rgba(0, 0, 0, 0.38)\",\"showChart\":true,\"chartColor\":\"rgba(0, 0, 0, 0.87)\",\"background\":{\"type\":\"image\",\"imageBase64\":\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAU8AAAELCAMAAABu2vS6AAADAFBMVEXh4d/j4+Hh4uPf397V1dbX19jR0tXd3Nvf4ODa2drT1Nbk5OPe3tzb29vT0tTP0NMKIjEIHyzAxMwNJDPU1tghO0/a2Ni4vscnQVURKzwjPlK9wcovSl7Cxs4aM0XZ2tzKzdRccYWvt8EcOEsSLkC0vcestb8FHCm5wMknQ1jGytG2u8QXL0Cnr7wdNkiyucJugJEVMUQPKTkMJjYdOk4hOUtJY3fHzNMrRVozTF+8w82ZpbGqs7zW2NorRFdAWW86VGh+j57c3d+XobCcqrhrfI0rR10vR1tidYpwgpY7VWxAV2yvucQZNknNztFNZHvEyNFecoh+i5tBXHI3UGfj5OVyhpmhrrxFX3QnP1KDkaFRZ302UGRqfJJ2iJuUoK0iQFastsPO0diksL0zTmTP1No8WG4vTGK2v8mHlKS5wcyTorFheI15i5p4i54RJzeQn69JX3JYbIMWLDzMz9aNmaqmr7mbprVOZXiqssAXM0eirbiRnqxneI6gqrg2VGrEyM5FXG9Ta4F3h5dXcIaWpLQePVJNYXWImapZbH5rgZSCkqRddoqgp7WcqbRTa31zhZU0TGKHl6ZneInKzNFIX3e+xs+8wMeiqrVzgpKQm6k7UWWLnauKlqdic4Vle4zS192mssBacIFNaH2OnKyepLFUb4LExsqyucbS1NtkfJDIyM05TmGElqdEYng/VGcyUWfLy86BjqFZdIhPaoDV2d5JZnzQz9GwtL3Iz9YlRluxvMV6jqCElaLAyNBTZ3iMmqVBX3aLlaPo6uvDy9PAwssnPE7X2+DM0dWYp7YqSmBngJE8XHLBw8eytcG2uMF9kaN2gpekqrm6vcJthZdfb4BFWWwuTmTk5+iVm61XZ37c4OSHkqAzSFp+i583Vm3s7u18h5atr7zf5OaaoazZ3uKDkJuRlqbZ1dRheIantsEtQlLL0tm+vsV8hptFWnRye5Gpq7aWnqaGjqEhM0OyurqssrZoc4p2i5Wjq66TpKyIiZ1VXm9zfIVQVFtra20X2oJ2AAEHOklEQVR42myZsY/jRBTGncnYsSeJLZ1GoUAoJyp0FJQU4GZrZNH4H0DahhpR8w/QRdBQXIOiU6otVqFHiDRwEtssugYdWolmiysAQcX3vW8yvpV49ryZsZ27yy/fe2/GVyyXs+VstlyOMBsXM3ToaZjDOE3m3MzM8YHir1dv/PWq1FNyqecTI4zz0QxdfkbXNNNfpL8UhxwvLIsZDthsNmdHhwvzGqMZWl3UmNQ4YbidbYHTbL2Yoy2addM0m0WzoZWbEg7WNGXpvS/ZYdr6BsMeB2wbexxlxLntfaiqYbi8vIyYl70vfdgGPtf35Xbbb/s+wtlnOS2W4savKLIgygEtsc7A3DjLmMelK6669z8eMR0z9odYHZ7SxVGmO/ZrkTAHtVCPdrnAvCBNAjaAczLNNgM74Zwb0RnwogdYgKwXhrMmTrZm1SwaEF0DZ0OSJVg2DYE15aYxjp5Q2Yh0G2Oway1cjLxJq6ru2eX19XVfRjINeDjisdijYwPFpidgHE0hKepraihmRVmnOwJCaJClmRTllv2PL571TiDTw1nbupiEaoq0mZDLj3woOE4maRb2h9dLgzqZpAq+GtNqjImTdGsSRb+ar1YUaAOcILmBOOdNQ3HyLIEVrSVbX258YurRNXStD5AkYJEiW1v6qvdVCNdPf7wGTJD0sULD05Lw1leRIq++wAch0CLTKMQgfefip3875yhZxiqfkBuds3AvGKGu77cOM5PXJOk0Eif6/8PMThlENHXiMmltVhnkkvFt+BxJMsxlpGhhDkerwRLnYgGga7C0Eyib9WZtUU6NrksCBNTWG1SP1hJf433rGcTAFSHJ4IOv2PMc+njdd1XoQ4hVVeJe74Ee374kVdj+1+f3GETwLPQ9CgdKhtUQ1PvqsXNgSIG5KU7JH448QYJoSdJCW4xyUrRfIkk++Sx4jTlyk2TPD2R2HE5mIClJuRVwGk2dhLriHHlz3vx0s1krcUqZsHbDEcGKqFji5NFyyhMGjgEt+hCqrmKrDj/swnDAJFQ4Iu62fdDTwAnRhpc/+DYw+CdVFqSXY9Jd3NWk5BDpFoVkyplLzwAnVVqcIYpP/nxuPDjIdwg+23JCS4B6qkgFynQpgDBlTo1JUH6u8Yok0SBOVqHGsR6hXyPGxVHwvLmcNtvXXeAZABTehwiQsNCh23WY9NuIOWZX4NpKoahNPkY+sf19rPu+b8RDX4Aay9oxgKMbCXFCg2RoU94fJ5xCqHFmmXjZx0hRz+r3yFlawM00OpejHNUyE6wmq5VdB94Vea7YoM2FhTuQAip0CZYL1vVNuV5vxBMJk1mTehTStsWIpzGmBU9WMQSQE8sOruvv+tgF4Qzs24D8aiXJd90wDG9+9dnPIUKtRS4vLDlO8Sf9qQPPnNhAA2ZUqNixSA9PTvQ00iyRltaZDpU2BF7Gi6KqcDec8+U5U7LEc6xSJGWueALeqiZNGIaoRNTnar1AY6zDsaCDpjA2G54iSNeWPNDbvDQfSdSyJjAC6cCuCwYWNAcOPK4DPdMCOuIcjvvnOxZ/r/WnVjcQHxUq0Y00h87SJDFQrylyxURiGm2iQ24CbJ8skmD1fPqtlId5WzcwnUJFmbP0WZ8zAtUM3MgzVSF0NYs6YVololusVxDnBrUIBZ5Am7IFUsX7BviOhGdgYaxH5nwPafoqKbA7AmPsYAxxkBzQbDjwSgXyleej3dVwBGnC3ZYl/+1i4qbVoaJ9lDGuUdez3EaCdyBPp7V3UtlUtieuugefOStpKGHqFoGlu4InhhrMhVSDesUlkcZQpMkRZk4dWC5g4MnKjlAnURZ0S5h/BJ/0SLStCHsNceIOKQ1VB0xCSnWSpPFkaOOGcoH3ZeVDbE2yIVjsl0GRJorJSSOQphNPAJ2AGUzwBUsMpagsKnjpFj6pNc3z1Ey1O697dSUPxFMIs9UAaQNlTJPnwsIcJrIGd41wpy5xNJCoUie3QYBq1ChEyNDgJZx8gD74mHJkC3Th8OfNwCgHT2PG8RXAkl5XxSpSkhHkYzxVfYw9WiwKbWSm0gx8buYkVdC0Q8ui0QBSybxB4yd0zcI3k8tqk0DFSnpNWmW3D/YJuomlWNM04YodZoIEyrw+YpCDneGUOA0pGoCyEiGD5j0meOb6jvMs0DTtyZO0PRMn1doC63Dz581+6FCUrg4D1EkbDCfkCqAeXKOvaLEPZMmNgHIVcWQr1IGfbYvItDC6k0rHFPLimZT1oEZnuakthSrBlJ79YcuJmEuW850kmcjO6WlaLt0/XyWgBRw4Lo7kSaBreAa5WYOGnAmURIqRrFWMm1PvgzEmaVD1XMlToMBKjH3tmooxXkVq1Exa7Xh6Fi5mhstPPou2sAdeb1+d2xCRkLm01AY12SxtZTgASe1pMJvW5jT1zqipEFGik/qM3bS2X7/zVLU9HTj9fsgI88AA8ixv5zYEVcueyQqKUuUoAU1Lea49t6zsGKwtoo1oYMyrpiMr2uozctL7kkHMEmMUq7sXF8ZQyryq6FmMiBsOR4xg/cmTL+6f9SHam5T0r06FwjgQl8KZUc0zLeQlNKYD3IenTM97IencfK7k7Og0Zw5RwuWM3pDZ7Ly1vLi9dU4fUtHRcsn255gueM1MeZQplBt2NkLEMkmvQpA7S9Z2wHxYeeDbxLKBYEEocH8TIU7ukoA6RvIkUovrKgnysGN5J04SxWVw7yPLUH//7quXL2Nvm/tqylSWDdHBrHbDCy7YEW8uH7gDnrw0SVMkcw8vl5HBUeF6OjPXE5xqMH//kl1WJ/kpg85AtBBGnVo1GUvQNLfm+7kG0Y4Y54lmb5XyJp1Vnjx1El8VsAcH0uAFPgARsyeAihx9GHY3P9/vr4builWel3uV+ApAu5c3u+e/PkFt33q/19dOEGrjKVTO0qbeDkFazuSV38dRp6pCeVWUtWldVqcNc5qkKQ6KnFLp1PPpKWFmovCkSYB0SaBMmzXf0REnuIInDpybxswqEfABXWhZhEDWKLYcGTRcNp4hsJhEUI22kMdBo1cl2u3vn++HHce8arxxlujDsK/q2dBF/mjh62Kub+KMq3NUZM1EeQ72pWiCKjoCZTKYio1sWi8uzyxtKk9yupuLOfuHCkWjsZv0KbOXmwmsXsrV8Cl11kBpe3fmTlsicVsEmh4884IogCd6hbptz30EOU5jS322wbZFpe8CkQ2EuhsItALSavtiG4bTiXgH3BXTWFlJ+vju9nbLXyR88ehRcTYHaRYOVoz0dPSjBGtR/tpbeivuThh0CJX1Yi0wObnqSfNmIujIerrDuBBqosttzlJfCyY91k9oRnbOkFcNan/irp1LpUYo6VmF923eqYcWB0e0ii4cfSBLK9cYWLAPVpMwOOsx3l3H7jRIteJNlMHjwTc/GcftrgrxjW+++bBIe+N6RlkKJBHWGFCdZ7YFJGr5DyQZ+cwCBlSspChByaPXMmHCR7T5gSzt/Kl86aEBmjryrKnVmhPulBZ6/wFdrtfdBWiSpfbrJQzOUNL++ecIdgAIColmQOdL9izqhIODHLWsFMrTaThBqvCQJQkb8OHJ7nFHoPHJo+vb324P/dPHj954822TJvlRHDYgQKGVMEEwvZ9D057IKZ+KhNOqPVtekGcxiqc6Bb9e9GtkEl0KvxN8ntmgRDTHTmFeU5b6Xw0r7vYmybZCcglkq5U7aXaI8ePN0HimSiXUrg2+K8ORbPX6OJApUiRkl6TJ/q3udDpVgAnjRdgBW/jd7rDDYt9WV78/vft+/vOn73z21tvvvVvME8T63FJFUh7lvoh1iUxxTRsjW6Cif5D1shxVUugSlOn/1sRw0qIG6lXFNJ8+q4gnSNBEv7K9JhOodpgW6gRKYVpdb867RybMYPWH/thuf7/wHWnSdR1KOzgbIkKpzHX33+1359dLlOY7f3/7GCCRNFWZwtCdLntk1cPVbjdQzhHt2Yvqy29/+ejzjz7/gL8/DChnOGdAmGwpP7NlPPUIpsRrah3tdWnOgtYMpTBmHHksJxlqASqsyhlWBaHzkZed073XKj03R5Jme1jk/8NMa80LxPpibfshj1Y2Hma7dJ2MZwMbUD6O/9FtPqGNlGEYj8lMmoz5AyE6hxASAi0hw5JjQJPLeJUQhCJ4ESsB2aulIIrk6iGeggmCUA8llpwilEaERXYtzaUJWJSWFcFs1woaNaurLir4PO87nbGKbybf981k2qW/PO+f7/tmCTeN6+nDlCG+TSNBpheuFYGknkoE7adD6SkkSgNNMlZ35438iSwkilp+dn7x2fnO6+Vn+N2HydPXKNvARImbLEF5AxWqZb3AuI4sAKcWbPiG/aEKMIgPgCidKlOb6ysi6vFodHsjibfKEgzZ6jKS+jnVacTx0n1gph02lCdoHgIcOnKF3oAUAkUSVylC00zX0eN7dwsmCYuli7Upfb3Ng3qNssfH0Cqn7dl2Aw1ye2+2s9cddEtPhSK+r/P4r5lRqNKXLIfXM0mANKDgX9VWc7bn+goYL3/ThB4gYZVNsIQXyBM1XbJ/YjABcdKuAgVPz9PjdHYudRYAkRiVJDtd34Qqx4dsETWvikvLkLrIuvhxJZma28CkuL/P7ThDy1AeI4DjDN4iUhIFR3bZ9nS3wckUeLYPsvPqjdIrH9xqhUBRTLUpb7YIj2rRqM47+TezFg3hJTT19T/C1HegUj0LJOjV+DK42gTQ4lb3QHztWyZ1mRw+/evDFFc+kpSmbqsTJLRJqOjAMk6eT8rmr1iKL9ohnT7NnG5Qi7KZoQl9fLk6SdPFTUTCKJQ2b1qyRG9I7sFmxkGUt8puEm/xZu3taHS3sdubOrMRnL5dPJit3qk+e3O9zMWwwN3Z0TyaQKenOhnVc2Z0z2n/bZFAoLHQdYgw3+E5vLbSLEMGZLxINcR/Q8x88DCL35t6WK/0DyFPNahTPV5AsoPRxTWzg6SsvytLEaWUlYeas2XDgkZm1lk4i6umbnIc5RsFwpQzzO31fuDE7lFbRgRKrHhgpJizV5dffla5td/O24O9b9564oeb4KlAXe2Jk40WoAHQTTYxQGDiEAxohSDZXKepFPXUpxqcqDKDrSc9pGbQKKB7K/pjyWg4lhj/9NONdntLavcQUDK1qwHmGvO6bGIqUdElTYt4vFmjc2nDrx2jlq7I0alZlzcxwDyJmBpUIIwfni6njA40+Ho6OkUJ0KY4qdNaLjOZlUqf/fzirU9r7W27tPHFL7/8+XKdM2OYe0XTFZwyVAt4cpIkCvLCZljRBGmDvPyYF5ifYHx5ivSpy+DFDWkBelVshXUTE5a4+Pnnbq23D3WyQtI3UhBXk9ExEc1PTGNkMQfJQaI00eeh8DwEQIGpHUt30SHrHXViPmIDqPB8w5BL2QLB9XqV6KjXJkWtASr5/jQ6/+GyOxjsTPqTR5lapfbprP71L69+98mbO6GEG/O16XX6um4KFCat56D/ysTB+5/XIx7PsKrTnxVgpJGDgsTHsk+lB0zuFpyR+F9fX66cAmhSlhEhmkxQnOrq9Pp7yXi6IPLUZQ8itVjFpx8+OsW8aNxkOEx5yUgiqIUB6HGqqcUnJ/XkS8gkx3iaGg9eOJ8sR03qkjf1Ws5g5eRLF4NB157Mc6MHe04+9/yb9Ys//7yoP/1MCDR5qEzVgolSkKOC/B6j9nDCI8g8ERz/E0pZWfIHBRE7HjAWu34QBVRETnbyGRvQVKBDZCLHSCSYl8xE0tsUTsLPmZOQiYLYqdsZ0nMaedi3H/064uaEODurJkPn5GBFPpx/U6BwdqHKQRbUPqlMK71hpzntbHx9MRkBMvff0WRmnVPHqb9bcuo7i44zagwX57erz/y2Mdgb1KsbpZDrkiaRAhs69Xo5YciEbXqxFB2xJCLCBYiCuobFtjpq5DpZvfXq6yFWGJF5fkC5y/J1TFcKmJK84CI/Q5yRwu698mVckhGm6JNmUtxd2gTUaZpAKsbayKDMuGSEI94cDJqbMUPkR1xMTTScCk4YAIK3pXtxRMYLWHO3V3vnq9XJyY7jOqeVlTPsgXBvNFn056WNi/OV40wmTn//LGw2B7PBD/X6fD9fLeWpT9el04cVJd5Bor/WXg01NiLcBdLkgF1wISibVJMkJOfi5DE0ovOYCl/SHQdeSiJzF1+qMo2kCqbBsimRshLjHEAm9GEaf18D+kRrnDRNM4uDciKZ9GHp6c7BVnXsT4QsTS8EyhPup9HLDfJESkIbbSDrTPs3Lm7/8ccfl6vZ0f2sXb9497kHC7s6W9jOwpk5G2+XMkf5Tt+Zf7R1905q72Jxe5CfHfVtuxvywycHYRWr5+TX85L3pysi9dLrDs6oqayvJygUrgpU6iiJwEKYt4hCVY5qwluiyoOTmBbHslWkYbOSXSu4Mdl7wwFLJgtYoTOzBQNALQPcaZYJUJJxxli8mHyColK3fHiNYZPjf840LXlAMTsVbWYx3TntXqyc+WRyerocL/Ye3L795Ruv72zUF7NcNZPP1KudijO3J7lM6+juQf7GhmNnio5dtfN7wjPIRLSAovK94ilC0/V2KIw60qUKf8dM+yDHC3Ji9HCKMnmJvi1RmDqVVVb9rrQHQLTuwRla4gwJ0ViM3u6uMb2LKilQjDAumAUIlI8KFxBDG/IcZ/NRky7MumdcMCSBE5/wa7OHMlPMQQ2LiZ1ETXwN3A+CtjuT1XyEjFU5WZ525ovBg9vvPb2zs2HP7HK53HfsXCU3y+Wc+W7x++2DXOnZ8vdbtrP7yrPrJeGpEZQYdRiUTELX042UiNwf09jJS4pNGPIDXUKX6/LjIW86peqW7wAHbPMq3filg3SMnGhxH85cRCAFCkOzxt5NaiUfN0WcxAmeeJlJ+Lk8s9Aw6LjN02GWU2xW7fddMy2ClIcP4M06Zc+mf9qw6N6gSUFnGzgMpvHp0Xw5TMXXouOTxWoIIda7T3c36lWnXK7dyuX7dj9fnXVGnaPo3VYrXy7NnGrVWcZv3OhUQuLhaHio3wdKjYQlxfqO6O9bUHLaR8hOo6UnTyHLO2DoEvLblOqmLADidn2wTNYOAm8PjClQ+itzI25EnpV15fmPZBA0426hgKZhGlrNW4UoVIajULCiOtHRyTgUqUNunWv8HJ/EJXSioTIpUuuoh5p+erIcpRv45d9a4+Wvq8VGtV4flKrrVaeaaeWLxWJ7atudeG+74R4Vd7eckr1eaW2F92583woRpPIMnJ2DkCrKyyUqtrDk8JiiZLAMCs/AYtpIcpanYrToUpM6UwHyc57yXBdC9A4/vihP5EolusbyHVgTUnSaIs9CMl6gQaZPCk4TVBA+ucEeNaQ8Z8JnbNSSyWqoz6OCAtJ7WMsgaIbNoRRLxvF9XGsuT9IRFD7YiyxQohfng3rJLq+Xdqr9o9b2fru21SqGzxqb4cL2tNVqO07pqY9q989vbGU0v/sFqKsw5Y/VHgNNKFeeLD6rUSDISNdGpMkbwJSPGMmdPiN1bW05vZInpAKE1w2ODtMvHJU80CaTLmokJqM1cEyyJU+at4qMNJ8eywPueBGnIbU5tnjHSws8DUMmmrJ8bCKscoqJWAGTFM90FC32dsNn9+7dOzs7cxvpUW7SXVTXP362up4r7h7sHrTzxe+jd8xmdNSfOR8cHOcyN6utlv2lkyFPsZhvwf9CAQZ9g0/wFz8O2eo0HJQV438reWXDHMLfTT3+U6WagbTcVFGqW0jW8rn6FTG+cRidXkyredNUkGw5TpKors03mlbBbHhJWxffQRHoCtCrVEi8wJeVFnwG3qTJIquB3tou7t69d3f34C6Y3t89boxmGefZ599ftzNbx/fv725VnCM3tHCWxUxuYU+cfPU1O5PLOPlajTxxsNGOJhlWmGgw1BM5xaEsMcLYz0VXk6EIYBOGngJoJEKcPBTSdaKMIXJz/+1+gUPN8UH0hFtrZHfRsV1DSmIiaoCji2MtWQA8mSIJUDKNNtTvWYMKULg8OPb4YJyRRYWVMIWfFFVAacrNpoUWvBlGi/sHx/ut1vdb+1u1zsHBdv6jW6+89P4r5dzW3eP2dnE7v9wszPb+yFRaxc6Rbb9TvmU/9U4tt19DPlKahMgEFHHRYSz6kmqIOmGwJM/H6KP/XTeKBFMlMmcjhm00979eHOR0mT2xN78e7NRdgRny50UIF0aqeZiNR+TLZiP1UoJMBaa4fJISbUCqgUINVqSaYfQJLwmaTSCE329GsC0S5dU0Qi2uMKgSOLnzFm50brUPirlMsVes9HvRaDH/yvp6+ZVS1a7tFvdbmXx+supepk8n/a1Opd/6tHwzl8k5dn5ZUZ6RZCLmm+zPak0PstIFsAKQAUJ+wFqJa3Q8NIZKwiIZT218+zhjHlLSZyGb/LUxHEZ4Cw+XlJKRRDw1Hj48HacKgrPAeRynRszwUC1wNvCOJ80Cxaop3yBQ3YtLWbJqR1RgSyXKc4a4Jxp/Mjq2UjKPgteDKTp8TCnDeLG5v1+rbDPQZsyzs3Z+/YOXXnrxhzdLNyvFdtFZTC6+/sPJ5mrF01om82k5ny/b+Uq+Mi+y/kRgAk5KUnnqQ0NySEXu89M8A0ryKdnpkkjEJ4vKO8hLEeSt65HXt8dImcbndjlshO/c8ZzcTZpYZUsZT+IJhUeffPPg4Sjl+bqsKkWSur7ESJAFT0g1SYESJV1e10QsAxU+BzBoTsumLBNQc5jOyu6GmGnIahIai0hlIT6tYZdD6LV5585ZpXve/aD0zOX55GZuu9ec7626b/x0uVgMI0fTTCbTKu465Vx72P35U+rT83ERI7XpSU2wCTjNMNrJQPM9sQMFOjWSpXFyLiT1N2hmIcQALU9kouTjPjg+FodwgaY5PjkZYXHj5NffP//890fYOed3TqBShK4RJmUKkjTUn/FGMn44l4Wl5Xy1TAFPb3gazc6XBi8aQtCiZq3xw2H08PBJE4t3nH7ic+IcLdNpXQf18peFAdP9aLEcZW5/9WF3MOmuRpZj1/bvTy8wZd+7XJ1mQ83eyVGnmO+X7UrfxnpoiDhxSFWSQEd+3oxEBUfHVZ5k6ClTp5syDgdbGywNhCdnOGzkV3BA8PpjijUEhUrppZ9rbGE2/5uscwFOo6vieExgE2gCMzvYdVwZVsYwuCtDnVHRBNQS67MiZoxvraWiNfo56lBqTK3r1LcmProGEm3FKm5wdRQVIdamMQmCD8AWq4mJTkJerRNqk07SpvX1v7s09XFhd+8Smm/4cV73nHPzter06L7aIa3BWWVne319fXuvnkUtjnQqadu12jUHT0xCu1Y8gqiiw1Pn96vL97W1PtK5ULtdo7JpgFT7uiF9OAijbPXwrdEdPeDytfl4SUb1mKToFiwkqweo6hkWACwx+NUxgY3XHk5vzCcrNhvXxUZWViy5rVrJIwq5jg5RqbMiHQuyolUSnNzRJsDUnLqawNGuaisgIdNo/X/c8fY/AVLL/5Qz1EYtzSJotkIdoNWiLVHBbz/XVLvOE7ANgdViNL9BT0li1T0YraazCjqu7TuV3Z1dk570efrb1TpxAycEFKlQlDW1jTEYmu0MmB/1xKeh6CEFrh6pUGgvsaU4CND1+zugrNQ2Hj7sufLmHAWIah7ZrDep7zVpfd+keikmp3N5M0ok2dbmBUvA6EtJtgLFCIxk8Sk2v1x25MR6XcoEOQ/nCXlYYvGAkQikHxKAW20QQSMoHuOElv9X9ugxSg1co/KhGgJNyvdx7i8FCDg1p4QtmlWp3rGfhmlpRSAJF2MJyHnmpNfLyEo2kKa5SIQ3KzYoOb4pNaEMz06qHgYDLgSkpvyNtJ06bI0+ZNWcqr0LekzVjkTipECUlOgIz62cUCrN370dI3dZwjCr9pPgPTC16g4jicnlbW0cl1koZEJ0Min764ptwTNJWwM+o9nWIlfu1as5CbnRYiTiCdFWVZzaSV96o2PtP7aY4gaT/SLGo9wn3veow0sDvC++WlKJRDqaIGtDdWHkH2vdH42voH1hZg7qDRRIuRHP4bMVbJaiUhIYu90dUyQlIPKRVIIz+qA/WhZEJ1apDvSDqDl5Mlox07ZuEaj6R/ViaLsi/WfGXh3QdRwYlBFATWlJNnf0dZQ2HlbM6G6QBauZUpP6atbZhFg/VoOZlNpmVvjNoDDAMgjdk7WtYDFfczppCusmn0WpLFfSJfwqxeixeyo1kp9v7Dn57/Ef90TUVN+j9iE9Xnb+94pdew/ZoP6kfe+Pc8PkNnBrqRE8Adgo2Tqgf1kMU1ZPpSX0ElCSHMvTnUfdTEyul2JiKBThwjZ/c4taOzrY3ft1nsgnYYhKh/bsAEtQhTASsPAzRCCnry7niNlsPNXmbvK6tulSjYsirKVvaWbOJtXZLNagqw8fQschmpBRcxZKL9Y27t6t8QWskRbm+nyxel4SSevXirJxe6jGchafFGIka0VWKopSkc0ulz3PDSH/o+04aRDEpDHDZ6B0Wp9Ls7ZO0qzp//Uu/PeAlsPrqBa0sd3y8TZBXBvZVRICtBDtriJjK8vptKKIPBeRZdHKB9mTl93e3Z2dmCh6eK5IGVq1vm7dXqCpDaJIpFrtP250exo02WzU4E0WrOSH72xxdp2OJPICqoxivz+lh8oT8cMBCZSDmRWEQr6iZyNGUYpcqQeUEkX6xSC8WNtvbdmFXLptJaF4CitzRslnNa+trMysiMn33O6dLkthY6ZkrwixXI3Uo7KVPTbGR+CPiOckG89A8hHOhjOSH1RVtCBJUDbkslHtUAXwf4bm8dW3Pk4wd5TrKloTDuDcN7otHfp0dW8bj51qqRRj6RhtZUtWYjKdDu9udHeHYdnJzYlNymTQ3JDJAhNB+GkC2qE1LsEjqSSBFDMCFGe66J8o6sgdJemIOSG7rcgejsbGTbL6TFGhUEFK7y4/HELS2d/cp9S26tB0dVlPyblKPqtrm+vz++dSIY5K15SFFYu5XB7vWVycj+ecTCW2+pe75aFarqI43MiGCh4xHAfJVs1eAh2ujUGwNum16Ed7qBqrXhra/jiIx/TR29ShvtTeWGi1mNJ6fwv+rSqZKnEtpd96MFvf3V7fBs+SLNNBNlatxmQ+FOI8XZe9yIyBsXUinAiHDQdVv24wFMMJsFJVHLLZrppOAIUrMzQGqnNa7q6wMFtQOSPZDJ7aQL8RWBKfhGEm2WWppBzc+/tFs05KFVK2OT9psaECFcVkTpttfXMzfcYQfYYJyMlcuYJqnCVWDTqGrnurVt5+9+HW9sOhaI21KtTiy/+0tVflZamniYjjYxaYNzLh2n4+YgQfA/1fZX/ETpvub+5X/w1O2mv+hT4CsLGq0t5Mfm7Iyjt7oLm7U09LEU6sVirVGE+Si0H6sl3I8x7RiuxYJpzwIdAkIRJg4axaSeJ/2sEy1pPTXDshSw7gU7fAGulJCy561RCQBBSYwoyi3k5gan4HhtRcMpUujXYPmY0Sz60V8EPY1qy67SAB7S6khhbHpqao9MZQLpCJcKGakM/Fy6xEWcp37+3UKZOStMf53Or0xfj6oXn2mKOpYTtb8enBViXUUPjGIF7//5Ny/11135duXNrIAWCa4dDuVYSAqcEmb+wwmJTq7t5OpSRLElqFeKtTqFV5LhWKiDT6qrokM8fTXCqR2Az5bNBtSKgWxDf6kMmkI3c3vhqwaQF9q58QtWmeH68AJMgCNMlx6glOn9Z4p4d3zxKmpFdZltkBhz3+IGDG8j1EYQdsFgt7PSSXAz6KqozFz73Zl5/nC0gyMY4h1sPGRB5ZpvLD3O5GqYlqrlUqudW95eXt89u7d5zq51Y345OHGo7veyTtildVc9j8n/we1d6BZ5/r/wUHquzjos5V4Puvth40ZUvVnZ2SQradhagADZ4M6wmFQ2JXZ2eXE4kwzmrFfRGMbWTdTpQcGHGBeGJCmuVXc203s0YABjkSRoGz1mdneDz0dTmrLeNxaOJplney8EpZBBfM5QH7uss76BZFM8fRdrfXQZpCO594/ROCRHYfpffii5lQqlCIBINOe9xdEfliKLOSGC/H5Erl4HX3lvFhZXlsvjq6PXr+TlTl0ICqnbUI39DwTCpPcmrEQ4/XRI3qJiGqnTAebxnY5/qYLQId3JSyuMNmjKyiyDIfIPXbYkji6RjSXdZQKMUxJ/5qZ6xBjyfoFGhP0CpyKdLlCY6gSM5k2tjsapzzZUoBgwHb27EhjngktQsUZ+g4gWzSYxm69mgLsabqoDh1vwqYxJGLmZHJ3w+z3sETnzwxePlUt9B93CFxJ5+48qVvHJrK8WibRUvDac9CKuIJCjm3kHSN0x4ukZDqJascHUu6HGtDyd57vRtpef38E0d6H2EgZOAvVKREfvwtmtA+BoYf/ler0r4L2h/78tf4XhpRl3rGQ7v6yW836LLZQCQSpkhbkMTzYp5lGVbk4H1o9/CwvT8II+q2e90s6l4Ro9roqflzSKU6gwUFL23tjsI7JJcMwhjGUr3CeGKmQ3zf6BPb77rDhuGsnuA0izTVtxCqMOXVuxt/GT554uRgxfHE4Nff951D555+6RtfmlqfdDqLsvDQtyayp5HjdHvRhuyqBfM1xJyryYfzPeNBZ89i8t5yxRf70OJUPNrw7ICwj6bR/ksQNPA2dgPsKzjuH6t4A9T+af83ahupW1WeuGrSqr6CD5M2RyKpDKngRsRSDINhaSmRSITo+OBwJyt6PKI7Hr0sRL0x3qQjttMAgPs9Ia3gB5waQT3pWMRUd/DmwZsmTLHziIgkWAa0hia9dkF/GLGcgayx2UZSgkYn45ld2OQsFXNH7c4833VyZDbGfL3r/otefGj08OHt5KDVOjkgFHOc6BD+8enbUa/dVXOGeUq445Ljy0lXueJdTV5fjV5cNhrjo6vD11yqdj/m2Ngf1Y6nBlSDQPA0k9PjZpAG60b7RiummpXErfbUXtFSGICK20eED+pIv1sqlUpQFHCyVYGJITbiw6lUGOo+PHgS6h7aZL1RwdE9HDObDI1uJZDUbCeeZIAjJuq+15t60ATOxmj8mRWDkcioNif9teAJnAEoBwGb5d88G57N+PuU6+FERajUJrjx4xORLhQyFpfHmBNne3u4YP/4psc+tDE//+YPvfa9Q0K3fXNuIeMUFfrMot3qmfReWBbKN+6NxmNT00z3tdNA80isHnf+giV5NixeAzgh90hCNfdNWBGSja/i8QA2vI6j8VvUoYo8saKQoWzW7PMVfBYzJ6E7QIiV6HxeLKYyiZCYe/ObXazVEwmHPIwgxKe8MZP+0V+mIoquOR/EmHg2hv7mwQZLnHCYbppAT2WoJydwbezsSqfBMxsQGTltzgaooyeYgZHw0oxy94IzSLXl37DpGegU3PbkQyHuFezvOew2hjqPZ5zO60OujdhWvP/wpc9/5Zw7TJcZs/CXHzmCHnprY7W2hXT96t31efchJt6k6WVDrEiYpwFVoRKpaug9uLeDohr2aCqtYcJVY0nerb2VTDAjD4Agsqn+PhUupCxXzabxuZBSt2BLjxhzOOxMvZRnxVAqExZj3Q6Rp0WRCyUiQVaI7lXTOoMWv4PjTUCFIBoaJpLIpw4w8TThpPE03byJpAhoYqgyCbZEQC2QzFoN2QLlKz//4ncO5yvnDnEsOzvhzfSZ0pVCcKUw+4az15PjDFuXlbydYY+9WRTDtJVjBzwez7hzkwn/6saHP/+243TBkkvGx958u7LlGnLRlBQLBJTd6cF+9/lPx5sID+3DY7RqNMkVYA82IICX6uS1LVVInOGpQddGQxxxwln9KX6rGuJgQ5Dmjxt5S2xmC8RjpZKchZNAOUdJx+xerxsrTZr3cJFEJO/IzM34aaunmEqErLCqlbTJsO+ANO1WSRIRvalB1UhiPLrqTGVFZ1JHQ9MfOXdpxZY2rb/0Bxevjn7gUHKP4/nwZsGT2T4SZUKZVKTLPc4X2dTawkohxkt2AfEGL0Wczq4RFC+dPfb4+bsXvnQ2ZJMfTifjd3sSjvmeLq7gV9ak8uq2Nz40mIzikzdW7hqf/b9wYCBANNOnwVYD+0aojtHgDlaqBDawa3AJVUSJJDTBx1FTQ5p0Akk20waeOp8P+UOs4ISc18vmkQvBKHKiezh6eYRF3jMM84oedatkIt8qiS47VIqq38Ycd4+HKpUYGllYE51ejYvUp0ldYgIoZmbcpH/zm+r2+pUHXn8xFuQWwnOZLe9wfKiIZCQK62thd2gtFQ4FPSOhUNxVpHg29eDtp/tPur59gg85vWd+1Jlih5OfLcUf1rYqR+2TPZWFhPP0E2dXmbjTHT/S9Eg9Vc3GnAAleW88SNVL5azGTiSq38/jkzcT7GRrmtYJ00oOgr2Bv8OgMyklGZGJYf9LAv2bchXpD0pvMybC2FceQ/xspyGaEcgKH5EY79QDVyxAcYlCIRWiPRHgJB698ecRIe6YwfOALybgp0rn/kBOH/pMBkGphZtw41WFXHFgBNKKoWiUrYpl1yuluKK/mfK67VGHx9c8Z+ztFfwFjuZCkQmng+nv4ooLPvorRz732hv2k8ff0Bm8jKabo8EFevU27UiWc5su+wDDCa6N00ODg1G7m/Wuq3G2io1c1IELKKnLDUJAI43x2O+oKAlGA5ngSkBiruq86tUAIZuukgVQOqvHvyfFCRVnlryGWkEmgZWQNY++NDuLRB2FrJKEJbQUi3pzopkKYaFJFTmO0uG/oQWZehUqRtqR1N3UUP7XgIhOfV1J7+5tTz+opgNEQEvACy+0I2GOGew1zlQBm+CkVJ/fNkQXMpYnUV55LTI7El5bObMbt2SKSnhhbeLo9Hu7v7m5tpYSHd77n3mDffb4N19ycnJ29g29f5pgn3C7osmxgfDm+HWW6RrYcA/Zo4PDjqP2riBRdo2j1vXbosdJDxwASlD5SWKnEftAMBsxv8qeJMtILYeYSLWEq53wIDh1cnUXIwbRAA3yFjhicxqltp20MVNIhJDuYPvdDrcbq8oIh/WyJAWMUC+BliVzKJzyGSmcyLewv3AnRM3eY4tPHMuqBEEUh4YSI5sWEWVdOX/r1vqOkiURkc9iItdwBuvGNIimVaZpXlKKBUp+z8s/ubBSzE+P2QuJgdNl91e2ZbPpCi0ZRH73TNxuPzk7kvBEgqLdxYTz1uMDIxOz33zJKffZqfccY77d7Tha8EwWgsL8WbzL7uwPnuzvmgRPTTLxVDnA7IEnCKhioSoqljQq9P1VJG40+CpTqJ56bQQFjS/mZrq+s7vXvVuVsfessSUoW1kdylV3ZDNaX5FS5Fn30aj9MhaVIi3LSkCRKB+qvLAREh+JRBBThX37CmAgg4RI7pNneuO5EpHPfSekDlgXd+dLLo9PL/7p0vn1KpUN1FWmEM3B177lo69845fOPPGJT8QVkMUoOQ6962KlzC8UvvuH3jNVvozkFo3Yod2nmPneeq67nrPzncFO65lrvb3eYGj82EBi4q+/+8J3j3d1ejxdzg8lrUGr6+yJgVpn/1FkHAaO9jMjMburCRBVMwkG0F+YPVW71Bwi6WTBFMOm2cU2dSmvRUBE4NoJcG03Kia4B1QCk6Q70hDPnFAvkcgdNgvSoeQ2Nubj9ZKCrBFwikjXDA6j6TePeiuDNFM6FLZEJBmN6VYabUGlkuSzQWFUTYB/x4mo+PWzjriLrWog01lwJRNM66gun/jkhbfPn3/R4rHPnhtbTdbSWFpmS1NjN26MuZeT2+cvLY8eGo7vVqrxj752efvBcNiTss3+4pWvvNvaTiUKa80zza1+ybqd687lsOtgcqTr2ydnj3/gJV2pyOCtM5uTodSsUxju7Brh+i9fcHEDA0PdnZP0eOfRl/z4p8s5NDyWuteb9sNDVbEM2mhUD/TterX1wq9670akaWisobSeApKXVLejajqtCi6sgC5bQg29rogoo4IRPHo6HYsOuevmTIqLpGAuxbzgiA7G4242H4NNjUEszVge8XIwSLMoaVercgjtSmolDlLaiJdumnpyvICyZDULirvT01tyQM4lk9Ht9YvfuHTr/DO/Vgsllx3J859dvid2SNOLi0MXl3O7Hf6qCZ/I4jcLuXMvftXHn/qD9MGmbK4zFWkT//bSv1U6dIkw1zyjfzD9xZ+sy8ZSaffNQx5sbx0fmZ09fnIi4uGDJzu/ebLrm51C/4mu4Mjs5fc4B6IDTP9EovPh1uLVX39rW0EfbunBrSbNNxMWRDy1xGGrVo/Rkcy334YDcvt49Qm1xy2kskVdtqiflSgjJqrLh90w6NKlaswaCaQiIeSFY9VSOi0j++5D/QAvwbHLLOONxgejuWqdLoFdvVTiEcIHRKsosqjKoBjHJwpt2p/p1uQTD4TvE0Ur6+p+z733RLfsp65du92b/FEyudgz1BN3CvH18zeGlNpeLsnklu/GpKEbo8eSxwTZ1DK3tIR+noXw5srM+gdHz6/uUfrArqxDB5L7g3/fQrtEcbZq8Kf1LUZ/n56Ss4cOiVL/eJenfxNpuon+fpo529kVCfYjbhof6To5cPTGhifWNXn06597yYj9H//onaqkkV4p7U6p9hMDUInWNhKHOoTb6RKWa0Q4fQDqJ9KpBqqtJJjX6OMfqWpOwkPovGZO8TrpDgZPNmI0hjhOpPPgpVTykg/9qf4wvmwFNN3R1dUkdu1YZWIx0WBTQpgSKsKsemKVGIv1J5fyt0IZNNup+iNohCWTmJiQ+Zw7JzLRZK4ipNMiLfR3dTmdTLXCygF9uq7Ti/Et86E711Zfu709PU4bAHOpz6dTVhKTC20mY3p16mMfO//hGyX4tm9679TT+rm+REyJreuMhw/LDr/I9J6JcEgh9AtY+KZmR8ZPdlm7+rkgHY6wwaOs21Fhh4y+jD9lnT633Lu9Vc9jSQUdlMV6k0YGNIn+EpsJNVeFdK8bfoMMP3lA6BqJN4Ktfb/+QGynlsTVGl+0b0eXBaC8RFGQNyvL0tDmuhk4VyhexIhVBXv0wdTYdYcQA0tFTgdQQbLyIQTxZg6wWZboPIdOxVZNCSCZWgQfY4OZzYIvHTAnhLreWNS3HDSGFoJ8IGDUN6HRY2FmZmZtxr8a3752bbq6XYtNX7fNLHW0zdmyctx99CWFHOV+1Z/vLO+mAybd4ec/f8xVyZpaZmLW0Y8/7c79G2N6c191+7PTddtsmAvyvAdpbTbiYZPn3ja/hUB5ZHJE6BJcqxxbQNOfnt6rlsuKWSEwYwibjb4mYIQEEC6Eh02vNVOS9sk2ouoaUT/aA4lkPlqDk3ByP2WOK/EV6hehZS7Q66KUwBBBukjT6JYU66IRdew1Dn1evFXAomgw3v3gQTQn5GWF55V0IC2rK/hEygxv73SyVjbG8GY9vh+tONwYpbrfH54Irtjamse3WpZm/LalOY9thZtZUkdbBh3aCWtixVJNLm4kc7r2FrnHvPQkf1M6oMTXt0dfef7IdPVQ3Nw+M9NhSr7y4nbuPVt680wLQ/3h7xVlb29wSk7W7mysJhMjnvBaKiX0RmnhzKnD8cD2lix7nKxTpN3j03E6trAmyXJuRyG6VdlAVqQqpymfrwkUAUNNLT5qnvbZ8ABTn26fJ/hBJHHAdDZWOgAJFSc0yVVtJVAdGTG9poBcyqNtgrfSNEPTKCSwfCgctEKLeZl1R4e9jih8u7fiZkQlLUnptJS38p4QiowBnkfScTJIM0yepxAJq/8BAhQ+vBLT9fG1cgSNsFQsswRZBMi+OZ9tiUwOzC2tYLATa7PcTF90+U4cvR3h/EyLruVJelO1Xtm7+sHeDayUWoB+5kBa3tPpvnRe0aMMvTl6o6Jroe7HfNY8f626y2+GJ2YjE+5hyc/RwVTY0uwrCiN2O83RjP3aqlnpa07tTO1VdUZZqa6u37p1f2o7XqbNVJMWjmtNvuBoIyTVv96ox0QHurj4iYBiXammoNSOIcBFAKPuQFcrOSS2IjgxVy1oOl2HS5cRsjMxVNWoNHbosDQt0ook0d7h7kEHsu+OWgWZTwWGXOGswWAx5IG6B+DgUTkK0k43Q0tGNd9Jhk6O3ukRUj7+dNBnIzup2+bgYeaIYJKjb4nQtXF8Hy4rwYk5/9j04sUYN7uw1JwGqb0SXH6gspVrbddlm9AYElKqNp15/VuOks6wtPDae3UsnGRp8HRy8/pdip9LeE6ctqc8qAXGz4i25jafkecdTnrAwcbv3L635e9bCMR2RFubTpb37o9Ory/euvSNK956qQm5Lcia32DTBvFB5IG2NEzVGYGMn3dgQ4C2lG+E2ASdKj24ahVbVcAN7XpdFh2cJC5H826XQEdCnBDruTNfDsAJSum8o7s7KjjHHXZ3OcbQPGWhOI+H4yKhlE+ipQAyTZOT0HfBTRONJzCrPUf+8rY7F6KU33OqC1plUyz+jgNzcJYzB2aWZuC9/UtLa2Yz7ZH4DG1VmCFJH62Wpqfd1j5fMRB3Z/XbpfUjvbt6IyQ1iy/A9PSPveXKlS89/UtJk+lJbY53Pr1kyO5UB49N12jXMQF1grEHopSTdwSfJRPAf8dPibzIu7uFqQ99qLdiabYFoN7opDZjHbLjFerVvfVvPLHaPdVENFdFBstpUaNOINShwIonZhiI6f1E54k/B03NGcHHkwGupMdFi1nBVO2A0ZF1pSwHJJQone7L1uBQb+/GhsuZk8myT2bjDwbdTqfDEXe4BZGnsC0tFAFzWE9bMYTdqKGQZwIxfpVleY9Zh6XWqTN/md6YOlbjFiaOJwr+zMJc24EWfTu1VvD5SSRkaz2ALB/Fka/gxPr5c6PvuVZR3D5vrkdgot1jzzsS0O1++HAuSzoYWtBytzTXcf5p56evfvp1N6aVjrbM7Lue+eGp1pq5YqGdxdj82Hs++RIp4Z7ENu20hdpylymfbIYZck67aqtjb++VyQ9yMcXi89sohUIF0GRGr040OfXEoSZiOm2kw8ICfGCnU7spVJi4ACheJM3/IOffT5loTgkQTQE1DwXBVH8LvguC1kQF4GWkAGcVGdgc9+31rRpjetIBX0iR69Xk1DBSi4IjPjzorcTMVMqHojsKxcVwxpYhLfG+VLGI+hFrhaQWzYHcj95/5myuzBdTFU84sWJrnsOYOWCLiTFrxm9rMzL5doNNdt359ns73dHF5d6NJM22KeWTJ+c/aRMPT8UrrTcrvc9806enq9iS8CRY0yVD+g9fvvrFD771ZxeVjicVuXPvfOpzf3Bk1FykcvMbcff03VNiVeA6ApKR8m5XZZuSLG2v1nJD16eXqxZWkozK3vqt9UpuJ43uyADlI/YQNqi0PXqnyWDAFBSIihtADzCBlgy9BhODuH/SqE7EUstENTag65LzFS061JZWPrwLFVp0A4hBPmK1SpxVKItxrGL0upW5hQhX3dl7MDUVL1tplBXi0UE3HYD6UhyHBAiqcT4fvvMFfyaRKELnHQPjrqNjN6C1vJ2yNHe5xjczS35bWkLbPNlESefdZWsxLeQNRcHl3Lhzu2foerxSlcxtNtvc2uzkyRGfKGXl7MEDLZUXvPCFT/1hxah/kmpuW03by+5bl6Yf0P6ZhYkzL/3yB++vfnbdpgPP+a2KVagMbNqKCk1ZaKKfexvVXTjwWnlrPkmWqD6p+9IL3/Th+/e3ZYPNWN3biejVvUamnTO94GlQmyqg5NB4uHQIJQ6i9RYy95FbwCL4Ho92bVFlClCyqaMRaBlU8kTtKWiH6KFZ0g9LC2KtLB1s6gtZeTTVdD+Ymn7gYHnUMtyOB2e8ebPFRpnR6RlGa43FEjBnbIVMJhMaP/WjC6eGxlGeHdvAHn7GvzDZ+c2urpUlnzWGaJ++NmDl6LzgqqUR5LJDi9cezidpA5KGlBmG3k86Eft0c0sWc9sBxALd73rTU577sqt76RZ4K5iGLGLeapVG00cqPPn91y2/aq/1yvPX8UnrsXCmGFnRl5P5tAUSxzK8nBuq5wJCMsfPspUgbLzNvPvZ57zsxtXR1RJ2i8rbV9eHd9Be4m8zKLnVJrACRwgl0MFoYoKCNSbY5ASgPps6iAQiEMATRyNgUk8+agV6T37sV1emkFtS7TaLErop3GwklRLdXqsPu2NWYCAV2h3t3h6KC3RQREDk7h72KmS/Hx1DvQg8YSYka/TU2bN/+cuPuo85WXoh47HnKiVz7S/HJ/u/eTyMnKWcrygyQ99z0M7IgKzoWmNMfHowL+aNczCkxkiIrSzYCgsH2iwmQxsk7sCTKIvps9/788t+cHXRq5vp84Q6jEZET6VKMj50knf94rfT/C25Nf3Brb1L33392yc3Pa7+TJ+tPr+R4y0W2eILcHHJFmLcqCHQMEEU0h63nvOpz9bceXyVZveVS2/908Wf712OSQZDIF9v0kGkVCXX2SwGC5ng0BHvBN2zqQ8iciSt266GSMCqLVCh/RB3o/qXZojLIg8fkXY9IqAIzXqPWnn0F7MME0Isn0AKDvUMu8PlvoxdurzHkxcGsXXDaLNICKQioQySThJz+95f/tJ7t2cwyvBeZ3AGhIxGm5/eTKwtrKVsPGsXam6BZXJbsQyX90cCBjOjoFqZnUMAeiAkZdAXM0P1/crT4TNkTUq6qU2plLKHXvC9r33vo6uVjtaE66vTvp3okTNT1S0hd73ses0fVzvuCzZqKheNLns/8ace1wbDMpFMuHT7IZdDRGmTuutVSmJRqg8HUXG1Uukrf37hD6briPPk6ur9+1986wte8MZb99eTdazylCYSGFkIUCMOVToJURsGwax1+ROhg2yqgyAlWWOIJUDiBKdPxNOvxq9EwIEgwNPM5WEvw6XCEzydRzmdm4jAb3MsgCInT1sjnMcqRO11dA2aRSeNehES9pELH52fF+hKeavs9njGLpTRGbywsDIXGVmYafY3+1P+1CSAumgmtMW6ymgc7pMQw25ZDuoQLjVj4RD7wBdcS4WFE+huV7LNfS0HlfXc0I3nv+APr7p0vehnobar1eUjv37r0/7oZiR0U+TuHSucOlfdft7HkijQ6LbWV4WcsZyLoVIQpCsXknWh+/Cd6Rw+zsA4ur7LaAoyO171ys9e7VFKaLa89daX3frNB5/6lHe/+Glfuzo6Xa6yTeoOKCKCaOADSSKoAEX8khpTqowbPerkQXDiBoexiF5/4GzRPL0acyGnbsLmZ6kEbI5hhxD0gBs9KSKfGczD9AR4xmt3uxmrB7UiscRg2z7iTdaKWAnD0/02Ox/2UUjMW6WQ/U83rr334exEoTARzsws+S3NgfJE113Bb2TGy0JogYTyM211KxvifQiaUm7899vmMrMZEtCH+yCvM80WZW9H2ei9tD45wFTNeA27xnTV0dWOrJTPpxZW1qyy5d6NDx55/qc+da2FbjNt5xaTCTpXrbklNjQ7ND850XUd9lvy8f1DrhEP4+StsdyRL033XJlaX7/x518+4xkfeeu3vviU57zsaz/42h8++OnPHtloIs3lUG+IKaCqENULwWoAaO2eiCIJmcDxUZQZoC8zbNpMpLNV2jKq61QL4ksZ60e5iiKww+uNods4aCXFYElKIW70UdiXJ7gFZ57mI1QggERdTJQRpqYyqVCo69Sd02dj4XA4ZLRECl39dy7eOc35rDya6FOcNZ9kc/HFhxt8xV6uLwAlwWlhnCwjmVuxPvJ4jEszfejHDkUQqq31rW2u+M0lrK98uxt3Kmtr+QMr/hYD/lEb1QbBFX48NBJOsD28sPjFLy5/7ZXn44ff3CaPrl5Krq1O76ZLilK+8N7OLlpcxV7tYtF5/PjRyf5OD9dVO5a87BJYx2f/8LU3feTZz37Gm278/XvPf83LexfX15d7v9TTpCk50XOdlkbW7rThM6otFtr/aMCm1/qF1A5ginYMf9PhDBB5NeibWwz4QoxFsSQIMZZlIIIsGVbAZNmBY3EYTzBLSTIjsE4AhkTCPmODUUUshlCeDdPe+XvXvHopFkrxjkBeKIRPDozMJuZsRhtahJlyPs1Vhdjens5sBBQ8QGaNyyOvZzkwM+OL/mg8P4cd6xnewtNWmBFjSai8xzeHNz5Jn9V1WN87MaMzLbVT7X59c+gNb6av/3xurWu2h30wNfrp3Kgck7bPSS3V7b0jp+nctDdWdy9Wxv6y0TkwwEryVk50Ofq7whM0nKj9OqyVRxQuPu2Zz/7Is5/x7F/+85//fM3Tf/7tQYfd0X3ocBO24tksDagN544LkU1yr52BUZ029koYCM5O74lvfvOoZFCHDz9ApUuSYdUZNHIynV15jgtyEof0kuttXzkbQ3xpgTvMMyyNpTqWl2HE7UjilwKB8vyxv7ztta+9s5iMmzM1Pha98P0fXQ81F0LYKDPT6tMXY7TgMbYUK3n4/ywCyLmltr5Uc7PNGhRlH5aaKTFfppkojU3/FYZmOl3xeFVqblJifiDum4GVRZDkD/gRAFCth99Pf/rXf+p6W2hmrt8zErSPPv83H44Opg2mAwfS53aXe0SlXqnXjMuLyVqdpV2MG4ntGJPkHMEMarKTTsZpnUWfTen8m5715Fe/+iO//PM///mvc0c+PzV4crZr+P4TTWqRWm2iUNlhppEzqG0V5EeY40Q4Y4qHCdciK7CXvccdolFN5YM+ioslUa54o5e7SPqS5tGnXSCBvbh13SXAM0Ui6F/wemE5PcgZRywwd2YZOaj5D732FR+dTg4OXXYkR6+9p2f5s397RbeTNftaFdEnV+Lx62WBxZ5g5EYsoo2s1UEUhlDKI/HT3LdUsBibZ1aabbwHn9uKhthB9DlW6hVZrtrt0ejY4TPeSXj/DhESvTJjNFu63/GcF3/jbW9ITJw6dvb8i5/5zHd86h0v3dBllw7snA9UWF+1CqK9oxW9uZgv58yMgw1bk7n6Ym4is7k5MRucnZhlmaPxTz/5yT/72Mdf0Pvpf/7zHxvrb+7tOdHpnb54rSlLcPrg3XWPeGEQZACsocYVJ3LoyG0gTZG1LOnWPXqUpoj7B/CActnrzufZy50MG6Q5VCgzhbWMzxfhJDYoFfmgIokSckttIY4MD5dCLGBGyqTn2mvff+olTqTn7Mmo48K5I1/59N9+ZHdim3qH1SyVr/esenmfjQr6LO02q3FpqZkklDIra2E2oihcnpvdLKBcTrtp2uOxcHR0lylBTXLVCoJwxeg+NqZIwoXAHImnVr7+fq9RJz39S6/64MuvRwef+OIrczf+8JQ3fuqpz3z+j9LZ9tbp9enR66FSvSptzecs5RA1zkRs/ECn0xON1f9xb8iap0cmGXaSZlcPffhTP/zYh+5tjF59EeRz/cihO0eu9f7ow+98TVMgHVD3Nlo06STQIILqLggjDjxI14xKFANXi2RlnCMnrdg04PLGAqpAU2blcjzuEPg843bySJaHwom1ZuxjB08uUuhrQ7qIFnnku1MeuPwQ8kk8Z04j2xz90Ide/nUHg8yH/dSRa8mxM9PHFq/0RnnjzTaZLjpdjiFPmImxtGDL+8y+5hXQBNO+lBVGLNDBefhiMW+NWcNSMM+trFBWJK0qMXTP1dk0trj8m6crAWqjjMJYFRWPzuyg67iuxtXdWbMTF2c6RpPFg1CtNWKMVbQegWA0Ta0jTliMSTG12lo18SAmIbYY1EgyOFrUaGgsjaERPBqmqQcIHtCEjAe1odNa8fxWRxdaUqYQeHn/e+/73vfeLlTKoUEoAULSYMOU8Ylwtbpp8e1NVzxkk/YQa9fVrRvYvPkm/cz2nZ4UMXDCCYP9sXBhyb7QwOC+3/pxRGiTtZTUyixX8cnjv/5+cJEWLAbSq/KGP7/urLO/men9oqen93XYs/eFK1ddfelzq1rO31E1COIfRlI8VBH9DM5X5qthSAw7/tu7xrAj1JL4AFWQ8qE2MUbZKbudZyWprVXwLkXroYkA2HFLPIl4jbaFwrwlkg1TU+fWW7U0Hx8uJUKwpxoR1UTDqHBPk5LmQwiuPY/dfuONdZ5Xt+09cCgWmcxqeAEjcmVBvYfKqYi4jgm7ZsMaMpW3BY5DGMSM/HdLjqlvGKPU4FbxVGocBdQP1vpkhaa8JElVfKlcaB4xUAgv+LlA7eB4oGbuoQ11siBK4s7Xvh//9ZHtG9aZasmJhInft+qyl1ffdAMbPfdk9FGbSO6INzoeyM0fyKo6I24HabMGAg6WDKYW+ff++qO6/zBJVJNH27948c1rvljfe/k517Rfcvbrf/71+aqLzj/r68vaz162qSqAPm2NMp0MC2LIniyXKwOKQXH9a1CoKmBQyCqgsMCDahA/FJVOM1Kbu6/ZSNEEUBglCiTeciZvLodkgwqoqQZEUQKahZyro9lB8iF0O6GpMWkVGhEsiX8x42ZCtGB+duNVkYrk6Zw0sDzBQC9CREs3C/SpaiEEaKVKzeZzgsDvJkyjSVvJSvXXD6gDdD9MSUNajwoeFZmagCqO1Gt4L49jH4n5ZClPIjuS4xVyvNZ7ZGFpDbAcW7elzrzY/bRxcat9OLfmmyVJu6pn1bNZhzxYO3vzyEkYObEUPTbn2J7+hV+kmHkbQ4oEnQrpyJwuZMkN/PVHTYiwDWTuadl+670XnnnNZaff9uNFyy7Y9Ptff71+2eUfX7m89/c7Lt1QFdoziHW29afhwCs7mgfGqgEwMZQHS/77hsXrik2VN+UKmHie0DEctolKzY0ah0CmBF5E0AxSpFIchRA+0XALqTGEh7qe4wRSuUKASAidai9FYPaADy/uzIQ5UujqLMiKQ9GwMrxaCyyptvf19ekmToSZQl5bIGlTE8RAf6E0MtJAkdUJntpD1KqcBF4ZL1rRCnGaA3px0dqo2juOAML4JvcBJZw70F+tbqivQas6PJ45evTo1sZwLPPOVdvv2yrtn8rr8ieOTM2sut1QLJ9UhYh8UlPTqTWG8cJ+a31gvGyWYwZfEOXn+LwaIlGT8PwPmb/+asod/eyTN89v2bjt9jvuuGzH9Ze+ePmyZVd88defX19+Te/GjevaH3kzUyXgyaurFddUDLoUbK6yOfQ07CBVlOaYZFyqGFQRqfSDlBmYJ0M8S1Cs5O9iuL5mmbGLGk6A1kQ7pKa9OHrgjVhGOoK04IWgRkqnWR1qeNgbGkQnbOAlUyk5Vozot03uPbjNL2DQOWEFVEGlOBUNItaron3NzY5SctRKOgNgnZw5p6r+ZuRxFb30JC9xbsN7NWraCv/8x9MxJY3wwfPjUhdnUu+T/AaPJSx4SypBqO63giHyihXvHpV3rHbgqhvWb3n9rEvv1KX5FZqkTrVEvPum1ZHJwgAi8jHH9fuXkgZ1aMRFDL71jdlXSAlwDRLP7dSGD3RMPrthy59zPY9cfs8Xn/d0RZZ37yyu27DqylVvXnd7+48f/vj1HXVzO5ffdO95liqBRIuhSdkj/t9dK5QVBf/cKET5HFTRiLADAyDcB/qBZ/alBEnkHXYO+jyjpGG4NLR+gmh3aIdQbVrBcgAXcbIkc7yO4AF3vSaaEtIC7YyCdkdjiGIkfVHv19ftzUY8GpU2j6GOhDeUJ1S0MzFKR63R0mjcqkpMjEwlT6ythzkT1UtGpiZQyTqbckQDylwChIUaFwyqKB1to1En65b1olNVzMSmI5Hp4oI/JjWFAiIXrumvm9ZnmA6PVMQrWPntzRcf6KAeuI9dXz6l7uOrP75rtr/2lJPB1x9H3nKTOUZZR/aG5ActhoKdd5BiKq6hVCV1MWw5uLk79cefK9uv/PjnMhe2WPQ6Vb771lsf2tz7y64vfv/99T/8rq7ld9z00s4qliUJLyy69P+b/vxj0tNA4eNWiMpRV4Z/+yGZAZg5fDhVkUSjnYRTSgLqJYZlGE6WOaMdrqIItlXzhxWkoCxvhKzTqwJYxOQLi+iJit6pookQhAx+t//ZDHrGzZw3CqQJB6VN4ExqvA4iYR0dgSsmMB0/9d1EYjRZ78w7v5s4V02IJDkOHY5arRNE0uRUe/u9XmdizGoD1RfiKFkfIvQZj3mux5wtytAPk9X9Xqacch+cyUw/9GxNQ6DsGEuGDkpLl5To/dVTN1f2Pnj1zx0UxERVJ58x//QHj7Ws6aestr2D5o2pPFICL2nyrjjtTI4RQWnF0dj8wo8vHjyw6pKYFO7K54Z5f8+WK3b98vIvvQel4lzMJb36/WsZfaSqtc8o5CAowDUIkT4MqySe6iY8wBmHMhy+CcfEdOXh1OEjuASWIXmYUbSLaSaetttdHy36Wx2ESgt7RlUDIpfWwTqoZ2BCyIwxksUrQN6Kk6O041Fw69esOFAmKA3Hq1QN+5NR2jaqRauoXmv4TaVARCuMimvKBpFW/Yk3j9R7BR6RmRRwBSnai4LNGmgKeLXA+vi+apMc0VvC/Uxs7hsTJc9YJHV4wSeLRzLr7njumi2ymN2DzSyyooLEg5tHAGKrG8iKtGXVDZKp+tz3Ut7Qa1/ueGXlZFTdoPlG+nkNF1J7yXxFROJ1JqPDu0l573yIKX94eXfPy3WThZhGIqnwXM+uZ5b3fP7HnAeVDcW5Lc+HyYKhyg3qQty3B90zWA7FaABG7FceYUMCLkVHMr9nHuY8kjpy5FcsCUYwNJkYF2dn2VZjnGftGmxjZlkkHArxLEATJG9SwWvUyEBapzNA0zyBWsmqlElaGr7FaKbXL+/Y5tkmgh9Fve+dFGxkAVr1YXUiYf0Xmo8mABO1wFimvCrKmzSQ04ghSoDf45uR6D4RAa2T1uLIDzlVaOOuXbSEsdx3OxnuzPLksFUscpIcOfvhM9uL4kBNrXppg9SPOeOaiZGJJRN2e9MPT77zwN2bryhXn3TMMWcMWC555MuWTSt8Wuf+2c+Ly32zKoogqZzWO8w7o7o4w9uKln2h2Idf95rNGTeXp8DDzn2+4pKZ4kJElsIcMLVfTkk5ZLEqCZGQE8b34DwL+6j5ffMhxYD4o/yFYw5bHj7CHKlUfq38GltcLEIQR2iJeHMfx9oZlrXr7GmGdbAMCFdJmSMiKKBNJwTHKoVYUt7hqSatEu608CwKgUC/4tppfXHvDAEDK5YGl+x0jiZVtI6IJieAJuFCS5Y6c2jH5WdD1pAmNSuQXoKkSZBWDEXxQUEAdAip8LVWmzNKqSR4hSBUenR5v+EXHWVKQMtnFLJ3vxjmcrhjM8PLYVKRFCyNNj7RuGb7jVd8cP9j77j15YHjRo4JDac/ufDKVcsuvjWktt5syHrDYSuVJ3iTekitY0lmstCqCRa+WjE3/eafYV4f4ew8ij593XnLN8oi3EOsUATvPwrROK+JFaoYjAC4pRRJckoW0UdiUmVcOd3zh8ehdE+lxnHEURvFsHKomMlOZ7MST2v51rY2RmTZeBxqSLuDINi4nYcUXuJScE9MX0JtTBACmRZFgBuF/qBB+1B4J0nebu6ZtsQEL9rEaioEH0QddeJ3+63JJTcT1ujUd/sTiYbvRqDOSdqslbBXzXn0ehiMCDkYTtLLrMiTFN5obSkZBR9vTRJUWq0WUno5IJbLe78ZwspkqhISqenNbq8XL6g/sxiubqhuqm3Qv3LLnePMO15wARGdqTV4/Mjxg+HI3kefe868a9Pdbkk1piG5PWGKcdDaoaEhanxW9PlcnewQa97yRs+WgxLrmza4qKExKtw9k40JCo+G6lgX59yzbW4jRxJVqMv9fqRjTuTkcGb1tnxAO16ENx759ddf/f5fK/i4AFNGiuWFafPGjVdlWfic3djaBbm4Eawgq3NA3YZ4KoSwoyCEV4ynafQzAJVwpQGDCPQ2tPgETSHjkzyvMUd8AHEh/KoUiGbcV8RaP/IdepojDaDuMFoRRT84oaLo+qS3LKQEJjXrq6lwjCasI5s9hi4Nr+OR77CFolQaLYH1D4Vs9VaTG3VSAIBda5uIehkpFBY107FUf1NTv1Q5IoTkOdH35PYnM/fJPe96m449rVA6tJ6sOR6CiVrZv/eQ/MzZZx+sOKYE9SwlhQwFmqQUdVBIcBX43cO0idy6ZWYmVi6WV0/7QmO7WWkhnEoxfpx2mTSxEqWT/UaNa7e2ijO6/YaP1kagFHbrfS7My2MVQaW4UFzIIFUuFovFBahJ0NWemzmwsae7rhiimLQoOBio7414SXDkWU6MGyUxcG6Dgu3taJuTZJCgMG4giGmBVA48qk/1cNChC1I6+11mVAA8K84KAhVXh5zW6OjESMkGTUYCvLENLXaF4Nw/MRpNjlX27UOkN4/XE1fdfyCq4lX5DoMsIYLyfLA0NTVaitI0MDyEuBQ27FskWiwl1QlbSB+zSxxHVlLzg7hrNvaB8r1zxV0rP3l0x6adH3yDvsPgrPqttw4dM3HaMacd0z8/MNu9+c1dPZG2CZMpNOvL5WW1Ly9gy6eWthOYiWV5dWmbwRfp+QvxEhPGQWyw20cTDCbn9RJJSCJFx5m4kSXUVUz6h76+B7bufBUzCoy2YUmCHFgyRcQWFiI75/wWS3khOzNjnvmj52B3d93y3t6jXAitobSdNcZZhy4eNzKcDpGND1tkClJRFEcIB9oQoZxtBdUzJB4r6AecIcR+QZ3jqfUWidHLEo5InqTVORVaRxhzV9lMIEuSiVEEUNRKCRX2QtILIDXDltVrCIIzP5CvFfmcFNTTXXwIzzJUSlqTNi1N57wg971MDHpQv49Gd69eChdjPhBW4Awwa1ddI/TXSqv95618SIwsv+6ZL5t5ItzfVH3ttVYl9w0eV3XC8Qe/uPYrLhIzNeAMCcVQivBOakSt0kLU6bi+Lp455IvJcqHc/pIlL46bqNlZgVaTCH0MiTYYGraOxrgxbiS0VbyDNba6P9r5fFc8rgElTltHfyLDlrnpTAQiI7h15mj3rpe3bHnmoV29u5abizlUZuippTmOoxxphklLMBOFr/DL6lobTrWi5kJ8U8A1y+t0OodJgfgUoVPmH4L2jiff12t+WNvoKhQYEhLaXM6ZTEC8aktO1Cawbwn5dyJpcnGkD0OoiIIxxhDxWDyypPcREskcQuSUaIHhUYA5c3g6MvfPGgKtGPMBR/gZjXBujS+GHAtYpvRK9uTyvpD1JyGzZddDd9/0Uma8/YoH2m/QH980sh/n4IQJhevv/+yrnrnfYmXMyJF2J+Eb5cSOrw7E6QQ0FuAENHa+sbscKyxM733okh6LpRiJZfWVWcKEcPVP8HPQhPtZT2NfX3B3FdwI/uxeXOxysUxfV5tG4gyGcFEfCQsqK12IVH6dab/nyjfu2X7PQxDlSQJiY5DjSYKXOJLzuzkjhxKUcbv1bv9hmkbyQZuahFw4iEPJkrwDMIngWZZFwQPjPn7/wef1FsN0R6Mm5mLzaucYocW2Ayso05u/s5WiCUysTYyaXAYmZgnzgYaAr3NjJoLaaprjXCQYiqwcEkmtjiKtitwVWlKdyCrMgJrxyTL0+LEYY5XxUCMO62ileEANfDiy4sb7Ht315uYLHz7ziibv7S0tq3v7B+vPPfHE40479mSMcd2wfd34HrVXSJSivJpymwvlQ199/nweaxNLJRWBaUOd/mgY7YO53g3rs5GIT29ZnfHMZUxOiNpIOsikSG6u95d1a9e22qtAT6C4Q27XEbk429rlluW2TlmCHp22lUp0arYyd+W9q+7dfvfKHr+YF41M0BkEaZzjGYmR9YBJbZ3uH5qRgRsXEZ3tRC5PO3QsD4qUtztIO8kiPZEMSioiGGy+8/ZrV28zWLZFOmUS8JjQqkGFQvKSAPWk0iZQodKgAXbHOgydnkJRk5f0r7rb9P6Nqz13GnRDhcbHvyHUtBzcrdORWppQWFQS2d4K2poUwM8wosaHutMnlTHogLOBuG1SBz11t9996x2Pbb/1jmXnv9zt9t/9WfiWSze8VLfis/c/u2Xt02+/8/GFVz+rHhpKa1w2E2Ex6t+66sByc1t5GFi2VEoOO4YRpcS8S/T6l3++YubVnWszPovmqoyFI2f1q4Wc2+Ip+nt6Jg99s00jVFEONs7zeZBDw3ap1dXnluRmTVdnK2nD+jNVf3421rO95cIdZ6+6Tk9oBX0z2qY6VhR5AUDTzbX5Oxv97sZmvwb0nb+PRX5yIoLwSs632+06B+tAZiJZFq4SfPzaO+tWRzw/GP6hQcCO1NaqqsHigyxNQvAQtYHBBTNqm1ydtRg8vjTRH/ZHMGagY3W3XGsQWXwbK02ZoGXH89uDXkyCEBKHSA1ShGfksCynwlLYktH75GJYZkgdTalpzlO3eeWL7dfds+HC9qvfv858dsuF14mWzVd8vOPjZZuu/vmq3pazll39QiRm8R9w5adcSLOWrMWzN//TbmC6UlQ7NDw8vNvqJGIWOogiaSar78q640xKovMZfXFuRTE7d7Tn6NFpsU2q5L1Lq9ISF5aNPJKH7geXlDYC+Whcfb7WIDYy2/jUbKr8yZfLll144Y43jDat7Of4Ia3OCP8TZyWZZdz+j/wwJAASGDxNK4Yc29Ism7bjaCtGRbWpC+VQJQF85tfvXbNutd7SkV3jl2e9CPb1EzcvDSCh0OopcEtap3qeSiTUOv2aSFZvQB0ieDGCROeiZMFVmPxpqIP/bv+5tQpKCILODgaDKBzsHAlKKqcOSaJS8HGyPpOJmA0+2BbzbQ6ed6zrnvntktd6X7z9mR2XrFze3bPp47s3L9bdcXXL+ZdtvnFv9rxnt2w6v31P4MaDX/x8KL9/mB7STbpjk9pSdEinG03+NGSCvBfUmNdQ9vG+THYOcZBlQKZn3LFDmU7zcqWW7lqzsZziQipbcqpK7/d7FvUckTMF7agoJZAcrlaXxhcHCCdx2sPZl3e0nHX2vTueMTopN9Df6BDP77YlrDpkeZ6TNM1cl19iRU7DtTbDno3NrTw/HIQxGRa/DqXMI3BgSCf3rr/f3en3FSop4Kh5LFpaMvLdEqc2Hlc5a0sAo2Cfks6AVuzY1mEpx9ycW6Rw80EVD+ncaGmotbOTMVmnlKk6SkcN8xTwC2ESGi1ckMrneRk4RRQlwRfJPm/2GyVEdpmzG7tY862b5f6drzyb6T37yss+/2Pm8odbHtnwzIUXL9vUcll77ARiq/zOjk2bLnnjwRtXrKvLjhmBUmKSJoq6NkrYwQ/YhrRJUIdOlV4O2ah8eC6WCknM1q28e1EfOSJFdh3MFuIulyYSxrqO0anRqp0dnq1bt8oEmiVeADo2DffEj7O2URPPg3pzx6Zf+/KRS77//uXvY6bhNJ2cmkKXFbxPwoRgHzSycY3G0GV0BF0at6vZ2NamcbFsEOZkETPTRqQnACap474Hr13/1gMemt6thUXAAkejS1AXIQ+ZrBBtJ0f/gTpT9bTo83T6hBSCIaVgdIYVWYdWyz31arMRw4m0spVN5wgOBXkayma2TZnqdUnxlGx3pHFiwmWDJZPRgKwJG/T6SFpj3vDVV+bK3Fxd+5tbnr2RC2TPfvjisz9uuf7j73ddf0WPhTnvtXWPbNrR/vKlV63Zm532SdOWCF/YTY7ud/LDvMbxUylqmi9NqXIB+UAhr5WKRb9IiJzhjU89YYFyEyHfht5DawqtLCMQ1eeOnjhKVW18fvqBrQ+0pk1KJlTxMgRbsiy5/RAVhvKcfmH66Pcvb/RYgEUlSGfo6FQCAXoYANK7tKFhdAy5HZWTHbWBpHEzdnvcYbSndbqgg5HSbDodNDkJ40cP3nDe+rqOtX1sviYRxYuNA5ScgqQwkaMVIklpPu6HvM4JMtpvCado277xynhuFgoxZ/0Yb9MeirHsMMl16eNwdopEOoJBGYaP+MP4B5miBAaMjMxhOYo+a8l4fHFO4+m0fCOvWbaeX28eJ9bde+8rt155YffnX7Qsa7n63pZVK1uuX/btjh33nn7xwy07vt26uf2rGb3PqOOm8fyThkJpPxnrM5TzydEBVaCmZr569kB3NiZZMsWYbPS3aubMPhFMh9Xa9czB7KGshhGc1XvUNltQU7XuqrVb1za2srSiGHR6OZCXbRypDmh1wFty0VIGbBehz8iNU8i+CP7Gtjgg0WEuFGhAB1NF0HSQj0sufGGrY9iRNtrjYErs+C9gR9N2k4k9sHLVgz2rOwqkWgsbTk3sj9qwIma04URQeQ1gP0DLx2PbXvUZDL5YJKKXnKoE5MliSha0jAnYvlNf4YeiQ/a0Lxvjga+CgAlBPi+ysvn5rvQQ2uFUSuR1DobxWxiNPtvl17OS0R0uzjArNxk6u+smw9+vXLVh5farW1pWuj9Y+eWmZXecf/EFD997ccvH5y+7+MKrv9hy1qb1ZkNsNh/zGNpcPsMhnSpYKBfiyJU5/DTJwdpwrBgCuwEmYaffoveFCzQoYefo7sihrGSoCLlA4KTDAsFpNFVXrWn86KNGDRKwDWyZllAUhWkHyCqreiDHuWMxBaHqSAXiqCgJderOtTJJjqGR8B7Wy06VIIEN5Ei3S2OMt0IiwbQqJLPDHrSzrbCryKfNLzzS27vN06YZG/2bpDMPaqMMw3jHUUf9wwN14phGYXV3InENntFsPOImCrjaNNbGSZUlrLE5jEZKsq4b1iOGgpgVg02TlSDRRFNvURxCDMaYCnigRKtyiNJSsBUxFrXe+nZMp3+0HaB8fPt97/N7nveNfR/o8n1jILuHALADHpqF5Z1VpKdur/h8iURZ9cmkDJG3rWhkmH+xKC3TAos49ipKcggSoGGcL0uiFjQBphIYBL6Kn03MxaB14ZNhFWADhBB9aQcSFnG/GEMoP1TE8TN3iDrMuiU4c83I1u133HFJxzNE/U+3X9Jx3nnn3n9m4/3rm5s3nXPh/TeeceZ1el4J1FWOYanS0KjPkd0tWxkAu3jX3kkYc7BzMr1Mc6SMIViS8NPOAIXvltXWHjskm5uTcNm4purK034IF2VpOryur89gsCRtCGCManjB+6ZVIeL83ZunaNmDuxFex8FbgMiP9DFBWAgCxYFCnyiTKYbGTjgJ5lkcuwsydWC+73ZgoDwRV1uUSiYzaiU89VB/8wgAEfHqS0a6rISBxWED4tBanMEzKKq1cTY5MM6Mab9i0jkzRWCkj905vlIN7zdCtxsP9/ebEyTJ8qwqzKs0oyFvZ8hu18QSPgNVGi3BM+5SqnJqykpHtVWTnwxj8AL9XgBbS+IRP8+TBoIXimhvBaexfHfd5Zd/8O7jl9xw/yU9NarX72s+75JLzrk3d+sVjzfeds1tL23f3HjZDfe206MDs1pq0F3apZnUyCajA+Mm+7UKBIm6UFtMWitLAi2KMZ1aF47BnaWG8Iai5cHcr7+rR4+E1W/6OP3SgrRAr4u4LZZk0mLT6ShAtRrwJx7kE4MNTU5hXqVAYjpMCXkjOaaurkV13kjMkbPplKoHh64EhP8irDJk2U845uxjo1QGyeVKK6UoddDhAFiC91kYJkmhhvbrzr3a7MQFaqciXZms4gif18cyHAODIm4ZKu+98toq0Oc4kiZjMg3E5jWZ+fqN9cE5iSBIMZxe1A3L20zVURG3PyknSCSZ4AGqaHI+RESVOoS2cS4tppKr9mIxgggERFIq79aBQi3SUIZuf8KYTqcb+n/b/tCzHzyw6bZrzj0n0H7CsfSPI2c0j9yx/vRzT79v/TtL6a7GZ9/4pthDlvFMJmMv2Ud3VWsyKhDO9n2nVZG+GFmmY0QgVQgDtsQQGViwciAWR4KspjbwWI+UJvahX5b+fuqZA/HyuhSDZTJ+A8vwPKNTa6EXTMOuTq2hK4gjq9DxPJ7ZrZDZ/jDIqxC8r0+7a1wLtsPuY59U/frrZzvBm6s+FgZlXhuFx1yLjpZMJi3qclG4jogEvAYG4xtur2/3uJ0C7rpydlgx9CDF0UQhjCEghNoUGdNR1056B834uExWW61S2Fu04fqp1QCB//TZSaepgJj51dD8UdUGutJUi5o5xlAuAX7XlqJqn66Kx1EUBBiCASxEwuHFIiEWEmo10R33STQtHbjwi/Kh9Fx/3UPbb93xwabGxvNuvP7DO8f9xcV0YOScC+HovL5gXswdDNT1GjfM9V/GoQyK0S4OHTNlB0wrGu3AaVW6teXpchlXxwI02GTpGI6gEOmrUuxWqJQqMM4/2fmxqVZtyT2/9NcXX7z0V6V3XSCZA4QiTqQKJCFBv0W2pY2X1CWNCsGFaUQUAeDKUYLgZWBMiuLK7Fgb5FuUD/7+1xe9eyHTzVNK5UnXHhdFEJnpSIFtKkVtjowNZwyFgF9GtzfoA0k+yTDog/vaWmbtcoyQnG4L/K/a2oYAw+8zkSSp1YybgEmhCo50EvgnD8JI/NNM4NTvlCkx0MdAPdoGNL4NDTRFunA8g4MdoMV4kEsQ/tT6/UUCwxF2TifRfJgmlIZ8e5G0kuGi8UyzE4lJ8f4b7r15x5u3bX13/Xk33HvdK68lxmvNl99/7oU3nrf8YccTFVFVrWtvDdCjWSWJuui2oeWd6YzJhYXDJs3OdBEHe2c0ioQVal8RanlE/qQMsDzwCBi550CBkH78y8Kdd+75/udL3//50gvOX9d5EB3VYn9E+twkHciLfhT6XFQqzd4yXspSmBjpBI0eCwOuAaHAG9pm97dAJP/BJw/9/PPXablcR4cIUXbSeNSvrpKbjkDYURfFoBnOhhM8J83MSHiZx3FE23YtvJtVVYYgBTrB4moTWAtQKM26wu6EjywrZdwizg76iosqpYnjYMMd+rXqEznEbCAjpVbptG2AmbWyoYFJRAJvmqKio1obJrI4jxUW4sa6tYUlOk0XCfj0YiFuJZecUnm+0p/GSW56eaHrvsfffLhx01uXn3ND/NYPvtzxue5A8zmnn3Pe1q4nbmhuXK16cbi3fsejXi+bKBenHBgZW3NoBvZyo2jGX1xGQRnDhYNQBU8wPlmbxLGMClss6uDJl6sZZLjqygfjXddfdf49237edtGpp8J6arMl1x/Wbne42OfRLxHAL9UaezkMoYJsifflibBAiLCJ23ZlDzKmloHq6rGxoWs//vef7/8muDAh8Dp44DKcA2w3JeAk1MZiNhACgDJmKpVEGEI1UPlfe+0PR+1TsHA/siwRVpmu/OoruOUHVMtOZzDBD8cSq+myCoxrrU6mrh2o4kAKQCwCIKnahQu6WDpaXQ1Y1YVJCFRlIouoKZBfIUMO15vNPe3tg4OS1VckiwWC8SVWRZH2NATnzJLfwgP2OxSv+e2dZ++844zrtr6jv+LeGzo6ep79qOPGG9cH76tEt88UZePRxXirNeMQiyVhimqXyPa1qv1tOMmEabNZbV9ZAWcLIYSAvsHKe1KwG3JSXZkgAIdjAW73rit/7//+/J+33bNt28knb4P1HF0pubwvm0MCCUT+t4hOCy91hiQcWXtJHRE5jg8ZbJRWsyvryiA6QLQQLB17cvjQv19s/7AQgHsBiCQnuBSoS4VROCOSvMXC64jNjeu3SBZoIF2xXwtzpN8bM8E/4jw5XVa23PIVsHWbTQisziVoTI0jfiX0LQzXDvtR06hLR9K0YINNSpfLaAznWUaHRKshxOycT/t5CnhtMoqDK4AilPHZLb0b+3vNevNcoACclCBXp1gl7z7wxt1qP0UwB9XhNPHbAWPvzXcCgzhnZP3lG7d2XK7ffPUTQXNhUdrQc4NZPmp3EMFmWm/D/PtNmPCm5KhdlVUPucq4H58uT0YVplEHitOiu5BYkPQuoIUmXGSXCAj9oSGmqnYXdui2899//9LzL9p2wc/rvEduZVvgQB1Ia7Fg1ucJPyavftAFpWQZn1R5BZeK52C/uExtGoeKECAo93/7L/aH/re6OdGfU1Tt5iI+W5WSwnRwVLK0cIQ5fXjZpuvqBXBB5WUwhCCyqZBxFJCoMGqqHvtq32z2z1VDpzNAqoH3lxXVkNTRqkBi8bzIkzxusHAktjfpB82FM30iwWuVJgWE8yiDkLKBWNDqtCiYG3XtrZdtaK0zLyRokScCRVLymRdI9WC87uliFUlK5kGLUh0u9Br7H3q345tzLly//pKtzTe+09O5sWZmNYyoe2c2mXOEEysaO5hRdVQ71lJd33r78k6fYui9NsqhVULuUqMFAseFfZ6eusQSyeswoFq0vj8ehrIwE84jCNhgha+/+Ovfl75/6aVX13lt0ZLLrf8tPxkO84Shz9lHs8qVKvTIDBxXLWJIKh1MEgSxWiEfRfE/iAzE95QHwQFy8JWamgYC7HsEIXwRr5gEh463IQyP5SipZsfNmzYIGhOYcQoNDJAaa5NzUOYyDKeuvhLakZTdDG0mcB2Mm5dBZEmRDJCiP0aQbIiO4TpcIEmoxNPpshKbDhhClDlls3EGhuBQx1Qno9VmUIwiRGOwof2xjXWenl49XO86qLEE35w1kDcaPU0yfyReVxer/VWuyhvFPTd/uXX9JbA/Ozo6blw/NbN6eHlYtbj46symxjue+HHzVHDkLlMIupyiaxWnpDM3aca+yqJRral619hKhksLOE3TqbxTL1AGHkUtvb1di2AMg+PHSoeGoT6myd4/D/1uNq6ts0B9Y8kHExbDHwLD2QSpz+dV12ZsBgOqRBUKCoggYwGzCZpcRjFRMHBgt2d4XqfG6yGoncD8AZGwGFhDyG3hHBkEpRjK765s73riqX5vFJjXuAYwt8bkQpOWCQNPAbob2zfgsKSmlqHbks2VALLhGKZUO2Bzc0mBZwwh2OB8OCxKEq2ToWoEkJVosTCc32KxZfBBor6bA1yHuth4XU9i412P3PW2xxiX+JhIGETCai74nGZzMSZzeoyP8j/8BBHwwmdLl3058uWNlzRf+GVzc/PIE3XDn6XVWlw2LRbr2gGCzodbm9vVSW3LbGhQdyhe2Pju9NCAw5FzZNTRDMolpEk5vFesFM4A9CGy49H8M+alYXnOry0caeuImaTDlkxk4fXjf40r1hkYytZnVfL53yIWW/LIgvp8KkW6qbXOZhpQyEpM8shfYwgqk41C+YLb1ODVQu3usrZu2bHdChZznrYIBKwDfLCNIvSPbLyrfWNra/vy3p1te6eBbra0uVzZbCbkTYWSR2JMMBvblrv9kWlU+6BKSKSSYcqhCvuKPtJgY80JmsDlOWxaoAnxDyhiEaVLleAZkRAZgXUnD9q0hqb5eiHnwn2dfZARrHvh7khwbiG4RBdoQqLjwaJ5yrxE5yDVEwnmSw/uGkPm0Fjhjus+uOaLGzZd8tqNI182//jk0c+fdtRQy7VhzLq18fIdMwRGdyVwaAEZw7PTwzNz8MyjiI3j1Bw+PV9OV/gHNeNV0K5H0PnCwexkmKGh6AGDYu/C1A29vy3h0+ndmb//hkx41+/rJgwWi/Xzt5t69BIhwIgmNiQF1NmY+e5upy27YkdBPBVoMclBUgku75yNUykghggH9H0zW2ZaBwOJ1dYfZ+riTQ19zEHf3TuufnhLzWBTk9XLOqphHL5dm9313n40w/hwBLdNajX22a+GagcGJKcweuRQsrAiuBQIkhSJPFQRQOURKOz8eBoPC8V83i3iRNjWY7XYCMIQaB3MoIJbaG+6yy0RQQ+hd/b195gFvJhIHLmO5qy0NX5AX1e34EwxNsTv7otkIXpHO4k54suRD3oP/b5n5JKOTY0jd0Z23nTalRpLqHLsx8PvNG6oj02qptyljH3fLrs2cNNqbPMjDT4bmkFH8XBZqawcZrWjGrX8ybaIPh0QzMa0SgeGnXuRlArxl8zEUtFht2P5+KG/33nqpXUhS3KiE85avddJ0oKFpUGA8qhtWhqsrCmz2WiSseQDLHdQxMXceIlKklztziOUx9dfAfZP6Oa27Hj65Y2XrR9p3rHl9jdbmyJWn+RlwaZzZIdq5cqSZv9sm5ZLkrhGAxmmFrDVtVHmcEoX9stwwWIQgWzJlP5wOGBN+CwMJCCVURAjNGDMYqDPK5BWp+TxGCxFNmG862mL966GGnPf3T5nU1Onx7Nk7aHBkOOl1QVzsbAwt5QK5OPGuD7vppQ5wdlHABSenG43q/LXNX8QjOae2bp1ZMMdHVs7NoSh33tmNTG8FzPO1PcSSv6w5AwNZe1yH447+7t2bPYZFFCGczK7Ha8cXlX5AckfW2sl+EBwx5ZYFY75f5wp/yRf2749qIvF1/B0eK+08Nf33/8Mz7sllLIOepy+QMrtBp3UKQocjbpkuUxOi0+4qIMhr1sUGEZkorN2HflbJ0S8W+S6ghWSBQgeSOi7G5o+9+zYsGFLe/2nndJ0ehJ4udJV1QaXpdYxml1ZMWVL1dful2uAfA3BsMxUeMpipzLaMGdjRIsN9eNEmQ4USAEqdDKMBQo0z9MiUQwUF3oPWPVm59wcLQhEX97YMLcaDwbJyBQdaHqWSaXIXmeuhALHW1jUW60FX7yyRjYYrYnAKgMFm+QL17bBD58evrLrtq3XbZ8zvlqJr7/zg5GRxh85iKDcdJLW+U1Njdhr7ItGZdrR/d/aqwcq08bWmpo7WhPpIY22asW+ojLeXhEN0toncmqB0OX8q6sbKstGs2o1Nv587PFX3+n1SeSaeWl5cc9L3196/rZ1eYvB7dU79YlUgDVYDlqAhgo4MhqFObeBwfl5ioGrJmRhWCIkaMfsOPnMN2tluUKtczppzsEenBh8ORKsN9bfVf9M0EonDaxLDtJ8bAwCx7PVLgoClNVZMDIg06nYNTs7NNZWbq+vCCFnymbAlRbSwBgmQgFWINhAgGD5OetgwmqewwlWotPhfuOBZz+M5K0LEhii4GQU6zxBc4DOlsCbJiIGZ7E4A94GqjtSd3r69ITHaLz9U2PBRy9U4AzNe6yiTmk35YZNpkceBXh83Y+/9f326p13bLnt1hwbktlP++zNOzfNeG4qPHygj8gltGBUz9rLuvr2P2ZqjARercxFS9xy6OZI5Q8yfm/X28+0EnIkXDEXhyeLyypcM6A78MUXe+bnE2lp4e+Fvy+4Z9v599wD/DMEyxk0J7wkaaMcyQmvwcDJILUzStG0s8LCNWApWwzCQYPosGsYomfkvC8O5FP+REigkDJtHQxa5w937emxBrwCjmTaYPTjdNs+KDAVDgq3UZAVy8IRCuu5f99+k6lFgTZslBysj+Es1VjYwtgOwmBNMRIh2IK0VJTqent7+hB0Dp4GEsyu3t6nPXpzd0GC6yhJFOM98cG8GLYmWSmUr/csFcQwhrs305LZavVZfXnnH309TpJNrJmnY7GYqFb8lv8jH5yfMBh67tvafM41+Q8P3Noo7by5Y8fWGSJXK95x582eSNfNz/YECAdLje2zrygWD5s5abOnG5OrwiqlA6E+bJTVLSzE77t5z331oyY5saw6bQx6Hm765DPMv2fmnX4fCXLMXPmzd9u2n3++5+J1+og30uOJOKVUH49BgkYwGEI2osKNlsgpd3frvMXCWniLYGOSaKlNizPOrq+/v2Dkbd7NYDouqoQ+iIaeul4z4XO7GVwBCtsFRCQzMcGyLAovoJ1R2J3QmmZ32Rgfv+YbxGrLYdTlTvkZoG2MweDtC3UGaJEk8PRcX4QyT/lwSWAZEFmRno1vOyNWJ42jGbA0c6I1fvsWY47iE/NWa9PgakKYtvCMp2BecDpTZh/LSsWwAdzuMmSPwF+CmKTqwy+310fo8OcfNXdc2HzvszdsvTm/6cZz77/kx996n7jkvPWNEFF49b7exXGMxge+WokWyEo65rcG55FxNQe+jlLz6p1Traql9KS/8Gwo26ajy0qNip4r7nzybPUPSzP9nSKm9pNzf/89c+nP20BzrjPqP/W87XE6rcbDCzGtkhLcE14GBd+cmrdSgTVAlQAybUnAxDAtNINbQom1+NNP8zwLhhGGxiQpQQQ6E9w0i5dttbPHjQ3Yue6XQ5++3XQ3bKmDECLKyFpgOcdM2lHWS8OfascpTqdLzLOoI0PZ4DjxhkQ6wELBlVGTYR2+5gtBmpyHpIQj+fLnn3v6ArSEaQGjlWpzMXFpiVbrndMkQU47V6cOzycctsENwYQz4UtIJAnHPAuPTQkkHwq2s9M2dtovGKaTETd8sPX+CzvOubFjZOsHHc0d9z9x+PJLLj9v/W033Nf1TtdlNbHqNiVa2s9SdHFSthcBTVxV5UBhPTHHDdfcZyTiVburYpcZ2qqHD01Kd5tVsdiTv9YO/3qotyYPZm2OX9jzz/vb7rkHFnSd5+kej0fvCwSslYSAqm2MN5VKUkqHjcFBtGddNs5iADKcBDMD1TGEO5QiGRyxeeG4ZYjBrm4y4fOCtrFkHa7q/W2Q+KbWNt892LC5r9trsPC2jEu7CxJJ8nI54SSRXUOzQ5zNgiTf7oyOllyoI0lbWZFkBFg+ZIJDCRJPI7uzA6MYuE85TFWo8/RCuEH0w+lD2VyOUQdem810MyrISCAI3Ou3r1bW2Jq7+nwRZ0rg4OgIWQw8ZiqVEHM7Tf1xOLOitIRIjL1sffON9zffCL+Nxm9GNvEnfjcDROSMA574lpn+y36c4RTlVQ30uGdGxwZ2Q3Qgq8LAXIy67m76UV3AFJKKpskaXv2rf65M9iUQGINRvTisii0/U6BySkRcePXne+459fxt205d93Rdz28vd04Ewn/+mcYwlOctE24vB980LtPAiTKK2whAQgRUQIB2km53YsKQMUUNCV+n1xvxvpwSDKmJbjzrKmfaWsZalPJwZ1OD3trUbn7Zu8ByWvgc733VwoXmK4fDYDJ/Jdeg0z4sNZjTlsAUySQlp491jKoBelOdhEPpd5VWhvaPafw6gWRjiGdz0Bh0i5RLGXVZDAkWoJPeeli9E6ahKSHxyJGpdDhMRt6MpEKJlACUENYzGUiFSNKzoXVOLG7szoUGG9bmgg81bh3paIZfX95x3rP5usb23j0z668787nP+1/dtP3xdxs3LphWNSUUEpL2Km22elyxN81RmYwy9fhWYpxwqeOv5a0VRcuv8T1z6UNOwl/bhsG7I/6xUFmAsju5dO/3sJynHkFM63p6PuxLhSz4+P6jZncDh4Dz0h2CIl+ICo7pZNnrxSKRiN4s8TbKhiBMzhJiMRllfbk7GYrAxzEGd3dnKFxW2Xcpxo67dl+081NP92ClpzPidJK2qAZuprbdGYewFl7Junbt06BRZLUzkKDgpsIQEJCMW6CAZ0Mbt1oqcJC1h6HP2VG/haN5fJL2NDUEaQGNuuAhedkTPFwh0TQf4LSQhJyEpvDM3t1ZLZ6IBvXdTrM1xLIhb2hiYnXjY4880vDClhqoJEJu2rfqzMfrW/v3bPmx5sCmq+94rfUhY6QmaD48s2FTa1389imk9bwdO6ZcrpVMdMVeygy7tCatHEMoDlfKKf0DPcomZLh+x6FYUQOzGfbsiQXiS0VUHoothuf6D/fH+3Ai/sXPJwOrO/+eq85a17S5s9NtSYJ1P5bF4TKaEAwWxgJiu3MiLzDTlSaPZ3PKrc9PwM8BxomWlG6L6A/MuxMME6JBVqe6UxOUq3Z/y9gt7+3X4pZOr9MLO9wbSHkF09D+fV8pHZawA4MkrcvUohQoJU7okmCfGUDGMrokfC2bwwVxpyog9yK06gOHwZclq8QSEGEjXp7q5CG4BIXpgrFnaurwchnRinQIz8hGNVGZbBfkOLTawQ31g6n54NPBuP7t4J53nnnovsse39ywZWN7EaxGmvT5rNb5ZT+y3GPsr9lydWNXsBBIh39aHjQa42ZDiLi9sbGyvKxCvd0k1MCyHJreqzqCsdVYCQ17phHs9kn/W8GqUVl12t/ftefQnv65gFxWJtLh5f537n1qu7Hr1fNPPeWUU+/5j6qzC06jCsNwxwsvvNKqEzXWaVAwGtesPxWFjLruomBxTFBBNwIiRlk2IK3drAisGoqSbCC4jFiQhRCJg7GoQ40jJhCM0YjRmjCNisY4qE2mbYzV6uiM9eeLPxcy7U1mMk1Pzp7zfe/7vN8+8vB7j2yZ4vkkUQVPzp2xEi7CVQU9IkBkDKyoMYjHF8VqRNDQBIObCYLQSsv3F49KvU7ekQdeI+OxSLeyBosdMIfPvgHdozVnwbOCi8lIZASnlGzbPrfnfnudgcJbVi4eLh7E624EbjcuYLXAToJzmWPDHsRq0XKcTALrCT17KNxRWU4se3Ho5sjIcBpjYT1lEo9OlWqMIc+1jrEIoAq4ZbYIIN6euS8milKaTC0aE2uVFlUcTUU/P77U0g8leVe/xizZ5Kk8YKxWvZPlcgc8+bgyqSHDXq0cnFwICfzwtU0bghm3MrB1t4e8IpWtgU0GGQDQYYCfiE3+4gol+8LfNjv2dcjlHY7I8rcDS6ldyq0vgwgGA7lWVbuev34n+dPDm+t55unwZ0swH4TnNpvM0gE6mRWy2SxJBYgqQeuQpkTIVmbhZPK4qoFkMkBY+6STrZOUOh8MuCwKQCBGQGNf75mY22rvtE82l7UWQln24FaLpRWspB4gc9vElePw6ovYSBEJBtka8jVSZ+iABbZNJnhgnO5DMognzCq9OCCSYVLUgQWkXJuZWVvdxDwKR17UUCFAzZAxJhuPe+09h8tendgAIzNkh/xYz8SIvGY08qyH8fkDFPTMKrShlPwcRocfvbuli5lUSAzwswCOieAeSWhsZRF+YXSJJAueZtAQRiYO90B+B7E3vdnUM/L+tjqDa9/c9hxESprbYS6JRGRPxFMeR5hSke2VmR/N4rImPYNG49Fp98Q2VqIot+/79sfflo6B0QGH5xmnP3zm6WecviW5kOcBEXEIXiaJYaRDR/pLwWAgwGagjGzPMSRhjc0SOJF0VTNV6JTortv33h5kc/ffBLtvok2xfeKbOQssoR0YJlswixMe0PWBKeyEMJZC3Fjk6+WRthBOwC5s/ujdph8SJ+qIVWkw0An9i05zTeYOz0ClQysRZUNH6iiuIiTwOtlYFpfNSnLeq+wA7WGfUhDmB05wWgvNje3TxaNut2R2fWSix71h3PvCyopHhG8l1VMRZzzRUY71zR8YOvJ6N+WRcZyVAMUV/GR8Y2NtDR9LzJxokIuLIquA1QRgvBO6jZ6Rbc2AUOyrMwdj78svBahCAvGxmIytz6x9u09qS10Dv6hvO6JY7ds3136RmOMz4bkMAZF18De/+3j12E+wnrA/z/h7k24J8AV/PHJofgqqJj9GYhE/Gi9hQa9dYs9ZYpYVhnMrRggaqm6DxZCRLO70TemTmVjnZ+/cD92jXHH/yLoFTCGDFVco6HxeY2Jsrc2XThwe+aLI8SdmOOl6JmAm4FCIyWHKH3iIi57N7Z6xWqr6eYbT4l4vlQUBBGEbq414nKI55dpm+mFmFWcdGK4EEPHgWEUXPzDP+PVBRFG0KY0+Vbwe6ywWpcxKnPrt4J42fGZGhJ9eh4swApFBd/e/gKpQHZNlWbeSDbXHIEgG1sWbzTEt1BMYRXoLlq09cz3wBhbwwr6Y64R87RgHhIVC2/TuVtlvdYm9WWZr+7rWN9aeRIzd0dXK6vLxGYO5z6wLJ3Rjbe+b2zplQMICt7/8HqznmbCU8LTD3y00b9Knx32mQwsOP+Ylhbg/rvOXKBzKllmoi4sKho0pBJ7mCLs9U+jqwjIBawbc3s96XvpsDyQKekZiOE/ngwRkaAyFfJAkMjb7/TDE2I7k3HVo/o4XCNZtsdma5e8DNjMZkrqrZCBAwBITjhLNWnK4SDEzXijRzT82RIZKVCrxuI4hV6HoSdQ8UCJx3l+P/BrxZtWo19JsO+r1+1A/jyAEvoFbM+uXyhVFhVZiEJeZaoCdwU0vvtiS7tVEspT3RL3t0uYyIDqz74+M7JFv8lnNoJAlcMLMuoEjbdo+B+OyAJ8ryjsStRrOcW5Jc3uoXmvP1dzFcqe0fat3b8L3bEPXMbO6VpF09B1ZVg2gM53Y6tfNy/i774/0dCz99DCs5+mwPzcf99O35KcG0+lB1ZRes8Az0HTwOp2jpCNZG+eaypo0NJ+t2WmhFFBKY6ZnnobkrcVii3121xeb45B/Wxv54qDoa9E78zS0jixzgq257RZtbOSbdYRZeOEN6tuNuie7EAi4DFpFc3H9fWBxJ3EmSAdgOQHzIbJepCqQAgOp4D5AoZVwJVAuEVWRkPnivI5KBskRFRL7FcMJYWH4BmhqeVdACT3E4JAwm1ufhZ7AknvpsFxqmwwHaAK3hMPOA70H1EcGGkz4aO3SkYmz5IpJK6vtOQzxGgiAjRThVe0HEbsNINdc67bT5r755v6Pka8PHuQCJwJr9XpI0nywPRaThoo9B4GC7mt5kVB1VypQIykrk5PtldTSAFppD5/ak+g6+LXs2x/ju8AohpPz3wvpjC1ThwYH04NpE4YVsmJA1MEZKlIFMlz4xejbfbsm7AyGM1ot1DXM55ogETYocorW7Xe98wWMn5z47t0JacFoYkWXq+p2uwKstrxNDgjqyBzCLPJTpqQSzsCIRrOSF4IBi+LSbU373EoDQyYJNmOgHDxr8Cb8OowsYeaEF5fJuA4P4MW1mWgKBU99jSolOLcHayQYgmOzmKP/02s8mQAPBNNRc0nAOWlbLGaPZYqzfbJJpYckl1nQGjLm4ReHh0bTfq8yoyjOAbEtdTPGjfrWl3omeorbe9bl68BlAh/+3XdP9IAMBtsT8mGKWA7nEHd7W669WQFuY1PHyKx7m0LZ2x1RChuw7eGNPvvA929NTEfRmaazTmle8shVT39y8reln356D5qjzYd9c4tucRzSz88f0mOOSJISsiXSEaEYCnMF8miX8XOj10AEcFd+d4vPt3tDi4O5k8lJbPC0v/PNXLGzKC9X+Q3p4b9VZ5bPau3S2GxPEYi/gl3EPYzGOeXQLTr0TkEQ/SYWHidch+osJcwBdR/p9zmzQZ0KE8hsAiuBX0FWWBzSE15HKpWKLK+SZEKZWK2QoIwuVygSU3346WsBLcGyrQjHuJyYAfS0daXJ2dk0hlNw+Ot0VIX2KqsCWErjLf4SSXFacBQ63OJGgXZnACJ252zrkJIAsqydy23fLI4h6ATmOigTrW3tgCXJ35c3tyIIIKxucLTKivgbCzSXFVgnKA5N8lZABxFI7+yzn1VuoMWF/dHVEz/88urAlz9B7/7w5iMP93s8qHc6nVP5hYUkkfF6MczhzTJi0ukMOjWaSYVMLkdYFvTy+Jq0Z5Y9bj1qs3f2ACOmUGQ0zsLKoKaQtQdWFl0sZ80ppFpp5wgSojZWVhglRVF8ROfXoFNTpMB3mVy4gfL70YGkSaVuUWlQ/7wTi0MDRApCEOOFSjKPORwCVmLiIBovry1DHTqzTJ6gWDaJ/Uo6jkx/8MEDKJsVSZqPO0RzKxcO2GIdgaJdu6xRa+AepVCRpmiawUZbUnGdl6FIpuv277uMrFsE/QHxMrWDTa2caJBKv0bw+tdtl/YcnoshgIEBkbU55UgO/o68rdXDuaG64moyBW789IG7lYMCVeAklFVq8yhlXkhClQ/Hfv29nbju8s9/+2Vp/8k/Tx776TJY0TM3F3QLGsy7+PyCSW+gg0nQPktKWcIhoFR5tsPdKi/PHlyz40V7MYb8ZmaPb8Rq9dysok1WXJdPfv600bjz+w2KqB8/vsFKOyFhpWgrH9zYreSUuNIk0Dq1XoioHBGMFLKksaC1U4VF37DPRFCmfo3vSRA2A0LUhxZIUsBQB1nK85GoCtUUHP4GNlNJzIirZKPRoJU4JkCTdvdXnz6wF/VWHDqdM5r2q9QbOvVuwO0CGSaBqkz6SFe0BaVWKzMiSaYiqMpPwnddcvV93a51oeql9i36CtqObVwXT1vdiJULjYXG6mM1Awu8+hoLA14hfAM1LZCkMoQDK8xbQ/DFu9/qekFRclCFQpsyUEKHFnWfIxOxHunydDz0yiOP7B849uUfJ0+e/PI9YG12PHL65nrmg1mXkMecLhCEXPmkI0IyOsGhJ3vkcPpMdCpCa20y4ObKYO2A8yyHG8UOoTBgdKQktAAukmG1Wd5ltZVv+mx7TIGvdKsB9UUEinTSfnTcpDo0iA76g1nRZDhKqgrxXU9uOJExKeHsGt2AYpei1dFUKtrSm0474iqShFAjWqpAgb+swyB9eyTlxzBvlsRMJtQ0/OkNLXH4cgLK9tG4V4wvarqOb+RGkOOi36FKRVJRjdqnKvgbEZ1DlYZjy8yQ+y+67YYyX3XtXkRCXaxdZqPJRK1dqs1YtJOTmerKIsUBBIIfhFGa8KcHXmAH8WjE2iFSKVUYN/d/EPVr090UkmDDcWxwNLprV+JSBUKu9jWiF1x5wdKxHV++evL3pZPHdpx7+Y5rjz3yd39UDdCwR62Bqmv8wJDe6cDNt14ImJTspZHZzmY3lJMg1cUUOeCiijAooLmtNVZ+ojW/W73Uks5nWWkzTGswWBQTp+xhWrqfvX13r37Fy+SDg2+YjiaDmGNhSo9hQtBV4BmTQ4g7KM4ZemkExi0twVdRFxeJN1QoekTFkMf9CVzQLeNWqz2nhEqYZDD0yBRYHdi4ST+qp/BFH69j8IR/VJ0eUKtKEZPOjKodeF9CHFCpUJWO5NW+eEpVYsxe/a8Y6WJc2U9uvk+vLWx0HV/XEUq2rb1P+kQHJE+OGixhyyQHoi0ohWyoVb61dTvkIUZe6uncpGxwfDHr1bFcX8sdu300/2hEaf5WqeM4M6dMzK7Ll+IyT3TXY18+P/3e9funVb82ll9976Id+082Tr738BZ+IZB1GSzFZDWZHxw6ILbKiJVXn370dqN7Tm6zx7bLY4paBkoLmR0iZJAf6dRuKxa1uz/4Hotect+t1q2QC95uVczOfXP/4uDu7u40ylctVr6lv/+A07VgMjlNfswR54Vk0JsNgimMLVd4q42YygqjA6RZdCl5Zxaj4DrhcEic1twSiRtUFwtk1MCKx+KA9rPk4IEDJueUYG6kYI3xSvej0aXU56mB7tGCf7RlqeHxJEgq4lhZrTRQNO7H/N5ExWFmswy4eA10cXu7tnRnf2EyS7FHlR5bWRpicYazGMKetTqHaJu2dYTWxuq5zpe+ODxyP1xU+D63toPBM0rIP6iNPnXL6K0tpnq9JiMrSg+BfHN4faPBqQZ2ffn5wM4dX56M/4p52h5974L3Pjn5+yfHztySXwgGDQpAblxEhgYvs3cv/FpdgRO/jPUUFUVYOsX2HEDA8H+0xDrlwLFry9JfbvhkZ1zyufPO501uMBakloxUYVvZUD/9+ebdktV6jT40mMzz+imnz5l3rOiCBR3jCgb3jk+BsgZBD4gpBac/SbNmpYfOJ82EWfSGPKDlA/0bAnPa1ocL6QUXhwlKhBacL86nBxeCfFCn7/I5F9Ajj6odGhRV773hGnVvN7Tsfd5KhSqB560r+KEbAUJEwMxhIL87LJZk8HZvfOct9wkUMHgEI2ozHFXYoMx4HYjbQqIGU5u+/rp+vNa82b5C+LGVZWvcmlViQeyzmUb3V/0q9FV1KlLHQzZG0R6ctxiKdtWSaumX6PO7Hr0Otuf8r7/inle/vAfgpWM/Qf3pdJpck4TB5LOGAwJBBI17DW6IcYoiwyCW9dzB+hdQUygO71HkYNBsLMfOuCc37rzzBN4h4WS/fOJXnuAAmeNqBleQp0BRcQWTyGzYtKDRF7AgH8GcEUfeQcZpCi1Q0zt27LjggvdKBUOMcAlph8fiBrImYOUslioN8S0oWSRgFZNmxI1jh3iaCAos5/X3jvcOjk8tHIJVVaNB2r8U90cjJj+a2qlG4QMryFRUMw0y4i+V4pGIg4QGga7QGTfnXomMfv9g+q37BnSfPqsTwKMyKF1gNWVFcTVhtc7oxFrzpVvbfhjbwOEkgyQHDNRiAaXAEQ9DwemLeHSAgcWtVSi97BkwRbGwEnNaolGdajV6w3VL+3fsfxpVHRnddd2X1x67/qcrz7z44i3j43qLoRpYpAU+mEzRRxf547WctK15z/Ycz8zO1t6FgTMT7QppcQLI5c73t8Wy4Vazf9nch7hnCoEM/Xk34zMJNq3LZQ0zdDaYzHbIgodS0DIJ2Xm9c2plweSMOjHfblP05PQ0WP4DfsHP5/mS2QLxWyUX5jgiwNIsZJZjChvg/5OhGhQIwc3jb4qnBUqvH59HVTw/PzyU7jK6klhq3jE1CA2lamB4FE3R/oYOqMD48jLmj5ARB4bpVsmk4DVzhAkj51um73z8lTsbjkviFQIYN0TGhGAAlJitGDq4lQJec7c+IWn/dmZMATmznj0wgB0JjY0h9RlmRVlTxBB2UZYUEC3NGGI9fcIGKaMKLm002liuqHY+/8vzP+2fHgUJ9Jbrr7v+vcsve/h0WM/53ryWzgpddH4BMw0sEbfsFxXFkc1K163XMJCqLm52PPJte6BhG5mbUHCZqiCQfucKZbpDXVftuu3K27oPjft4mhJFd47Cq8G8cYhI0lNOk9FkHDQ6KZLKkg7No5+rKokODyaWXIcODC4EDAal1WoWRZLC8tBDIm1bIQUGnYrUsy+ktLh4DOMdpRJfSEI73BuZMg2qp4efHla7KDTdFY1DSdA1WtJ0D49GdXHUL3i9JUnFX4qTGDTLAhQd5jCnuvGGvS9ec/fNN964+O33nwiJUKws79nzxFaFLAS6U1jbPlYD1AekudgkiNhN7ZuvOmqHGBV8EdkntYa42aLbj4ZtLoMhR3CyCYsU2qMCk7Pr0EZtrfH08wM7Lttx/auf7L/n2DnX7zj7ssse2VzPveMLRBAKQVTku6wFTUHULWqLI4eB63bXT7AyaZadLd5//2FAEb7IKdhswCpTwuUyZcL0L9x3Tcvb51107hV33jB4iFjhkwbXxgnuxCK1aNRQgnr3kBptSTsxU5o3+gu6rmmSwKIqSqSxIZ6mA0eBjYQjzwHtJukkaXhJLCwobNF2iVemxFNdTgeWBt06Pa+KGgfhsVYtjb4+/IJ6Ch3tf+P2lv750gCKtQy9oO/1R1RoiYRqN7FKzZygdPHG6qpopolE6obzP/jg8bdf++qcXUeeWVrQiLERuE/3XNrsrkE2o63cDGAbwOQgHkOKvg3GoEjhgZHY4AfZvrU1hNQTOQkrLAQzQHLEiKpUYgUGDIhrSRMZxZUDj8anXwXD6PJ7ju24/IorLrjgsguuPPOMi8/YMn6ID/L5waq1XOOZfBZ0YmsVhN963YZY7h+xKQwG9xfvzH0GAeD1dUMwz0onEZbGHKb0649/cP4N599z7dUfvPbVh3p00FRgcbgG3SxL9w7qBzUan7r/9rQGCw5Fxo1GoeDNeAF2XRXJguCyGGh+Cm2ZT81DDxPH+GA2t+3dclkB0QiwQALCaPf8PEpqNPr0gUHSleedJkd6d//wkDqu2f3622+//dUd6mg83vh1YHRgKEX6B3UljKZKldC2JxRKNNKoVBi/yzt672uPf/raHW8/fvNTbwwNvfG2T7te3A7DBaGhhDRAeSukvutr2ifkm2+f3lMEs9WN5PpybTCXcPsTzUitCZ8pLHq19BTFga7AGTrtvBPOe8TdpH60fvz86TUw4cAiPveRy8696spz/244L7749C3jJlDo83mBr2pt3pW8lmOCTKAmdWutRy09RUsmwLGgFllzObsUYfNBK+DW5mAkOrrz2nOuvmTndftveX7n3Q/e0dKlMsZPfP0mvPlNq0UyRMFo7O1uaentfSPl8A86nEZncMq3ksATWLRBMhRNqW7du4DpBw9hAs2ipqDL2takaC9LISiImAU0lWoZTkf0PCs6In5/ZBCADdMueHhRB9r/yhvDH749BPq34O3w+/2p1LJfptP5xVW/Ci+OxAQHxL0rpH+5cuTGnQ88/uCDXz342rN3D19z9zX9jAJGdE9KtVxOsa0ICyvDRRGXtG/NNW3tVMC/DYKIO7d1OxxvT0C4ouxJiDpl0wy7z8u6aKVZihCopgQsF9ISiR67+tXj0++B7gmq/ObndOiNLt78bFmYWkiSwanScZ/VUHWmAhnQ4bVSuwG8QlapLeZy8AvpdEvBYaQBDMtBQpNY6B3d9eT5519/2yU3XtcVR++8+8YH7lb7dcybzfJLZyEwHmt1T2JqjXpA/Xb/oan5lq6WLtOKRq9x8ozZr1Kt4irf63c//gb09/l5jGY2SB8F9pU20wHB+wxnEOMmVQrF6lQ8D+qhf2ioV2/UpCM7H1UPJn3GO+5Ox9PDDjLpEjChEUmpI5G441mS1EVAFGWqy1GHGUQVLEtV0Ol7H3/tzmdfv+Max/zjD31/u7FgQWRWJYjXB+3lYsymkMo4MOu4dklbERpAGWtwc9p2mBK3vr5tXd4DdheVr9qlsI1oL2uxlGXBJMoTUql1gdx10auruld/+kdU2vxc/N8H+qM83Moryaef99FHiczkUanFIFqIo7bJQECLG+z2ubn1kZFZqSVAgElhUPTYKd+B7uFbP915/mMXnv+aXnbjtfc+8MD5+kXC2jFbXAcprA0WhxDR3Te0pI3PPu3TaNBISzqicar4wqIDValVfnUKvWNYk0ZL2fE0TRJko27JHKUdEbHOgBDXYEypKAO6PXDcIM2++AIqAG6Gzo/nXdjQNa+ocZaJi0kz5C1eHD0yrB6IxpN7/VA2mYwaU8SfIoFgqmACmDejL9xx651vv9E/ZN47NP1sv8YB+hjQL96OTrs2Ntsqc0u+xuG2zE2W19fXy0AcuIHriYH7DpG3NqSmJLIlAaYUhKhsXesOrZjveH1QC3S2dIa88bbIpHn/I2fCQv7vc9VFW/QLTle1Wh2889abvw9mDEAAS22WoDNrKQTYUFPr+uzhoq3YaevMEVV6atxUnbWZBrqnn9154+03X/jWjTfcfudDdzx6x62P366ctNo2Z33JW910liD82G6jsQWukd5n0TiWVjkO5R2OlZVFXtXbBcuJgTl+99tHTNGpLJllDXhNGWL08YiYZTCG4yLqNMkQtEgnoansShcETH9Nl99ECQeGH3wjKnp14CZbw5xwYGD6CBT2mjCtyWIlgChMqmhKFBNhQGkrpb+4OtfeROoojPcjeI26VuOorVu1OusFd6mxTIAuUzA4sBkQylCkUijDSDEIVWgtF8uthYI0olCkIKlEsAFC1IVqTb0gNQFl3VhXGuMtoqkmvtD4yrO+MfoBNlv+/C/nPM/vPERaLN3FizWXGE+SsU07GuV5g1TR1xi7d//WL0W7926/9emLn7+lDuYW2U888dWr2qZsAaJM2fvPQ6QT/EZkX2vNRXtrML29OjosWnit3LO4CD6ornOvGTg3bz78I6znFf9dz/t+/mKAZLoIGS1CO+P7/fJYG2/j7S9HFWh7lK3Xyt7+iL0PzIWZpx/KGIOoxRNqs7Fa3qW0yCfHZ0+NnIuHXXIxgiDLykOH6PLmPDms1ea8zSLjrqc3VaF4K8KiTQVQqSky6BGoIvywy5mIuamygV+qdnE4s2XrmPU9Yy+BOhMm9NKXbjSGUpU8nzIDr2OMRlEEN441GlgsgAdbISQcjvxwCd7vRbjsHD8hSICQRPANb4iPu91RHO4GQSTlgPozqcDSFenszs5OSBks1qFXEwTNvsjxb99YucMiWUp0460QX3nNk+xFxnf+IZCVH2vyNDArwL78S5X7T+7r+ylFB6A9AwzxXnfjkGaUazV0yl+CF7LNfoaLHKCribNP/W97XvGIsDXQbdGFVoEx9ud++WjjufclY3o9QFoyWZO98Qt7DiIs9mVGK8i4Zl8j78pTz+1XxpVOQqAbGZy+dmZ2/JxwWb4nl04tLcU39jd2t3M+uCeLvh5D+shsicVqYWnUZAlIyFAhy/LTtGfTXglQ7gKV8/oYJthokyTON7ljF0AZNTEJQwokOkDgjzv2mMEM7F2QhMbT143KjIoGODERkur81pMYgqnVhTGHhI9sIZi7o+GRGGk0K/gULZDbi24Ua0QbEUSum52YOpcvMHWzWVVwB5m22/p70PCcXmtVs/eHFj44+fAqULfWz1af/JYN3AtES0CYmZ69vbGrP+/gIyq0U85xF2/dODkEIPyXNkeGu5ji6iEdps1dtfLfuOKOf9fz8h16xeOs9AB0c5WQq0IwQaPVVnz3DUXKDOJDvd0GaP5tvQayJYxRh2w058PwrKfbf7Kvm5hUKsXjUydGZjgjHB3HLl96Z2pm5NFPVOVgmarXcQIvmqO+crGv/i3B3yPDLZJyJhD5pLTiD7tCYTqf4AvwIANyiSkQJgM/pf2RCxfABJSAt1qGcvRS6vf+/vubAr6pmAsaKQZIdDw3tw0xQyZjkEnbpUQoT9MNIxDVCpRFR9ZADWBQQu31RZiQdLLUqv+znigyr7s4odPBmYLvVuwB4o/EFqGkE2nVud9Hrxod/cxgtRrMcD9Ytx/TL3y5CiYsDFUCymfl8cbcrkNTr2wFEVzP3oCwgoVV0cKwCIJ/ZO3zfnMnH0O/uPqOK6+GFQVX876n7z519w1X3/zg1wP5SiFE57PxUjXvKZVKe3u6vRodCBXqSZl3TqvZ+OVtE6YFfhiLVKoB75Ovmi9Oz3B052Yeue2RM2eunRwfV67Ip3femb592hNfV5KkwfpySmY0mn1w6IvBdolsgUjjitirLNZWWs76iQBzPBRCTHkkj2HoJoai6TB64UIEg0Yxkohi3yxKGLcv9RsfiXUiHhXwSI2UJOHY1qiLZRSLRraWhTrhFCde8QGrZDSk0wZZ3+agnMyclmzwidrRUTWANXwKd/on1tJMyaV0kQWc9FISRRT4NdvQxmMfqI975d9h/mYM7NWUj9c3ls37v4BXvz332Nsfw/2v9TnRSKgk+GZ0GIZNMxClA23bEITHZuZWh0T7ol2+s1SiFJtPPf3hiQfvefrmmx88cfZNzvKZp668+r4BD90teDxZ3dFePuup1kpHNXm+EGBoX1/T1Az19fsZU4MXXDSaKRaCmk8uhpfOSTkzy8sczpkzI6cn4MgvDQ5ylqZPkQqT+DDhsIHzAtG8tl6QB4Bhk7IQKj6+6URwS1xsX4bpD/tWGq+1TPnlrOlHZMskqf8k+OOyemnAImlUAUK9QaEUNASE00mmw9X2ZRiNcJdXkwiIzuil99HDd+eFZ9aX8xjMvwGYjLnhdfJSTtwmwn0RMctTc6mK0QaWDuV1tayF6FiNCnMENP9IIxo1f8b+5ckNGU6RZS9oWga1WaHImY87nR93T2o0UEXBQ8/etjmdknKCX/5uY+6XjUWwqU6e3IasHhjUAoQL5EsZ+skKH8VW7r4oHf8pLxzkvHm46X43PXsfPPADrRYd8lRd8lI11A0UaFZJzMqHAiqXtw+p5bvs3T7m9vKAsF0QeARbrWirtKSbXH8FUSK6Gc4rZ86cOHHi+neE4yzhllab9JltNj17fx++Ti0gELnF3YXgZhpFYu4Eny/wh5VK5a/CXy1bKM1H07FNyfsXWOVUtLGi3EISGFyOfEASEu6oQOAkhK48DgleaSqYNPEJ3JSL+Fkmt8nNTyRisQt+/2bCFH0vp1DgJreb15clBWb9nBPuGvgjkbRbkcISW/KjLHyQS1yZbNGR6zFFCsXrzdeG9GoKV6l6MOxoTRmNAOL2yqCL6Bcz2qFd0Cd32aM/fvncM6n3f1+EzKztUdHoMBSqEJkyBxlyIs3u+SGH5q9JNIGiZ28bfGXzG/eFzRX/N+/9EFu5vD+fHiiQXU8+W4JD3sXJQMBSK2VD1WyXTPb7ffbrj2XM7WAuB+hWQO6qsDxdBhFPcmanVlziGd05DmfqZkiImV2uVSgAbjI8NTiIwBvu757ve8t9szHj7WArMUGEH4tAEQBdjzIuXEGQdDqBYREUpAtnJBiUZEtbIUE6AZ2QSeFQN1rpaDCNCGKkCSW6uI80kYV0WqCMhy0mgD46EJwZOYbHC940Co0kJKmy2jr6XEpA61VOgkiDpByRpC4Z3P7aHlJWGBq5sTWzzdpMRqAUtjDP8Zi4CzYf5rUClmJw5GAOw5o5KXrty1WbZu75Wx67kQ3v0cZ5G4B8bE0K7xnG2PCKaIb1c7CkIg2U9959GQX/yHnbPcKY2wC2YcR9iev44adXwDaG9aTpUDZ/kK1VyHaQIQlP1hPwhAI+3pCmz57LBLEeFo3y6mmdrpavwGamwsusZekUqyRlceaXhdc+MP3Or8oQCdlLTZ7Py4OccUicAfBY1owGK1EsaBQ4L/D5VNoeFvD5aUQstvwhSKvcPQkYVTkDGpMi/nyYsCM/kZgE2kkgqLCkL9DCgumQoJAmSZKi6ukWHsq+smIhGwm6B2PZ/JgbvNCtMA7rWzZIrIIU995Chm2wwC2hMkka0NFK+ADduMrlnCH5ntVhNDiiguiYqCfp/cbQBdwZSRoBwOX2FFE343v5GQgjhRwv2Aw3fQzGLYTKaFa3d/fZtmDPoM68rVlchHhjGLnPLH4mgjBKIENFC0XOPdcqsZTjpZOrl9Qw7HjpwpuPQ+85UGjR4nwpe1ClGaqtKuQLlVbTpyo2NdtGoDqASWgAKRasZLM6Fkll4yyBWImopLN2oZzFYdnfPDs1Ex/PM7ZmJjPn1ULC4AYgeNtDIGXaHC/XquVY6tDCV5JoKARkGliT3wCW9XKKciJgGcP55c9LhW/aEdMmWQ8wDLhtGFQoRgaNekOVAK7CnSRFW0KhVm1ndlYurfz53lrOMaYBSAKOOWzoBGaCYc2GJWjh+7w5NUUI0pEGAFHWdCicdXk8gUgy2ZSloI6UHPqDeNl2GQTAKbRn4L6nUItylIFrIN3c1VsfexuAcliobXC8t7c1MCpxmS23ptSZtf0ntQuKL6HhhD7H29NoZL4cT7O9qLv57nvWW0meiP3MS5BFxkui9scBAx2otCoVTyVbEgegnvBUwnioruEVmabW+pvZXA4Uo+ZcWVKphXUHYcE7nxxMWQQ0HRCuL2fHp5Yml1lHbYlrWeAT8bxAfPS8Xs2oCOY4t/sZbTNpNB061O9boOrOisM/bUWw98eeAYbl5PmXUhSK+Jf9aXRLKVxeXqGKaXDpwRzpgYFnfTmnskSpVjZbiAhUKpJi7bH4rMF1jtweTiMmByD8a6tu5DC2abpkUACZ84dEEEgwuKdiVaAWxK14DyZC0LzL46rQaY+P10wZvrx07CSdTsIpM5plCqAbHH212gr3k092771z52GSHmasvdx/Bi8WeLLzw3OA789t8wxGHg9gOG0mUG5YbTxgpH/9w2tVGK2GVunm++9+8HoxNfbwKNcG0V1rjU371LVPXTmQpyvZsEtcrYVw2AuhVjFtNCbrQS8PAC8sEsx5vQY+UpVy5ON2+96R8pCgmALyCofDkoe3hPPycWV+yy/hjsngHzRzOWvTB7iYdpSHuwhnLiUx2gJ7VTH/cGVwZh6i80bPX36t9CJuh/QfLtvT4cl51rhc7sFNTvg2A2kmF2yXHbgAEdAWpOqB6j0SoA/yFTI/L+SwtsDmCGCyh7X9tTHJJp+/KTFJIpg7hv429DIFbxjv7Y5gE3ICTJiBCQUKeLJhzCkcXu3Dz62+vMh1pDpwOfhyQWdZtmhbzMBEldnokO3eCdX7MOQcfQZ/OExbyWDacvvWuQURb8Grti1CEplGUySDTudxLlMcn+zwLQqHeOa2m6++4ubrR17pKHq/Yea+SOTFEMv6CMwjuLKhbNYjFsO96SlSvkzf6y12GTMcdm+xbW76zL4ifuDiy3XjLJXTOT7OzzBV3ZRwXqhUsnSTk9KwRA15KEH4EnhFX9DZpoLGpleTY+JxcxQwuhxJ7MjD8hXi9D3rqJonOgkq58mHy70OYfET/vAyguQtecTJRwukKoYUABSxccHJUG2BhkwH3ArSku4mfZRqC/H7/RFTA20YM9rnuOq196DAjEUun3mqhx3vllWMidc5tOAqDCoF8EsZqJ+TxrLzj47B9pyjrx09D3MVjvIiNI5qm+2SesjLmDtR33ng3owKrQbOcEa2qOYuiMB30uxvDI2ZvT6RdYG9INrQAE5lObZpuIKl3xW85ih5+3033H/HFaceWbejh9A8J819b7IbkupmT9w+wKpma0cHpYNqoFqjqaIXDmqRapt5OV+ZSsIot3nBm1gSEy5pKODmS5SunLV2tLOMW8Y5LPHMzPy8xfDZyWeSKkCRgrzFl2A4BDrTQLPMo3/1ijqOzvpKDNsaHAFl79ozb1wwJtcWbh1efZlhaPsF/+aW/JzOAz240+kMXQxTVICs0xFC6kYkhjJZd+JUQtHyeNueEDTmVXnWHw7/2QAqiMc1uLFkNN3KR9z8iCJpShLGt3t4Eb79uIqhwJIzRXIQr2Juu7FN52Eip1aLNNsb7Ou0XAMYgBm9fnTM0CsqSJXR+NBzKk+IwLnPndQDQtnvi2xjw7JhGMPKOYwi6+WRwYee5CHYb79/8Pa9XstFA9fsED0Ogif0mjdc/0qtesCKERHMXKzHCN3S7PSJAVapVlq6eHSQN3erBfhAPkPOZwY9oU0SQDTxQB1tp/dY4WpYYHQrfGiEx9rTlVSqrRUWS66TS3W1EDYGIhDpLdbB+h1rtpNZFuX9g9LFixTeNL0xK0fQN6999JFrR84OcpS9KBU0G3sBwh8KCQi7PayyEEC8b84vvaOjKZIo1S4eqXoCF9wrpqKPMZny2a7HSankYHFCuRaL2nzduhtL8PFoMYLlCxjfFB1zpzqdX3o9Qp/htSshIoAU6BYDtIuvZS0fK9QwhWrLZET6DTaoPS9zZd7z7LtOOqzNqIqM6ndRZaCjCi6c3GcbzbCgzZRZz9ZDYkfKOzdntirU/X2ZKSZRjH68sVC2f5IYSo2mb7/hhsvy8f03ny0tzTyyLj3kf4Oq3pVfnJ4YeXygBi3m0tJBtpsBfSIQqNBwYst4ry4QdI0MCb1oLVR11Qgngf8egxECHnNwoKsKsmEaLr6s/EzWb5fzLT8Zc6ATWYNFRVSQhHcl6KSaMhXhft+UBTfkp81fY1uD6+szp0GERJiCWIWPs/bg/9VJt3DlrHQL+QK+2hcmcTJ08AnH/wVKOJEs0QaTIyiJ0Hjn98LRNOnJdwMIaE/uiNMNcjMKRE8j7cnjjffLqUuXfp37iMuQcXFgyYVDtVfx4O0iVlSV10bnVh3H5bLMyusPbfC8vKihTeZg8McwduuY02cY1eOEwfDaEFfLlvGaZrgDVBm9jPeyGjiKBAFslUSRgfQKIIgWtDJ06VF8bZ87eOqGp0Gog+by2QceffTUo+vLK/Ni5NeJkUcfuO3UwEFpb+ni3l6+GwzChui2CiEKw/EU5aHztOVilXLVoPDI5gVKGi0CL2JmLdVKn+zpCqzJqUkP5+zKhXnd4QUTcAa8XA7qd3MZK8Cda2aCMHPYfK6u072zM8VPz89OyafemRkRsvBIZ/mNc0tTM57s0aTYz1dOLvOxC1OfTM+0jH9142ICxcUWhpFm83Fn0ZvD4NIWiD95h0nTWd1eSaBCTVgigvPBx0MRAjo5xXsSybHBWdz/xWANegqBSkRA12m6FQjgXZVBD8TcnLdoNjPFYjLIgC0I9o5MvwbSVttsjCo2hn/rfXkV+xsLY0yCPOqjjonjL23wVJUNqVzMifMl6ozGbAWgncc1xk5f61ZrVBMP3nA/LCc4RvfdB9bRo+uvnFtfPzcxcur2Ew88OlA72JPu7B1UWt1CMckUGIZUYCU6R+fxUK30QhcvlWgSGhFVHZivfY25AE1j6cTEXmVp8MRgeIpzOC+Uf+FXJEzQaDd5waDRwUzsMF69yGshm93SCzvyJfvgeIAYTOXk03LOxMSgmPUKRzwu3CL9cZY0vrminA/8+adr8qgk6ElQFdLG18X+zZhlRcriY2puhBB4arpPdiL88eyktLpyiGMpE9Zu1Ouok6gLWgj0+1CCMscL3+6nnAf5PZcSFZA4HeimaRJ3aH559W1IupSZO2DjW2i8EFqDRJWX6zh8TlIiMQ4bKNn3ryKTFme7DvspGiVVf0hyjh/Lmyqn2EJYqJTa67Wm3CC5y4yH9/itLzctQvub991x5f03QIQVLOipE6fPzY6MTDxw6vYbRq6/fkCnO5jUsWo1VYCuFymSaROuQyloJEy50iIOXNnqXgH8snKUBxBHEXX6Q4fx8cGprEd6dlDHmZpHljk6MWLBa9VA8X2gRovI5PQJjjSgHUomDw+VyOTOzJL9zLkI3z4xcdvU1OnTJ06MvKkcL42jxU1xPB4/N3U0OxjeCojjYtyasV1K/fHIC0pUEcSVLlUas7q3JuHqzi8pmxhNWkgq2fQpog2fMWdWQHSxGzYvRIg43L3U2PZDr0KR5hNPSi0kiarwLhAVDCVTA7kvaipwpqPKVl3xEKFw+HLH0EVBpx91GM8bKa7o8CjuIkLBoinpK1LHUTWY5xbYmv5NQaCYLDMoY1A5ocPJxQmu4kI1TpjSd1955Q0fPvjhzXc//siZQeHgufVz1z57+323n5i+duDg4GBph1U6gPaICna7dYZJikDpDHlarAAJD06pFCqG4GzU2wXgMwTvypUHTv6mwIWGw7pZOUspXdLNIwpxyKWMcr1/hubXT5+deuSV9XNdnswra0SUO/JXwq9MvFnmv7s8887M+OCbp8++uVKtxQUmPoJE0AvzwqmJd3akIE2NDWs0w6sX/HwfTmHhESkTiGCEfR5N/FSxI+YGcHsGI5WURYE8kXFftvEcizDI38EaL5chYe0Z/dC+tmzBxHCH4h4GLgkcPhFDMlDJAWGBgzJBOxF+WWI4Pu44VW7chRRIHy9XhjMer9TpgxDTNMrUbrc685xDQjoJPoYb3ncKgr56Miew/BZs9t2H2jWJENrDZveRu++/757TZx9/ZP0cnK8VlvyND+++7/7bT91220Dp4ODinqdUbcElw5d3SZ+h2dLtZT17rOUCHSp4dKWaqmfwkfD8SDdZFiTE2vEf9xDEbUI4SyxCOTshFItJrBKdG3akOWeEZ9/44s2zZ86cnhgchw3PeEnZwytC/rQ8xk/Ll1iI0H/2FZbuIO1GyyYKlbj9y29e++ypR6Xrcd959vZdu3obr40qUcnOC1JQYRFWpYLksyGaxpLJaIum6dSiVv0yGOiifgb0Cf0zBj6mHbtksK1ltBtao9OLZ0slhEZxASwhhcdUVBusDirdDahUquYQu9+PklA18FVOWM8CHsRd4/G4uFVsucRUzjjGM+QyQ4sKCY4Q4Rz7l/M+lS/nVeCUT+TtBcsLwz8KhXLxISG++MKpG07BwLcwG96M8X/y29d/fvr+q++/79QpWM/azkGpVqkzxiaZxsliD6/kayz59IiyEEgamLTLU8BNXY9QKh03tdICxImgx8UOAcil/2LcrlyaWlmx2+uyXRPumhq8fnrizNTg1CuPvAC/5XR0cFBtyyRcsbLrURKBLn6IIIcrws1O4UjQaMKdi7l/O5SffeC2208IlyYDPpkehJ2muZzPBrGdiaUsJSfrfCboCVVoJ45FkCrLRVhHh0A4m9sAp0vG1vfXrIRbezmyEQZIHppLOY2+yZpUShWDeAGlPUiMrKtAnQvUPAHcbRyDzAdoit2SIjiFULHAcbbGfh3/VUkoq9VqMtdYG+M6oFn4vWOxEE7FqAw1mHO8qBMNZnqC3ujcmO1dKWd9XOyJ1wZfuO3Zax/h+DdhSyRAvRX+fMPV999/3903DOwd1JYuginAMJivmPTCuEetRosJ+bOPAnLVt1FuimDFXRZ72MNSlr2GNCg4x8c9clIcRlwcoV06NbUshB0vlYt1M4NLIyPwa/1vrK8/OD09u+xq0669HXvisF2YLAhKgSIla7pNEIMVOCoxRu/vBoXkm0RtGmL1xRA6oayGvH2zlabbBdwXmAGrgqKLRvOxZ9xCAXjsUMWVTiWRE+0+9NC+Xvs+2Q1AGRHseTx1k0O75oM/3Vcm54KWcamLJlvdrqcSKrAqKlOqV1cFPAKnTLOh7WU2eAwVbIDQ5xQIAkwSI+KGXQeOd3pluBcgMwPcuoVhA/Er6SsG4UUya1IqVb2povuvfv9qsiSeXJ66SDpL8Xnh19Onp8KAn71nwBTud794/O77nrr9gTNnoV4qwTby0IE2Q3a9TcZT2wHZw6UcOY33AjmtAo+xxPMrh4QLnju0xyBKiwBB7JyRWalYPHP69OCMfH5+eUXIGRyBU35mcHb9TeEXy5ffcc6ytB7MiWffmTntIVRFmvmbo+t/TaYA4/0JQQhOZHC5ImHZVu5wFTtHm7s7J8ftDud2nhmzs+XN3MVq2Xxlt9M5tfbl5aKa77v2OiTk1WSakHOVEMGcP7hYSasmQRSNaEFB0U89S3jh/QLvy/v43PN8ns/zeT6XzJzjIkKM3qYUmV2ef/7Z1954+CqBxs1el9HWvI7WlEqDtFVPoVqnrJ1Sl3HeCwYIiRTF+mXk99B7f0/N8mfPAYn+6SMZJ682Gip/IMmKKx8szM0VPH+nDuenX7xFN3xqOjlwnlbS6XwV5DqZAQLkZHgkMPfFI7dOVs7WLoEVneUjQOssLM3yC+98fAWa3unpwo2nxOGtF166FVuQnHUwPKORy5N5HI+9MbYS+OKLlxJ4ToW0aRRwEGOgu9qPNtZGCyfPwyH06N3VH0yv9Gv9xN0HGpVqo5qmaeedYJrPJILlXLTl7bRkGSoQH1kj1tfXNxBldXlxlStziouxs/brKmOr6WF219tsFje5+JnLOgyNG1rd/fvD7tXVjzAqV8HcJFX/cLpONn16N5ZeiMWCbacHvPu2AsdbA39Hft+Bu9AvTvhsp+atUIs2S6nEdppctFHMpetyrVPMclJRb7QplJCOzP40OXbnvZWxsa+eeOydq0A73cgykloJzkcwlRF5Zz2T+fvvw6mVg5de59RrFKVFBcLldNJicGs0r+I8wvPpYCxwCWxhbE1Jzk8RyTx9d+H26Fbind9eKgQPXt4v5PNrB3ClAjh6lh8QF0AtuTBaoJDZl249fjD3VoEzumiJY1zLEZlSZWjq6/jaQgZMuJ6Jjf5q1fc+1WtZ/HbggWKlWKwq5UowFqxnnMHTg/1z+I2GhyCyybIrjboQ6OoIynEcTS2jPqMNQE/JbzP6XVaU1eu1Zj2rwuIjbhjUaS27u7vfuBd3SXrUk67DXjOWG8+5WIufJdfXg6HEOiWdpQ7WMnBw205MF+rzZxdqtREtlfYGKpYaCpbm641Wsdlp6gxefZS0aXQ6fZYBgHH18uQz8z8GJr/45MVPjoJSkfGTW2f31PN6PidYFR7nRwNTRGr+1tjcAk6U5WXiQqLT+XyQWEjstHPOYFZGG3nw2nrj09+OVjyVPDEA5EuEJxA+dXj0znSqfvIFaN2Csy88+zqc8C7BnTjoSPnbiTUQyn0KNww7gWO3v2b74aN1DqfX8WW76p7ws9To2tKt1157OzR6d8M/+OQMKo7uAl5qwIhUVBKZfAEI+hjInA+CfFXk62mFAvTZQvhxmlM3Isi6JK1qjRatTWvxuy02lsSsEzMzupqf9S/qhwwOk1Zzf3f4Prb+0borD7LuN19fSnhSZatWo2X11nViE8HVv++8/tybt0KxVDvRbqc5ppE/LXX0NXXZqreVjLXmNVMpdjtGo0ZrZFH76rYP/RWWywcgkzmkx8/Gjj595NYAxQgUY42qFCfkk3il1UJlZCeT+n3n1htfBKD4EqftBWjwm3kxmGjDJTrcA0mKTM16iN9BSsQp2TRP84TIL4wHIjy/8MJkjAh6xlKJQ+Ls8G04lAiMrsH3kNq7KIQisQz4bsDbc9Ykn7vK3J+ZwEg7tW7fttv9xuhnazvPPLP/7hycpXz9w5ChwUmbEw8AudTsCtALJj3Odih48sUH77ycEV2SeCGpjEwJJUwC4gKlEW6VzvkgNjcbuG27Vmcc1k9oR0ZGdBZfCdm26TQzMxrNhNvK2u121oqKSc+mAKmVEDGj1qj32zc2vtlAaLhHf+FqP3MwBk9kgicFa8On69X77FZfs9v0U7VupSwzsDedMPqqmPQ1kkM8BAjvicgZkLBFz1mE9MmyC/NbV23u1eXkQCInd4soxUXeW9l/47nJFaJ6/vnO0vPP76SmQO4oBgspaCweWUmOvXkVe2aMqDSoPLASisjDVZmzniIC+ytnBOEJFHaIYAS/s7JydXWMpPfujMLYGkitnDwObya4Qqh7G8vIZ6RNNzxhmeAiXy9afPBu2PdgInj+mcDOFCLs3p/oMOSw/oFitQQANCcG5jL10UzeAx4aL5/eqwf5FtYSGKbp9dpQVFXu3dtEZat2yKDThcNa/7ZOY7b4JvQ3MdVun2eH70NkLWad3g1E+rAeMo2lFhetILwLjuO7AKGgf61zKEkv7RzcAZVA6qY9hzyq1T7s9oZbHYYeZ6I+o8/mz+ZON21Ns25QB9BubWszDWiJxyPyAC0IfqYF7DRKuRpNm8vtXxQJz6lYQrMVmG/+ANud114Ymz9MHWfgJiJwMLrFD3hSqWAh40kicnBubnrysakKUs3SzlO6UqFxZxBB6vWkZ2z28gzs+0ZTYO22Mz/36K1IuqoQU9I67zm+vn7unZeOTovSIbGxQV8zlhHL8MbdP6c+u+++UGkQmmZW4Hry3G6x7Vq2JyA6DxQbrW6pWM63AX7W09Xy1aefPPL267EC4m+1ugzj9cZrep/qUijZvgtJDT7Ogw6vzas1aCZmABmBIb7FaBkeHhm2frQ7MjNhGZ6w6czxcNzvWsfsnw3r9eTqIguSVqMVur5gx/lUJHVn5bmTdpDgEzTpgzEhHlWKVYppAnBrNsgsDgndPxjWfPZ9YHZrHJEkfHyA43Gcurfr3f56fKNEWlm9kQSQbFXxAZSsVrMNCv9+eh+88QOPfH4ckdb/mIolCvWVt98MOOueFFCP1cj74If8I4XwkqRwOaYKM8LeqSwruKLAfd7s/Mr7qdSd52F1/NLcfF7JjwHtxCmePe5mIdbOS8G95NYevgGDpUBvbpzd3lu89zVy9j2s+UL1gV9d1nCPZuaHL4de7Yf6CXFTill40k8Sp+kgKBi++HQ/RnMU2unKgterHRkWBBcASaPGoBkCy7sesw4+GqNNb/PZv9m1k9sTmuGP7J99vfrNBBQWq94c7utzxG0WCLPfojVqcFRo2vRe9maUYmX+MjQGJklQ1zIpJxYtUphwjeQoEivmKhAXZOCCtcF35qgxmZ3Zn5fu3BolPGsItxm1fLTLWkih24n6MD91nmswCJw7oWr1PArM6Czof6+m5z4JJGXKTh9nUon5o3deXqGTdXjss/Tl+y8dLclZVZKYBsM0ihWlrDBdpJ0ES6Kpy6XLW4+HzogzAj8LhAbkJEelgNpOEr6ztaO5cpaTgdfaIsR2isNQBPBi9iMOv/0HiP8PMguzXy9bDU89+ORgv2nE1PtAq9OsNbutavvqk8npk4HQ0/Dqjekl2kUpZShMmM1v9VoZlGX9ml6NxmDoffXVXrPWaJzwTbBGv8+ivf+NXT+Bue2ryN2t24DlF0lyOPzgk2Gd0Ws2Q6qGzRqSBtzjjxstFp8xXiPzbTgLCS2knFN38FKtAZtTn5IMVrLlAVoq4wTsPtaBrBmsVROT70xOfvjyFy+/AFYG+6eUakdJQcUaWMkarcKEuH4hgQWpK5oVokJl4GegPuZe/+6LfDuU+X5sGli2uf3Q7zdrKQIXnDBAeSoyA2INlhEYTJWLZbHbAGH0NCzXx2AfEWoTf99ZgBuK+SmxKMsIRW8vbvcKnpCoquTFxu1xOBsmTqcioA9aRopRhBj/470FOM/ZW7dfG5+EU+3+J/u0GtMDYN+IlCCeKRAlvvDhSmJs/1aiXWZQdBNW8S60y1jdLqbhN2ochhnNTK/plSf7DHGDH5gAK+B33ZB2YmJ4YmLCurq8uvjRfetHdlc0OtjT59Ca+27YrDD8PLxMGo3DRtu22QzgXcXHbxcCswAa5w9kv4/dWneVqHIxq1RTbTEDyvo8Pm4JmxdB7vD2Oy+/8Mg7k6+/8EhmDSxgruYyWRJAG1MkyUpw6/fp49vOczrbEiutUpc6O7w1/+2HHz9XPziaAx1AIkKcPHdweZJw0mlFOpvdISqiguXSIAAvdaNVoVFJy5Gxq7mXrg7qPE8cXybPiONCYW9v6jYrDgB/wi/eHzS1IItJZhUZvx3543d607Wc/PocdSmoII2P/zG+d/veJrV9cXH9w5f9D73y1w+qTD0A/8W4sdloBcemb3TeCTHoPL2XzblgPVd1cS4M81nB6E2n1eoMGqNO0/fUDY0Sb32OarUWi03rMJghVtuCW7Bbd+/vulkGs+p1wFobDD1PPfhQvwN2V+aOa9urNRu0g30Go5HhuEXXMs1JcEqE03c3cAVjFAUmChnYoFi7WK4n75kdy/8e4rdxsDpYEBWBj4XghAGu6sTra4rC5ApNR8ZOXju6fP9fD88Je+dsUShWiBiY/M/xVD0E3iR5iedj8OaVo50tscs//2ZmAFSZLJpGYReBRVG5WKmIIv3IdOIqQ/FtWGDlxZsja0JyDmDXh4diXqKRjz76VckxuxaSuvse/h4IgCGzUW4T/fruZ+jA3a8HcHxv+Rpb/Ciuw6j7P3z5w33AKQ/EzYZwvFltZAuZegFAaLGYbay6ig2g7BvVCkO69c1a3GzWaHSDGt3QYM9TT/U4hgBuj5hMQzPAZnrjOpvPx9pusnV314q5oDq4DX09Doepr6/P7DUPQtdH7TqjztBnHnToDJ1GtynYWH81nWvllUoe/kX0nPcMJOkgL0pyq5tLl73be8HDBIG3mg26nvFE7hJEKBY4CUocfzjr8UT4naPn566mp69CVxnoVwtk1FYSxMIjX7xwwItEu56hFeLw8Orlp1+a/8Mji4lnjhIwfcrY+nX02h/1MRjabWUpTowFxLpT2gkm9+TTJC+OHx8fjg+QLE7JETzSZvbqyzUj+FxSv24NvIdEOJmTSJJUL/B16d698fH1nExR0qLW9FSfeWQC0s5mtD3gNRgccKUDPamSzeVgeO82GrBpa3SL5UY1l7Vu63Rm6Oomk2lGZ4IXVDz04FNA85nNX37Z32sxanXems3o0w+z20CETLjZa8xuhTnHMQjYXq83WtwjNr9fp7fG42wt7NY6NLpa0dUqdm2GOCmQ0bycLefzZSWyRIvpdD3P51otJV+O8skYmP/GIhEi5pEROyVJECEiMB06OXrk5Ojq6CgiAdNF3+ZCYAF7eR2N1nzVrBMecA9+NltwEvzKEfiUPDe9n7rzxwUfCwQVxenEJRVzsf5SV8CETgsEcOJOsFwg6PFTGKVEXI7AvPPz7DjTrCnE2d9IOb03vuyIQ+mn9hYW3qOr/AXngqefWYxsrK9LSGSV4y5StAqP3ZMP9uvZUs3cOX7gxiTPX63CiNQpNeH4qQm4uiRESy2hWq3KZdKodTgM8cHeIc0QfODW5qGe3rDBa9IN9ZsMFj0AIr1/mHXrb0g696rbjVlYuwuKxP3VxWUgWle/YUAq6jDqzKofZnzDkKXEcdWqCzObG2Q+kQQIeF5Oi+eH+QpaLeby0IurDCjs7x6eXF2leCTnLATPiaicTkuHd55/fj8WjIAgMU+ywjVlF5ZrlHI4OsZn0WgX3do5uDr8PRAA0e30ycHYdCIYAk3V2O/PvTQWBAY1D/QpvunykaVoq9FpAq2XOz0YmzvhibaYFUWqSv3N/732QkC+9mG4J4XLagVHgoJNq7etbo5v7VVwjmUFCp75zbsIdSFB4aFc5bwv3NM3+GTfqt0Yfoqtv/SA2RuPdyAZq91orQa9HvzZvbVSyxe1khR37arFNQbY4sHqbshkMGv6wNK2p98Rj+scEF2TZgQYJhsAJ7172D0MqhG71RbXWLQT2+yytE5xi6tWdltrCPfoOvGO3wd7lhF7U0BIrLqssTE5FJSJsMeplvNArp1D7xVFkPxU05sSNHkZx1VeyVXy9UJdqXKnSTFXXooFi1mm1Y1GS9fXpAtTWT9FZz0eabPSauA7c0uXoVgo4yyc7F9ehiJnwH+c/X4nEVxPnp56xFPikECwkuDzuYqdZomNYnL7JHacmEuIjQjCO0fnDz0Hj49y2xU8mE9CpYaHRoq8hxmNtah0cSFfAGnRZP1REpi1i8/Ua6GF5auNcE94UAPv97SHy+wL02sP+GGWiQpFJlvsNr0OyFZoUDpWO+w2RpmW/wb0GLUasxaqZa/JNOgY7HnyyUGD46YEOMImE4yfExY462uC5HvbOmL1+Yxmh0kzqBlxD/+wa3dbJsyafqijBviymGjNZpO45vIiJjDjxjCgxiTvTJaD5Yqzkk4mU+d7RVxsCS1RZrJrxVI6i547QRlSKDhPBSVHlysV+Na7RRdGtlwS+ivmc/mYaEVGy+l6m+dB/nAJNnuFqd8PC6F3bu2HYGHrCUH20RQpyZ5gJF+IefBlBuAZgzVrMKtgWagjqnANWrSkZ3/y5Tkwn4k5JdanOAu5aKRwhchORZa4ZcxRyvI4yghuzMpRfisr3SYBQfoveFTX02cNvfSFGO1EueDLLzsf2NZbbFi02wVUX/Ma4o641xA228xercYIwDQ+qLspkroaPeyAvQS8xg58RwYHw2YIqCEMZ4uGoS+1Or3ZFrfpIbB66Dq98DENaUcM5gmLxTDUO2jq7et1GEtGvcFM+jcXa66cC0WX9SxWAV8dHldG5YqYR9K3L+m9TEhhMLmKIDICFb2YbH+eukdFnOVslZVBGnbaKEWLFSjuVQouRXDfqostAXdbTeeXlkL7ITisf/2XyzP+MBECb8MXjt4cE3PRRlpVKwgehNGTGIXJXMY5NytEO6zKqMzq9bpaKtJI8PCdTz594WR/DAzj96hyI59yRfk3nRFSSoqICGpAVKEZlcIwVVqXtdAmUJ/f26EHci1Wp56kxHN/ukHg1Ttb4QdsRtg3ugCUQTxvaik8yhBUaDlaczxeM0Pp82rCGi20eEc4DGjyFViTwMJHqxkZgqQNmyBxDRr4Q61xRKvfXdSZQMcHmawxQKx7+/v7hwbDBpNOY6gKwASQpexyx4Euk8t2VhWqlRvKopIvV9JFFg5bKon9/cxoGYR1x0uHIp6vKrGVLZpAs1RORKsIXVZyZQqpipx07kwdjg6o8rkqoJSYSxOBuUfuLE0evfQCnEuujM2FDl8PXcaugmSn07lGJFhQ1oMggsqf7/26CPkZhXrRcKnqtQTjg0JHzs4m33njJHTjWL4/d5BT+D2eqwmFPEGr3VLUhlIRArGzH9ECi9l39UM6vc/mjeuX107v5VK40uZhpYkRMDnUq64H/LVaqchGS9DWO7Vmx1azwRMPAdPAch7SzgHtH5LRZHBAW3IMPvkUGIcCSneAGumbXctMb1/fYD8k5GAvFNcvZ74ZGbqJYa92QqPr7+0HYUoPBFyrmTH1Mlyr1Ci20GVUC9+uTQ+ttltKioV6OunMMdH6dLta2Ekm6yfJbNIzmvGU2x5AURvxJrLFUfTtu8UcmixXizJNgyxI9hwfOGVVzeXSaSV5fAqUcuhgEjzx3gRmb//q5BKPSHDdI1cq1aoqtscCsH4naC6KMoyVjAoYiS5fuzjq7vtjo3z6GJbB4At7dZJKjD039/IkTExzA1LTq2BIalRpqY2ki2VImDxcpKratGaYSjRG0o9O4UWBVJMHdZGB1JNmiZPzfAf6O8ClThQgTLcLPyn5jRBQR1inAeWxwxx3QFYa4K+AcEEd6Ou5MWmDVX54xE2WMExr6unp6+l/tR8ul3vho4HUvMlJmEyHvxmEFWoPhHoIGFONxs5JXBErKmUe8zG26Kod8zf9iCd5s9TlqK23n993FouwN6bFiCJmUvPO4N5oOWcZNMjZ0/TWOZLrdDdFrCJJiDi6M7qX5FiGEjhFBh6+npYLoG2hfz6AO5/QysnY5yCszZfJdKbAUfK18/WjR8YKTicC/zDrh7iwpACRcTWkf48m394rDywQxI3sdmwrQhyejNVVIknTqBStoel0K52hj6e5jfXrbYBNNCp0m3Gze7DPpIljU1Byps64rQSyq7WYSxEOEzAzxDPehEJZakVrAJg6xpqtVquZIS3hR9wQjztgAP//FxDYPhghQQn1FIyQsHcT0H9W+0Ei8SS0KLi0BfPgfoe5r68X8nXGYDb0GgxQOE0QYUjPId02+jX4QnAId4+CxsygUVSwMXg7KUIvIdVQUInsNCpoVOW3PJ3I6FYomDhIgrB/lRGVPSmdhcMln03I5ig0ix9O1auNbZjCsaiwKTvp001MKmT8XrdKFeHqNRYYxSV0M9fhQ8dnd+uZUGBucjIQam+SLj1rZaFnkt2GgKLUQGi2QHAUSMiQgxtlJh1lOZ4TeYmiVRVRSVx2CR2VrjQq2yMOG8tyrmvBOtOrg21X3FuyLTxzHKQv1LM1cVkPCwXhs2UHa4F41iCenWYzHvd2ajV4xptGr+MGdMLHrIkbbwrqDWSCUbwfMg5uQJ/sA5UJmWXgrWmDMDDdxBMUfBDRHkOvqbe3zwRhhCavgZ41BIPADXA1mEb0NLe7nq8wlBVD0HEcnn8Bq+RlNTjANSoFsXIxWm6JSp3YhMsfItkGUxjP3ujW98qUjLpcWfncg8KoZbZeo4vAzt4r2QC4QAZ0XVlGFs+fL1T6zEaLKvGHgbmCEym6XFGvH8O3nn8mBj4kS/tg4c6p90kV/exXcoIVhFKDcfHjIEaQYL7/j6tr602kDMP9CTUNCSWTJhNQM0ltCmVHVo1Do53SQTLBmSBKIWOczKhL2y0bE4LWSWcp7VJii2YSD9XGolwQi2SZcIGtlRuTBS5qgpI0KvHGRL3AO41XPkPr8aMHDrvs8vB+7+F5n+8lCQrleKliDlNJ4wJyO3TODMZ4+h26vk3EtkVKdlhpjHRYpFVviJC52wyLmnDj4dMqaLh3MEAqSPhkwcbFjNqYJElA2+uGHSLz9DoRkmzWHoePxCWTw20JdTv0JG4X3OQk/KeX8rrDaVEMTU5OTU7OoQIFzLh/Ynoaux0eADseXtWWyYSu2ewg+ZDCOp4Fk7FO9vJwQuEYeZ3p8n4jJZLRVjZfjS6Rev3pr7J6o1DPamQ0zkPT8dCbux+99M6merZAm41yYaOQ3dtbJ7OiWGyzml73K2JNRuup1UchF9mt2x3b36zvn9/7AzNlOny9q0qs1tZST3724ocVvQB1VUTgiv7e6W1SUBmGQxLJtQwumE2GY4HVF55MxOPh2G9f3T4jE6mljz66TabCezzV7ucoCP9khyovi7Ujbt7vkxGTYmnxTvBsZz6GpmP6YvatxFkwZ382FNzZKVv1UZvCZgZL3GQBrs07A6Nzu10umN3kJFxo02FzgJVH4IYzhANdm99Lu6NsjodpuvANA7Woj7nxNY/1tyzV2fRl0oTQjjzBgXfDds2hLNNnd1Lx7c1YUt/M6p3ysl/gNInj42Zsv9LqLvFCqV7PV1uMWmncfCZy/zOJl078VEYp1+tmtZM8XDisJJKm5N9I0eIyx7X4qKlXlRIpBCLQUsjc159CQXDzxm6+p5uMojYHJTQi4zu7kbqZLFVW49EWodVLnLJvcSIt0BQDxRBMtMFXD7YiC4FwIP7cSz/8+O4X3z7x6Cu776DUSGwqSFI5Vc1nZVnenGWaUFPNh3lRXt8Owky5bb8c5AOYYPIpkUOZxKaM7JjXC7tsW0jW+n2p2XSEXFjuzKQ1dABb2B0C1g4bqD0rkrss/5lhH/dQ2zHBg8gE8/RYX/jTqJzgEKA7ueW5NTntdlmgOrFsUzPea+4Q205vo1caRbNTJ2N8vuD3RwWVjdZTBeEki5fYJVEk5fvV2qBR3dk5efnznQuLjVDNaLZTqBwubeyRe3RVp89PCt0q3TALkCtm9So/+8wzkU6Z9c8v3F5583w/HIbbJYgiG+3OPvr96o2NZNbE9kYC6bf622pyKcopkBx0+7Kq0GUSXbOdr+7Of4AxtK+gon33VRy7S0TevLu0cRQNG2IxJ0cFKsgNzxas+L6zS+5tOoZBsbiIPjqOnPFfffvxjyU1Y3eB92GyY26kQ2zT8kRdzWKSJC82dijkmhiNs/TMAdupDFg5oAoFmQv3Wmvc066xk+NzawATQhMgumZd93iArAc3gDPEJ9OXId8NU512qusxJkVuMuJ1Znt79vbpIW2QecVcII0UfVgJUoRJgiusaylVjcVX7u4+uSV7vT4H1RUaA5DO5UY1SpvZznm+V2k0Knv1MhIiUgjS8ScPzuudRo6hh7/F4/kK4MwKBCETcvf8sw+xdfUy15f7HCohy+spUVrgICrU+izDaVV06RMRdDPLQtUIHG89jyMeD2GQ65unC2+e0q0E6cMTRU1jWeH30oHZeJLkCAIFzHufbgfv3IbWqxB54qnPDspUBumQLRQyxyysHM0+0s9u38rmgRvISzfsEKB9t34Nm9cFNG2wWOTy46Nzya6JiTmvqrnHx3EFstIJgLhmLYT5CdwHe8WClbrgS62IP40vCtRo1dTR0uTvvDO/Wh/qOo/Dlnpeh/iz0zHr8V3INhme9snB49l7q/Va7voH2z6ai9GNZAXyBYMhC0t6PFmH9MME6wdRdSBV6Z2cA8SSQGWrGACLnnoZDABBiDLB4sBMVl/JGooomn5V0+S2KAb94QJT02QFKTcyLrOe7AQCX80jtTWM+D18YOBnDzxlfRrQSzhDoMsNbPQ0T8ZiKY1eT5dSVq8lRzns3tD1ZxfXI4V8yXzu5/t//lFwhRC3vVPR7Fgmh+ida/cxWKctOW3umWmXFbMnANx0/fezThnOFFQyULZyeQvNcTD0MxNzU9PA/NIpjIPEmxiBOoer47iBWzDctTV8T8zdAqwut0Rww+hewOBJnKZeIpMXG3QqXTiKGUyRoTTDL+iRxO2N7TDNMJHPHnl5V6sxFTS685j4+MzOxpPPGPrB7Go+vnEYOY/0GsFCqVI/71V656DiOlma5hgBGxuyj3K9XBM0ODyfWNlCT51XwQ6q4ibdx3QBs8XE9AYnB4FvDV3VpAmp2M75RrhEpyIHWzfwQSWPPfXY66/e+wiTzXrhbGM4DETi+zw6KmxNExg+Nhs0ggwMzCFuRtW2sfHtGy8cvNMPOalQBlrl0JjbaZPcbm8715RQU06uWbZ1uaknpPrJ+f5JddoVghN1AuWRdd5HEH5WnrCQgrnigjUyyxG2Izjx5Zl0zVkPTuBx2PAtzzRYfiOaJIXs6c7p01999dJJwHJsyYaqvxZYFtMyn/pgY9eQw9mavnPj55/jFJgu+NPUwvzd57Z+fj5hJOb1eqKi84XIeQ9EytJW/rcw7DFikEmzvf0GlIW7hXzPTDaqhp8SzerTGwnMsPg5LGjapLtLM5RPtTdVxoy2NKHGgQdt8SSv8Hx8/q1sQWgU8gdbH0KG/AJqpY92zntxnl9anb8BdyTKapsKvkfVmGUhLVKLRc03E6K/ekdkfWLst7cWSE2jWKfD7bLlXPCfOexlr0/KgQyBEcLALNCwPEp5NX54MP+lZ3pmZnHRCYBGeDoOA7eAGBaw+wtReFoLUxg2Fn4DzrmruQV4PtjwzOKnwaMUmRZSz93ceuLRR984hcogZVbbZvL125ENBboQChk6a1QH9Dk+QyTmDcna4e2VRKQDieyNkyXyIhIxe/nV+qo1XvPnGzci4NAxq3X1pFxW1J8TW/defbOS7JkNs6q2QRqzRi+SHXJMeL/Qz1BFWpGIKtWUKHHgV1BeDzScEYKmjA8ndm+TgbjOfz1/8/UtnBd6A59dcJJaBXG//5a/uEwSLOVz58SiwDOgXcs2sGWTXwZOUttiLhfc1nzKoDvgOKrozPhw/ihnVUNWiukIISTDCDFyAAsYzFTOh/x2bPbLubUv19nO4yODsx5yWQjNjdalQVroWjn91WbHBWOziMz46InwVFZqSrwXJNFSPkqlF45voAv25MrtOO1n/GoP8QCCVy7a91K0ICsKlTx46qOkio509OajL/xxUhgara4eP1nKF3DWMQGF7NbJbCGVOF6KQLywcn5YEQwuHisIcd3s9RoDAdGnzfo7MVIXayyOCuyVfd56HSDKKpoFqtYd9FX0BrKCERVSJ+enkfhGZDVcvbv1ESbWgwB45ebByg+zvJ79wJkmvKjACauDTTUUTQOD65zM2HLvGbKdcPi8kqbIlOSQZS8TXUTSvjiWo5pA0/e4A70MzyTMCiiMcBifIn+Krx6cHs3cN+62o3R0jU7dXIE9CkXAcBxf1rYet3J63AcwLWynijGjlft7uMZ45izGDLfJBRKyy9TSzo03cIY4H6b3aEFj+N36xm6vOkBbJKpw4D/Dqzff7wyEZam999wL3+oDZiDVSr3EUq8QNLJgTO6dhOO1WvguPhP85nzkOF9vDWWKHw7Jrlkv1JpFkWIFyPLIBVDkqt0OkZrPls3SzPJ1kaVwacpqlDc4mtZTqdkVHLBaWIgsZUtormBeLQaWff/cfGD24mSVt1PrtJ/j/A4p5HJ7KRsylZDDlnGChhDRAverTYnln4Ud2dBojOk0vUxb9gntq/j4FNY0QIEJXmHgoTg9sPHNouVKJzxTZwliZvwvPLGsqGNloKM9D2yR0GMhBk14wCtdj3Ey+zee093fSK3bv7ORjevxIZ+6Hc+ShVhs75BWapV4srGU0vVGS3Wkk9DrY3jO972W+bXf3pYM3eD5aL+tCWYewxorWT1x8PO9SjIF0m5jBSdKDua/DgS5qF+Uix9coIWo+Fi56GOPn3xyd9+Q+mrbRzkom0Pq7q1vLsuEiOYO26YFkeOYcow8JDEjmHyJ/Go/Uja7Rnz2ADMRXnka2icysUtekDxKqVRQ9BF2Fo0dh9d+zZvxe22xocpQsrp95o8JwWfH7/OMoyuu1BWwcWMhr2SJ5mxIOr1giP+GE4DOLddJ9qdrMErPpxmcQF78dPHvR0c2OkLwMuRYV0YoT1jlkf3a4ubFkf8vPG9RSp2utbV0KRwmyW40pg+EaCRAM6lotwHBEoRTJ0c8mizNvtBo1IcCh46BJrJqU22KBlkd4FbfjByfHydw4hhS2NX4SaKUj++uYLroOzzDDmNP77/7RbhfA2vtT59ti/Xk8ZJZq2kSlXOMKF1vW1UJdGckmx3elVNZJVXO935KZWleMfGukSRjRMmFQHznxk6i0nkuYZqV/V5S9fpTu+ttVSSMGqU2CT/VppApatWGV5lC61w+pC0q6D4E8akZO0gOqz5Cun0N6oYcyvgZeM8r/zlyob9MPWth9x1HYcjIReLOKCBdLeB35TKtNfIF1j2o5qczOd9eoa78hf57YRnUZ5X2dzUjPWRbAjcwAmFdL5SFWi2bjNzb3U35RWlTGFSZGB8dprh0WoM0hfBz6KyDoRVMrh7ZgQTiBG1zQamK6JMU9PYgvFeNdXNgmmKJ1Esv8KCs5PWV308wDCIQCHBFuQk2EmoqFL1otbAEAc0Aa1PZGnKlNBkrdA7T6FjWcE5MwH9O5/Vk4ubdxBKJuCP7CDOVLufcsroeFFGxlww9aTkrftO/TJmUy+OG7Uw6ul43skQkjugZW3FoDFFo0poROOl2ovXjnrMw+Asz/J6aGuGZ7FXB9Z68hXusy+jHVTqEH/CZlpliWW4VVbvLrYJ+t13h6dJ4dn0zSu5pwrCrGH1NUgRNj+w+ekfrthU0MOLxjijXWA3Fi4DmUYzjj/2SkwWxxoKwFHPNaLhy8xmIUg+XcDRWkLlSPrKU6NUFASRTq9+Q5WNRFAn98A4ldvbPewu/R5aOggTRzIVqOcAJ+YCjXauphCiyhJ1iRU3W9siNi/gFacSGkOfx5QBdwmG7D+7ePU2Eh0UQaFMuuVDXOC7GyE6JcrrdTjBsMxn0fPAiM7Aj64W77Qz6Y7ChUUy2ePaxSTAcSMSBdyjnRT1pwfevlft0AlNb3OXzUkNP5X8CkpYd/hvzyz2PWD/6FyZQFDmojCSLlOi62u7LKusn6+Wf9pCKnwutPuyjX10K331L1wf9WldQyubqCu+n2GC7JisaZ8QXzgjK1h2IDOFT1VK1VjUhQqpqAodpUQqnUnVoONFPV4uq3DAEXlIW+SRXMxB80gs445m6dxAIvifbvLkRls5cxm4jStuMwBAqm3NLSldR6UI+8Ovdp63WEA8WPxk5wRMOw+SdqBGzu+YmwUYUuUHq5B2/X82pm5fZIF4oDO/B+0JT4x7sSNeMY91m94wCM7ghD7QhY5fpDhoTHtc0zBN44gKU8G1dn5wGIOPLWjubBaM6868JY/+EJitbggMZwTr9ZQaG72NZrsRf4Tl+3c/UA5BClm8c3FuQl4uUyDpiS+EC9HT9PjLBZLZ3UxMZmVDbrMIRPi3ERAmfQxT6qo+C3VaZdrYA0WeLAxFqlA22KSSeA8Bai21RotYpd8vnB29ph6TUjFYM3tg9PUzFinYUgGAcLUBtTrsv/cH8YXpdJARIV/2UT0TL0xoXvZI0Y7Sul3QwMKQsnpXhR5nQ2gTyRhej180jv+/sjiSngeYITvx0Ff39kHV7zUlcPytOTbiKjM3lZn1yNcuPjaADsWHxwU0nkp5LzznazZfQ3nrP1lgWCrxIITRZ5vsPmlebflTAj94XB0tYe4MYnnUqm9R3M5N4T1zF97aj5Z/qdbpSqkcYP7fszdXkWDZM80wTRLnZX91NJDlWbQ/6QWFx+S3Rs6k+zjolkYn2KbXhoLw5ri4ghJWiDMK9hga3PmhFSs2ahMc11ewOSi0c40pkS0Zj0AivrmY5AhVdJuQNWYhmnHZVXMBI4MNwEFUagpLXZedj5wfPfPjCQa9WpSHnyFZIvMuykD1cyG+yk3NrsLFMOjCkvBLBhtwty59d1oBz0+6WREDn+rhhzFYMzKadC3lVrplbZvtVegyv2FqjrAf5J2C52saXd+IH5/KytW7jsD79F5j/2CjWVVQamafNh/7fImWjhKNOJ63Pp6LRx0M2QtyEkviwToPEHX4TFYmMwydEGZpWRL8g0DLXoHVa6bM5rcQ4niU+pTLu4FtGi9FP5lu+WlUQdUXJKgOcksCVKN2v9UE1qHK/yS6DKB80B6AptEb7yOB/6lSzqx06lLODcwRxlvG6raasO8MWTt9444vzShXtMZ/f52Ahg98/wBHtr/QGb2TL6P9zGTjWWrUTSZOqyzrsNikdpW3M+kU6OOO5DnuzXqD1hdrPy9ApktfNo2wTPtOd80ltVRNreqExhh3+Vwiytj1uWpeR3V076tH+Lx+nQk4lul9+duIfFK9+43IJ/RX2nlyuGCyWGstUrZbsRCI79xr59UWElKPwwsLT0AC0hoe9zt5yUcTpGHSNVc3HcrTaH2roJNcQkignfIWdsLvg5Hi68Oa5LCh2oh4WeaM/0Mqm0ISWBd0uRGu4AomIFVW1SQUUrdE4Lxzp8DF08ph3gRAHnmAioaYOgcx22MXym2+8/eRBoaXacvb1TYMR9A9WsN8PZjeO82bJGvpRk1h0LfzplLEpu+H/bM7ArChvfJ0+XJy59cllwB0FCqtwsYhJRPCMqIVCEiE5QhDZ1IzwoD92yXFcpfBA85IzwvWJzYVOnTYFtVs6Xp+Z/Ldh/tuJWtf/Ckw2QvYvOtQgWg1kN4lVb/kFWeKsZm1YCKcNY//3hc72InqbQj4LNhkdltqy2hdMHIZX2orklagidBFeSuhDS9Vs2kK2NkGURJs26NaE6EYK7SypicWi8sFhmiIkk1qy1JL2JDmq8CWhs5/u2kfNhSnrNUJdDTWG2ys1ComDg/mTQwHvgi+92ilV9ZWtmzsXkQ3oR8rlMpgRjjY0H0XeOUPHyOMJ0s/6Z7mMnbp+3Uncmv5k/Co1hM0hIZz0AFdgiiCEFh/LijY3RJ8S5WXH/rODR9gCGFybY053ezgRa8ayscfxZ/63zf+D6lXBtOaPlrVnp93ouFPZmpBKpczB9e/8xCYUcozPQX9A9iI0WgXie0O0zeoIJw4KDEMfyrOs1tW0nAOzxryoZja/PvI5Oa5EhXJWpQcCQum2q9GjD46kdjNKIKuktDaxDH3kpwTbrtu7uKtbWi2JRSmXCVnLa0d5naNkHLzxUZQ3w5Yxuj38FqRz2JliMh+o5F+590p4yOsQIvIClF1RcZhaVzSTvLP/pO72QHKoNF2ea0Ta7X48c+26hedoE4Jg92BN3rp1y41umz1Y5MEwEhTKTJYK/YPn/8CZrtw8X+ULlZS+un/YzVyZ8D+/rtKqv6O8dWvtT67O76W9Oozj/glFHDjncDggZzcHDsPtezbOCs5ZlDu6MYY5bKfNWjQclWU6AhmFaKZlI13RlZWgsQsxlRQvrAhvBqkXBVYQWHdBedFNF9FVr2f9IDrOfffVefb5PJ/n1+d53s/zWV9sZjN6YId2cJlrHgPuPi6n5/NLP142ckpjZfPJz6orpV+N9Ep1s7KxfnzZpPLGs5ulN0v0lax5gKFqa4lipVGaaa65xlo9oRuckwuKtGl3vjus5K9z9Zm6Fy7Bd5cN6p++WF98jyzu8fnS2nfXhCtsJU4eTETdWvOyYdNoqIAGiuffzewtVCaDmfeWyE/ajbpHWfrU54++tkAw9q3PVn59b+XDDTpCLbAjzQabnz/cMbQfe4fnrqbG2/plt6sdKOK+DGSQQm1NkuQtbc7VwyCgCmo56HqNnF1olNcTQ/9xJf+NXrAxL3dK+/v7Nxsdui8O76yo7JuEA8Hb8L7/8ae84Hda0Qtm6s3vvwcynHFqZaIF3y0d71fHgV1ma0FlYYWc13Cp23jvdPbhpxfOKvlcLsvh4cbVVjl39mNZNQhydXH3coGqoPzaqkX6lGxBkqtZyJ5fE2lwgacUQzCZOaMbDO+SzKnm6+5lFsxuDr5sx0S/UTHR/XZ9vZJvNOrtGBDO745zYsKadW9trQ2/D89u0P/i5fHpr198a3qPhN7WPs2nJnrb6aCxQHu3RXftIjXnxHQdRTyxeO+A296bE3rK7k9SlZoZi8Kj7fkg39ntgXfxijFdzS7HhwbyzYOnAdNBmYQVq+9NlFYm9mnIcrK3+uI0Zf19FGtbV9eK8r5/mfU+05RPkb+xLSuuVuxgrXrkpHSTEGsjo1tqfXOimjPyqh966ydTIyNUapxUpl/a+ZENejPnkVOvPso20WgTCivPpA+bZyX7u8reUiTAKJA7SqwteStjvlu/dO0wlPhAou5SP7LcG3n497HNdaO5hJfWbZKVTpjAy8W0e8s/7374Lqyrr+nuuSgIFPBlVrHsJhDBVve9qyc+/+iH5x965fVPtkorK9USeLkgTcWU4W2P/FrI5/UlJDrmLGPVvvMS9r2BNy9htHabVVPMblzRbSNHQu/D9CacUU8k6xkrpw0JOYWZ5Rp4nFq7W2/u7QAOnx47mb25mX0ROPTJ1aZ+r9/rnS53+y3e+A9Da6GnxOJRSo10HUfP9oxCWM54QBxTbuRHoBvbejlTD6JY2wuObvanJzqd968Me6kBCcsztqKsNV98Uwco1Z48XDrOr950pvJr+YveYc5MUWIu4ApLd1H3+ZyFB6RbwPclgBUrdhev3nn/86u9M3uJsIeXXS3C0lL+QNDROhoevfrp/Rf3JnP1xtL12dhkvdk5bNQV7pHIxZJqt/rwW6//8uCnjz/15O5CiVKR4NfArmfmt8vZ3TES7OvLdiLe0rQDLL3A1qEn+Qgy4o7rxqWUQPVTVsoPln8+2T+tbG9bWkKL+/DR0CDWJlYLYwVZoWcud301dXMzNbUx9t7h6unJxv7O8NXobmEtnz7Il05ulg/uzDkhp4Q/splyWTc8n2xyVC+uEaRJz4eqFQe97NraHCYx1naNnGL7RjcKepwbsLFMvjSGZvRB4rh6fX0Eabk8bl6k85fHs+9f5Mykuw0I13FtPJhckLMyZKvrSzjhbbJ7yfsZJWNNVE5+f/iNFzqbF5f1H78D9lRzMQ9wT0LDE58fvfnj7ff3N0nxBDNZYlJ7Z6u9RgM5LWrKF93ewjgd5X557pmPfxjbXF58c2Ez+NZX3C5IoM7PG6Oj73aq3TWcUHaZcec+IJ4aTIcFMv1i5Ouh7eqqr5ipVJNyU8BfNTU2J9aKXeoQdktIyXbzn8xR0jw+27+52nhyY6LUA92+2gvK1dLqTPqkEZYmXt29mtpUTQqYeC8E1ewrVzkIExpeanCcwx/pmiYm3pppGqrYxHuSuUsI/pZ1/jEfORZFIdraca3utYsEJ8ZL7NGpR3SB410u9ULfD+nG4fiqrrZ1N9+o5/SiqxhBuUjymnlx4apo9R9/pyX6yUkPN0Vv/jyMTSJv6Eot2T36PXy488JXv/f2DuxcGNOAYdmJxFou0GOJWpjsVsHKfskxFq+PXwHDXxwepdfydoQYd/dGd6eHpxZmKj9Xru1Wkm0jFwSFsHOae2sYRyRHVVK9JC3pB5gJ0ocXQMTaSXFOhYWHHP5lwR2Ykz/ix1za5dnqr8M3L47TlfvkZPLivbNV2n+epC+Dq52p/d5iEPVbwst8SZQ0oWdsxzFodUOcsEEqlNVxHHEp5A3s3JwWcRJITniAV2bRj0yjme0eRJFjv/FlD3So3jh2wZrEzLYGKqJlsn2Or+XWQJDj9ri6Z3rH30lHCQYn6dWUfn65+sLG1T7GoKmTaQpmGsf5fNdW6hh3Ho2LdO/sR4MAzxxTkqyWJLDbKAPlnvPF548+/ctbH3Oo43B1ZXHse7pe/vzzkY9irF906GY9trO7CY4kVFPm3L3fnEQyqWh6PGlaxKZcu4kGsu5pcVMz1czy4uJhtmm3NSGcXEN/ZS7+9lYldyH/dVer1ekn3/psf38CT/vHi9mRaqn0Ht1fqeS+/s6mSA5Yp8MfcWFvC4VUzEmFhLF9lVIsyMZKyW85sp8bS0JZi6enxjo1zbG05N22bdiJ9sEXfp+q1/Om5SvqdsbWknYWXSVJqfvl77WER9YAKJXiQbOLS5tcjJAz5au37fqP6dNr+mxRhqjC55u7e3YpYPuas9xcU9HbXtRXU/zBYIgyhoHsEa+Ze+Doj3e+fIZ0y1dvfVZdGP5wdOvzz6d29m4VONs9n9x9YfigS/fI05quZg5uM+vbimlyuFFcw6w7SqbbxMJp6BRkkMN6Nr/YDBo53bn312xbQ/98Ipf8A4fz5aRZvBfHnwRYvt+pln7lkIyxFzlZb3d4HZRT2GKjrx8bpqIe+CF5s8IoPm4/BcI+qYETgYDsyQTbgLE1ZU4k4luLCzdjhLSdu3gcEAq5mPCgfUuVF8KbSGS9TNZOZGsoncE4WCu+RaPId7LoCBzyL/3iYKR98Awzk78Cdg1okL60lI0KHZ9qCdOKDary+JYLlhSIFbcCZ/n3jeachbFvgdt+X1qdmh4epn7w4Tc+39jZXc8klHZx7fK0k9ZNKwRQ5xs1vR8eHc0buhGaLa2NwDmWZTP2OCIUp6337frP6+vLXduNt2IYfIX6TQgr7MmzILnRFXP38ULd+urJx0beef/9F6YnZql8eOetZz97kmTF2K853YrarWTMvsxF337zzYeL+Zneoao5SQeFDUJkTtQI4s0r5l7XWgLBbT3gkNhvCX5HQ7mKRIpC0CBvAnCEq5TP7TUi4id3kjwRZNkAAvlXgJqvvx1eUcYth1Efdd67zJ9WG22vW3MTSi47v5dFo7OI9yT1LzlWHslBIBFnkY9E0mWdWwhBzdOvTzudX+d//X70+y8+3Pr94Y2rk/VQtyzdoKVUkGvNxdVaGNmhoqrR0ZvzTc9ICWKYYaVUMJypuNmaI9mWUMLt9UKhtLhZ2w6XjDDTWGoMyScn/0F3SNAOQBfjmJwFYfo+fd+mpj97gePDnn3n1eHS6cTI6OmMkcLNbhebzWBlYnf455XZq726RhoOCj3QEpsP4wvxwIVpGcLaFjoUNSv6mS+Zo6b243FAzUwxyeUkinYmMPRCA4U1YMmBqLA8jhhVRg6Vk3ETeYtjIzCdRq932Ptqv6xSfc9U1UhVzHtzpBlMU3Mwf0AoeWJNksKjojjvS6J0hGuS1xf18vX1WZq+S1svbFZ2f6aB0mLNiBBfI50+/HEp58xZGRUUsB+GVO4HmRDJS6UYuhbrR/0oEky7JriXop6jq8GbtYx/ZNxGtxnfsIYcKIG0C5BLDDxsBW2YYzj25Pc3X321AYj/xYc/ef+DZ0dWSxPjHJi1uZRVI1OpH8+cXV2VVq46ZAEtmBpeQ7JEV5qOZOXgUsEvYWY0GBVkqGa2nL5ULSXaMyeG75/r53HHtEirksfCWFHxnJhjUURR4GKC/HE4JhTl5RDgYF3QrU4s0riQ+YtD6XQ1H1kag59rATL/7Tcm2nIwZwNtY6aYDuw4SMAC1YjxywH4n9pltTzj1yjk+5DD5QrVNxeX/TjDMqPs5NkS8ex4ygcBXFT8MDOZJQCpU2JxbArHJeP9yL+LUiSCWy2tiBcaKayooDbBELcQ2yFZP0meI/VcvMBn1WItp20cLqy8l6ZMdWF247GPHp6aunlx66ud1fcq+9TZZpvEzHonq7YRZCt2Oy6qRQPbDbehIVtkjeEuGEMeiE9C+AbKmIkEL32FEHwiaWoJPwOZNWgnhZ3coO04EIGxxpUycV9VhRAWJIU9VF1JIWl8zsBhVy6O264KV8GAXJomNE3OIV4yBchpJh1eCGlhd60Z1iYrOTQFC3efZoWWrlqo/wjNeJDx+DlSwGasduwpOiwY9nEv9ah2lC3M19Q4vpFAsZiVmYJD71i9FlfMGdRhiprjV7AL5mLI6ccf0FoJGaSMlOVmfi4VdCn7+qyywEn7VEp99tp4b++k11kEGIWQV4NrikG+65xMUvIGVF4q5VTHPT/ORQolDCk+XaRUJFkYk2/obbJ/jMLbbO4uBLCcTCIWUSZq3ZOBakVdZTUiU8rGLJ0oSroXqJ6xXMlmuxCS7VZRYaYg8oWTY3ymyzbUXeMJaopHyrL85aKIthLADzRm2rwSuUt5xmSlq7vgB5MSI5pzpHSSkQEVZp8qxHQSYmJMct2QiIep3mWWv61ka4avMtC+lKo7LGy/z3QtkXnMn5IwkQm+fvvN5B8zNYQswrzcwwQAK/hCRgNzJeeS5vmPZ72rDQBtI+OAcrO4d7ramKF6qgvAsVk/PgXd0cxZrEXKo6KGtjccLGUVyQ3KSoqJBf6pxCPEJ56SsK5C0ZKi88BpEjUDFXhG8bLKmAOImUpYZj2o0L+I5GUAVStQ1FdVFe/ERQTZoLcTbYdAgg7qijgTHyOeM5wBZRk9/xPjzjcMAkG5P8J//xxb+kkduy/vFouXUBwNXjZZGZ1dqmNyg0F5SitloodTkWl5eerOJhcL2aOjUPX7iugfoWU/3oeaQk+NsVjo0pYQlDlgFYZEYTuC5MbRYBjiACZF9llmsyG46NPpDXyKhWA7u223qVbY65w1xamtN8g0kn5NIURR6OloE+rkWRKZCiUzuRqeRTEV+SCICkcHB7dqBDNAmn7/jvOoERHRsQITdXQLYrsItsILNVNBN3ZOD4PJmeV0xg9TZHtJBqFA25YUNJlWXDFooOXZ58ffnRdxFvhEntnT//0slSi84oH0Y/NkM8gO1XIkDIw4yGuF1BK8qequqysiYG4d62Z4ShT141GkeJczm1yTleXF9fWCr2D9malcPAsx+YZzZM00AHOpPszAj4YIoHBfu5mjn4LkRrjgBf6EnGmxgS9fmh0enh5+dT4wGnWpSCJ5Qw3yIax4fJ41FMUDJXWct10LT9ozYQ/nrl8LZkhFngI/J/u6tzvMuWSF/HYY2rrHfvKufydKR8NmJBAyZdAMgzIIDyaG5qFt/whOrOnhAnbtyBXqJMwEBRHwJqaJvayr6143comvstcrQkaKT0QPi9piUsTo2rCOOOBMHHpjHxNcotOkfDWqNTmpL5tOB4Wj7e2wm635mTCb6R6ERCJkw3sXbmdpirqXzlcW57Nl1lQpxi0LqiDSPAlPYvbErdOET+FWoTNlAkMJglmGbi+pESVwLD3sBfcjPxo29XJyhTO+fh8p/UqxcD7bkGKv72h5k5scnl9seHqEhQsqZ4ArglywXQ0KzfM1fRuY/MbG2A5NuEY+25qeGuEwdqJV+xM0DAJmZESpIrIxKPJUff0utC8vbdaKglF3oMwshXDRrwWOryH2IGqi7QgLSnBTgmXQFV6tu5402qlDNvJuPAlLCuF5EGhCzUJSqIvgCWgQfc7KQWm0EtXUlerwh7sbjPDkpPrh+grV6vmZWi3jqYwoIz2Bsu8F6Urwa6NcQ3/akS5lVCyIcKcVY1Fge4RZNEfLweLyIyyglzkKhhiEuCN4LIJ98FMRpk9JommIjlE5V10ZvXnh1fWgFDTKhfRmEFQapEmMi73NwszlOZG0Lji1CZozpb9/lQj3QqnaoUfFG1tbL249Of7kCy8+TFfKkbGrG0402aGP4OZiIBXdth6lmKmihl4IGl1xpZ1GkY2CiJUaGQZ9co5ueQ9V4r6FWtMgB5lf1phrUC/BgsBuDLOtAl2VLAfGSVhYyCllfeL5EucakMBhOyw6PK6XC4s/7+yM08meI39pAXgFopkTDXpUImZC7H0Y8uhmCsuLm/OFrh8xQN/ACBBY4ObYV26FnRElqWHXxdIMdDVgWu8oWF4cEkY0eatcGhqBv8Bf4tF2WXu1m9/r7ZwQbsjVSRqDsW8sYQps7yBjZMGxeV7tvZXOrpwUtTr+7ui7nHzy1gtfPfzWk1s07pyi6e5nWy/sTD+5g8748Ivh5ZVs5QiIhi1aV0mhpnxFAW4AyVzdRT6EBCputKHWbm9vYU4ooPhKHLDagBxFahhhNoltaHjK9xi2Wy93PamYUrYVEXtJuFsiakUL7YHznZJiHZSfzqdtf7u5P/Ii59h8/MErAnZ84S0OAOKQ7h7nc3IbXZVeEzWvmSvPVJbFFmVUlUFYjE4kyuGCMtgucdHEDkFPUZFCw4jOkouVIciI5zxQ5HKxmiIq2BY8sRxYv3p5puypFpLGynuKjRNoijSpzZqgQLJB/rREyy46dE2Tzthn6cnNTG3MvvrqV1+NfwYy+4ae4b2danVxHWlvlLfLUEuNUhazxPikMC44S0i6UI/aRj+DCdLPXVfN+bqOpDFLu6hATqiDZw07QEwupsZgFT8HlNBTdW5iwZXQNSXlu5Eq/kSELlRDGnFglcPM0fI3I6PjXz3xziscqvLUy4+88+znT3Amy/jI6HC1kq/Ztto1trtGvkvioFY4Wl//lgobxqjyjWpLJYSiKENIKgs6YE7YEzcKjjX9sEuF2VBCa4PfElUOlXxfHOe4jCST8n1VYTkcnGhZgEF9F/tuEaB2DA2m2vYS6IwspVUkCCcmxgCzb7CfWh0bG33y+9n9sdmN2X3CKSdn6flCcDR/tM3Ce9KPTdWhKK6qDNNHX+IQGar4sYrukwFe41IoiLJ1P4y4EEM3pabuIrytwdKj/eNFRfY05IxV2kETLMW31OsWYFdu+2dR5/PaPhnH8f0Tg1qCUOZlIDLElvTSxEOb2SBjdkhiI3oo20E9PBMhiDIyvxijwxjLDhpJIYMeJBjxKx68RC89qEcboVA8lx287ODR1ycKPsu2/kjT53k/n9+f5/nkcJ/r6kyRez/YDoATowLy8fM5pPnR81+999Onr335Bvfu/uT5D7j5+SLKnd7dJBmNWBB/5hlmUxLWM1VpzAiZ6YOtleBMui4+KKNvtHtjlgEOTvPbtKfRmCRAdH2Pvf6URqTt44XQX/H26TKP210KreOJivCVj9CoggahwlOQAl1/rj16/VDTvNmEJZ3cDvD941c/Pn3z69Ovf/2482h6+f0J+6V7t97YShIEA8OidsFFP+l7JJM0vYusdJn8loWQagoLtjErhayAuM1svX64rw32BwCKTwffD1x5D6OLGZdybyJ1W1oyI3vE2SSGNUKTSOAP2zqGhA6qLYQf4GyhUh04Kc77/HefU1D2nc9feemVl7hHJbefevW4w8LEO+eMHBT197DukvOEppkput/FmOcKaW2X1qAtdiic8gzS+ylwZFrFjH9gxz/6qLtPMoz1tIjybhcL6sUnkWEYFRAr29tcBsaWBSiye7BCBHF0iVC1sU4OEHnMAXTNVtvRjP3530wev5nD469K2ZMbqnU8jnu3xvnZBZH3kQ7Rr8CjxdqCkUYSV7c8DwzF7mvBBDpw9puma4fgiYHdag9aAxDRQQwC5bF7f48xwULjls4TZAWiF+0hClmgO9SSfsscaxaUynb7Qz6BW2Mx2eM+NfWYvySgvuD8s8+4kdwH/Dn6IstYI7o5puAulU4UbkOfjQfIh7HJek/qFPI80WEjXS+8olZlgaZPmVPc0XvGI84UbdV96D48dJ9+EJMJnb73Iki9fiCgs9uaHhPblY3aMKClj4hNHf5xPg4M1qbOPJ2+t1Gd7JkFnOcAV8eMcxz/Gyc+6XwtyTuE5a+dPL40fmZx3AhyojVWsDAAyQ3GDZ3SiCR06dkAtZNui8LqbykWLPUaMbARgOgOSBrrjF8GSeMMt9sGKTgZpAZC0rqQJTbjTLNM7EfL9voaL1LtkoygBpA6loLWTwgTlXapqnCRLeYvYL/N359HVSd0emHv1nRuHRO8PLPPvOpIUNMI0iT1ElPGu9/ui+StlW06Gp2EYu+398zuij4iRuhK677LcwBGFu5RjIZBoDoPWOxieunYNM3UKwL7L3ubataMymtsGzAdezZLPKsF9s+19pv6Vsi60Y9XPd/3ezeXN53OzdfUlmR/0J1han8cjgAGTYtv2QRBnhZEW8+1MPLge7Doum6D5iDFdboXRM2ioVFXhGsL0FF38O3sQiNstm9tIQ0+cdiCnhmCPoASQdYSfcMoE8/TSs/mP5S6TShFSHeTw1QrtmnRT1lfP67VJsqGWZ5nGCLr7PRE2XUdBH3bGBtlUCQsX6YHWh2UKX0qyjoVmclUUlmmLlPP1Lyi5KsKmpXAWVu+ydpuLZq7Ik4CuT7svc7C+iuNsjTeRd/zzMDuGcoPVOVvwsA28Sl//uHOdgKbxQGmZ42w9Rqb+zmE3EBnwRK7CI3z6+np+9nx6ekd9cnGY0JDbaLOYvs1pIk9AJqIZ5LKTF5qeh6IuiiL1jZNt9S0lZamYVmmJYgmI41BaNCKfnj17Y8jFr4n2E9gx3hBCnwFSLgZKkWrzjx6TuuXAixX61sXXtKnghGFiOWBnXrnhhfUwaa6lPsoDalxnkUR36dSVdp/lYoHKXid9UtVh0oFdVHUpW1qVqIPin5xX5SFBxcAtJWWKiyZov62pr+8sU3vQRUv2r1fdfd07VvZCjsZO3K3rZPL6aXy/U42x/aWeoZXk5+dM+o4MTVnHoIf3fmh5LmRyAcCq6YnTDAkfJxdPr75hmpPpqZDmm1MGVidAgMSujlYQZxPPtlGYphJGaCPUojM2sJhkM92W9iFUmRtY4civ7ZxNr4wYN8Rw2GKTe9C9xqBYPEXBvbSNLEKrFQNdWxpYGanZUo/TM4ewOccfS9lyFrC8sSEUjqB45RBWPr+pspP1/Pd/AsYvq7ToAbAQKFuvGQ8OTMD5UeqCpSqQR9YeVuVBB8Uv32P3kDSYRUK9yNBmnPKArqwyq0Ige0ze6z5p4Dcb873d77/2FnGx5V/GW+OFp3LnMJDDvtKED8Ju/iZICSBNnAHMDJbZlHzYhCgDlL7r+mdT8JuYtClkbjiB/iUYjIKjcLvz4hCg5PhPlUbZVn2y8Rq5ragn0CVlmEV5+QVl0v/Gk9vDKnMkhJQLDPQLgyt34Laii3+dhD4hq3SoJ/AojMhS7vkYZKmZZEW7sDb6pBuC0I1NfbJ86J9Yky4ZqWqKgqz2I92axg+j9KyrCvwCf06sH27Zyvlh5uoiiIgU5d+FWXrdVStw/pWBbZtG/bYtlXIS2FdK6XCMIsqFRQFbtSWbwfR1Z5vLCmstjz//m76dcRNMtebOL6kmPfxJYLToViqB+OdmR76KPEMz7Q8S4f80G4ifp97ztULFbJVZ4qGZM2KcXZ11X4dQwGzf9WEt2jkBzGF3NdHZ+m0DmvbFhQ1yG/WRzgJqCX+3SJ/c/f4EaDmJz0/gIiRixAZzIymgiATgC8YyNS/jhWXEUrW2E3/l5GqwirgO34H4KididYD7NkMGNIy6JVxUPtVDJ4V0xZV4FSFASQNmuBig6OKwTXOj/NoGGVVFsWdKNvNj9bZHNDyqZoqeKdHeIQPR8B7yyKybDOfVyFMjx4om3Hc7y0fxY/u0DjcJWN5mUfzjDo0Hdrl+9fXeOXKL0v4BuEBsY/Nns0TtAELX5rav+9CnXW0QMJ3egaa7NYcG2OpRfKi2LeuK1YWoYQVvN8UCd1EeRTXdmKi5cXYQdwXUFVa9u7yPFqiK7LFx3ksDoAHmKhwzxRUOYnPXJlnodrkx8fR8tG051SQFULXVqAbBDYdRRAgP+3CTG0zNZmlALqvwijP4yiMaJ1YhTEkN/eNSYmEqFW1rqJ1lWVVnufVen2URet83qF0waNH06+h46MvPsh2GwEbHU/8QXGtWN3eqkfXi4/nw3UU+WACk5WpAtm9D4ZHxzmlOU6up4vFghuJnXbefJUqPDfT67so9MPACBpZQnIb+eT0Cy0ZaFgRGKI4tWy39zvz+dFnwyXpb4mA+fZ4dPjjc++ifggKtglqQqBuFz60ijDKYoJ3IfqB/elwpThislKs701++Nnxg+U0yiCGXgxas8RCh4O63tdQQkBqnBkTFa3nw6OXszffXxxvVChcl0d+5aNCr1UwoaLI7dkk6MkbzsQP/c0Gq1OObJ0dk44drjMQW8c+hTyDMqh2+TqjFHKuOoss30QvgM96fto5JcLYWWw63N6Xe2LM11C2CgJ1G4ZVJ/ant72p86jzPoHheTaMQrusCyyFMAzVHje4jq8nFLyfHu8+Pnrrs6PF1zuqSzy+4a7G38d+PA1uO75/EvSIJwsjuYyQeClVrjCa9PbF+flpZzjc5Rv/xDnvOVD05NuZLuXBEKBNbqArvo2me2kNabD2grGOYWKt33alFBHBFW7YDV0bhty9BdWmepLnwISUpoG2riNqERPm7Un0/hH34Pvii5eHxACXIcLOh7I6HZmpKhw7v317Lq0XTKGFaQSSX3Dv5COOtaACnLw0/CI7gq5UEMbxYrfLEQFRLgS69PPLaSVnMAfHzP3us+HffD5HjoYRkFZcNQpCROHdzenw6LPPvhjO51HUu4vDygf0eG+xuPnmz9/oApG2N6mG/etbC9bU/for+xnvvnHupnAW5B9XUSeYJBethBgDsXRxtnkgkUIj3uWdahjFY6Nn3vV8x4CwWgAKZQqY7kFL9B98qOqqyvjO0A6wRTDasJ+IclhUDj2nnCCFpjTiOpPJSYC21TEHxTa2YHcLi0fm/6STZ1DMB8z6C4sXFvnxabQRKKAsEEWJOE6Pkfx2fbU8yX01jYD5aM6QhzsQOtqsI2Aacgw5omrXi3c32XEU0SumOs5Pp3m0lh/E624N4DHMjYTaxWEQ1llYCZ6lMsJw06nmLwy5KTSXk7fDZSaCfx7tPd7YY7Y1jy7GhvPbDaXCf8dhpFDckkLq3AfpG1YIfUyhFJjKdjDGcZ/IShCrPkAkYtlbY4yR2N9FPsJ24jmYN9jlbkvc3PsVPhEhjgKb3fJsD/sZGRXHQRh4kxNv29Jhds1CUdcg6DWS0jSMYOrg73kaWOI3p9hLYycIgmpayVAhtS8+G4IOnIRQRPbF0S4fhlUOnmGAZPN7yx7z6rMFY9HJjuc09MIOlb6G1TM2fHGNt4AUcCJ0OTJR+cqnApYfoOcv/TC3c4JLPdOz7XN1G9B8W9WpXWJegJb3F2yfDXdHWQZ1rqNdJ853+QKhtzjaG5vJiEETUfDGV78tv3ceP46Xd4pCrrNf/vj2hx5ET23j02l8B0sSomu18BxhUzJ8pNZaSLcUQV0ir7DFUAiahSU2GKDbXflxD1xxMEpaXSPW6p6Ke/YE26MWPZdgLhZ8XtnYIsmZUf/l30Y1sl/ZgWnTfDswzMmJiqq408nnDAA8dln08S7LOos3FSKyUjF3cggQoTJmVBBSKsg7kX+5jm46H3ei4w4fha/RQ0wI0p5byma7qhKGx+hhCk2sMHHbbfFZTY8jxdr9UaeWKj6TXaSYQ+m2z7/UQi2LPRBjA8AazCi8GzbX3x0vft2zCD6+S2tTXhphaNoGFw7shL0CFEa++vmOAkXYDnc+npNPooUILW2fQNAKpaTjsmCnSA4QNw2eJhEzEDetQRO/ETTd7bZfirvBUZp16tFM5r7epgDG3Ac+Jst4IluS/Dz2q3Aaqg6yyhe0lDKgTmdaidm4zrPoaL7uRLm/RvpDODX2NDTD2jr8QyatsIFI3U59jM1O9KbPEuA3pxtYlqhCGIW7bJ7voqxT5RQcMemGLvng2Yi/iYeNRbxTa4+s/qpltVEQUM1z9+R08C2tASPaIn4oWGvKTYryoFJhEENF0FJcYe4R97vecwnQPQWeKBiiZWjTGXEvqnE/g/P9oc6OKeM6DHznbjyl0E4pUq8F0qQp7ler1WC1wivAt/ZSbEh+imRLZKjblmBH4/xi4lqrcotDmAKhODaEKVBOzLrHC14tImlTVQpgcbN80f/k+X2oJ89VrCoMHN8Mgp6/7CEqxHjEnFaluDVOIaZfIUEMi0LNmlidnnDlGOUWOv7Ux0a5NWpQx1EP4aKakcsFlBGYukROiFmRfOkeMPQRFrLrSqZzhTfX5IvIE/0blePVxpQmBtuiUSQsMYPUrpOkSK1ZKqq/rhQxc3+v2yYEK6nvA1EylLoh3UY8HGP9KapS6rPxlaH+agjAQFWcj/tYLwBiSa6CCRvgtWKPap4Y2+UAL/KejDulv5/BmXVdfvHC7vEV8RTFcoVgiadh3TPr0PKsDmBl4AxsFdz5vUf+zWO4M875AUxMEIgAFlaBYzOfIbQgUkWAFO9KRIuLE4Zw4XDbANuX8EcNu3DFsRQawMj3+nwkkXCLltqKDyfEpQj6vigZS0ZKk+R5FyCJFcvCBEry0Fh+JO2J5iR5+eHhYcV58BzjEX/IBV+4kMgIJmCJibzntrrE86EneeegDaLt1/UWCEPrRM4tDRiNby8ov2cY5IBNjFfQBM/BygXLFo00EpFNoITX96VbMpOEWukfhzQghWGaCFHjgh6Q3wJSQg1mGdYl+qimBQjuJbmxJRYenghuNEiCnIVu0nDQzIRwRQo0Motg2eeyQksCCOqPScTxIxJsC+OnpWnwCW1QwCXIsn2GDevAHjX9IDrDaoMmsi5JC+rvgBWxYVJsLNpmYe+zPJIVZBysTCaPz/Mm/dZgvw9byioCqLixYlDOlqsfQu57bVQscDNSbdDEykghHBAKk+wDullCOoTq2Ps7+9YzHcOGEFukeA4lPtRcFOUDvXGudFjcIZlj6ekDrSt/nllticAC56rhJ5noZyXj0t4n6ibOJuRL4Ksm7ohWJg/W+yHw61oc8gQsSNe6/LUOkWs11CYgMh6ZI+aLGAIUBT4QKMFlmVSRqOb5OXqjINcrpzNQ4WW4hfHRQ7rACmiBip/mD1ABGU+aLZqy+lZeFUChUTLCPJF35CxZP/TANR6acUrGgww7eQN+2gd7B//OGt6yTgEDgpoA7A6EQsGI0fRno7E3IemnIwBpOirvkHDZihsCCKIyuAfx0sXUhF+ASqZRfhv+ePvJtx9WD0KoQAqYLHNjLSHDeRoQ9u8R9HxHE8kDC81IbISsfZWUWJ1E7YSm9qF1agt36Rg64b8vhDmIRkOTHPy60Aw9B3ixJpgJu6jxwtJEZpGOQdBcwUU0cjIri6QYD/DQeCCwAagspm62Dv3/Cgf/afKOvCdPWPYlMMohjbGwKrDJTrOQa4/UoSsEh/184TECy5XkGFHODzEw3dbF4S+66RIAk5mn6LdGmoGPrSByRHRDn9Bgs+AM6GTeWRDRdKHhDqSRzCenNnlbYXZOBXO6BGVJUJkhunK5lcBCqFEi72RA6RWOFa+zj+LfJKAIEU6kPfnQCBU+ipDmh8b5aEIhZOu+sTiwz0oxemCf/TaAIutEQwM8eLJY7D/QpIFS04Cu2VPIK0DZDEAOEQm8KW9xBuMjYSQv0hghO+Wf5cGTpCixerr/AHXL0k6WjunQAAAAAElFTkSuQmCC\",\"imageUrl\":null,\"color\":\"#fff\",\"overlay\":{\"enabled\":true,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Flooding level\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"flood\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"24px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":false,\"displayTimewindow\":true,\"decimals\":0,\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"24px\",\"icon\":null,\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":false},\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "flood", + "flooding" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/flooding_level_progress_bar.json b/application/src/main/data/json/system/widget_types/flooding_level_progress_bar.json new file mode 100644 index 0000000000..b6e1d91994 --- /dev/null +++ b/application/src/main/data/json/system/widget_types/flooding_level_progress_bar.json @@ -0,0 +1,30 @@ +{ + "fqn": "flooding_level_progress_bar", + "name": "Flooding level progress bar", + "deprecated": false, + "image": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAMgAAACgCAMAAAB+IdObAAAAnFBMVEXg4ODf39/g4ODg4OAAAAD////g4OD19fUjTMchISGsrKw9PT3j4+PIyMh0dHSQkJDx8fEvLy+CgoLI0vGenp7k6PhaeNVYWFjy9Pu6urqtvOqRpeM+Ys7V1dUwV8vv7+9KSkqsu+qDmt/X3vS6x+5LbdF1j9yGhoZmZmb39/efseePj4+5ubmpqamXl5dohNkxV8rCwsLj6fjk6fgljp4SAAAABXRSTlPvIL+vAC9A4IoAAARWSURBVHja7M9JEQAwCAPAUI43DvDvsjYCk3WwCHuo7dwChsn1GgbvPGAeKk/AlUgpQkYRNoqwUYSNImwUYaMIG0U+u2WvKjkMQ+HqFEeWfzGYFIaUKfL+z7eRcwMhy+xslaS4H8ygWFKsD2zI2/gVeRu/Im/jHyKrDBSO+IjlfFB8IFLwmUB/h4jjQL6KLFxfLuJ1I30V0Y6Xi+gRYENCmWD4EkT3oKjl1qjosdvjWA5Faz2LWAe2EuuXuHdOD4mkmTkz2GwWOAWEdCT3eYRbAXO3/FaQ3UlkdMxI2w9qf8EW4o0iVUT8LlJs44UCpUuIbLbs0fMhYstWpCZZeRLRPVXRqBBWCBeg0d972dsuMjMBngsKZeSSPVhwiERgYkBlBXAWGR3KZaQWKho7zOjmy27BMRndz+aNOrFcRTyDjX4RCRw0pNyQm/UM4iN3JGdgnPLA9RAJ/ytSZGOyrpVynFnpj4g021PG0YmAZgdlA5CvIlaDdBapLAAU1p+pVj8B6HhExNPVamMkxyIzo7kFWXgRsXyQdhYZKzELkPKQ78xVAvsjIhBHOttXZzLXn6DNVxGoI8NZBNpIlgSrFGx4N15xl8gVVewkTUeAv0nQpJwxuHYA5853f/220n1jxBfeLxK5EfCN94v8YYcOUgCCwgAIr/56iZWUkA3W7n87CsUGy3k13w1moqyKMj5lEPKLIYbkwhAaQ2gMoTGExhAaQ2gMoTGExhAaQ2gMoTGExhAaQ2gMoTGE5iNkqusmHppLGyivIfOYdusjZUmnPlDeQrp0GO7zxwxDNvbroMVBGAjD8Gnwuw+GIYZAownUS5f2//+3TVdddNl1m5MjzXOp0Etfpk7UwTNJt/3NwM1+6UmVnZABSNMMPujbXd0o/g8JAM+fPS0YGEijnRADtJSNwGU9Jpa2JXX2Q+jJrkM6IHrAqft/lYYEzAzpUhpiox9FrAMsqVIYsuB5JLYdu4G46w6/a/ZD5K+QZSfDhQQTO+eEDrQfcpu3VvfbxnUAZc9vQo6Qw5fyC+dIWp0jj5TsZiKcQ83z4kIH2g9hIFDm4GghcwAD5jQh5ICRJEw9g3ftNJ5bS+wAe54QXj/9mukhSxwmgc4TQhwB+CSUjfA9ZffkAfiRzhRCJNzLcik06/nwU+N939nPo4ZoU0O0qSHa1BBtaog2NUSbNwh5GKzFvlGhPCRiyzQqXItD8FOjQ3GIwVZsVCifyD1izei4R65vvLVOpoZoU0M+27t7FIZhGAzDzs/nQEihlCwejEZhjA2+/+XqExS8fXH1nkAPGjSKLYOw9QPScg1gqqlqG4eICirVukoUSeOQeAOBaiX1EmAc8ipskKxZZQbIBZznDJCer+MQ+Ry4I3g6+kCtjEMQNFcwFTRnwTgEKYEs+e/L/qwMwpZB2DIIWwZhyyBsGYQtg7BlELYMwpZB2JoI4jBF3q0TvJ4G3ptb3ATPp6Uz9mXzT8+ty/4FsaeuueShPysAAAAASUVORK5CYII=", + "description": "Displays flooding level reading as a horizontal progress bar. Allows to configure value range, bar colors, and other settings.", + "descriptor": { + "type": "latest", + "sizeX": 3, + "sizeY": 2, + "resources": [], + "templateHtml": "\n", + "templateCss": "", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.progressBarWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.progressBarWidget.onDataUpdated();\n};\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '280px',\n previewHeight: '180px',\n embedTitlePanel: true,\n defaultDataKeysFunction: function() {\n return [{ name: 'flooding', label: 'Flooding level', type: 'timeseries' }];\n }\n };\n};\n\n\nself.onDestroy = function() {\n};\n", + "settingsSchema": "", + "dataKeySettingsSchema": "", + "settingsDirective": "tb-progress-bar-widget-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-progress-bar-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"function\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Flooding level\",\"color\":\"#2196f3\",\"settings\":{},\"_hash\":0.2392660816082064,\"funcBody\":\"var value = prevValue + Math.random() * 2 - 1;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 5) {\\n\\tvalue = 5;\\n}\\nreturn value;\\n\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]}}],\"timewindow\":{\"realtime\":{\"timewindowMs\":60000}},\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"padding\":\"0px\",\"settings\":{\"layout\":\"default\",\"autoScale\":true,\"showValue\":true,\"valueFont\":{\"family\":\"Roboto\",\"size\":24,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\",\"lineHeight\":\"32px\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":1,\"color\":\"#234CC7\"},{\"from\":1,\"to\":3,\"color\":\"#F36900\"},{\"from\":3,\"to\":null,\"color\":\"#D81838\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"tickMin\":0,\"tickMax\":5,\"showTicks\":true,\"ticksFont\":{\"family\":\"Roboto\",\"size\":11,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"ticksColor\":\"rgba(0,0,0,0.54)\",\"background\":{\"type\":\"color\",\"color\":\"#fff\",\"overlay\":{\"enabled\":false,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"barColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\",\"rangeList\":[{\"from\":null,\"to\":1,\"color\":\"#234CC7\"},{\"from\":1,\"to\":3,\"color\":\"#F36900\"},{\"from\":3,\"to\":null,\"color\":\"#D81838\"}]},\"barBackground\":\"rgba(0, 0, 0, 0.04)\"},\"title\":\"Flooding level\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"units\":\"m\",\"decimals\":1,\"useDashboardTimewindow\":true,\"showLegend\":false,\"widgetStyle\":{},\"actions\":{},\"configMode\":\"basic\",\"displayTimewindow\":true,\"margin\":\"0px\",\"borderRadius\":\"0px\",\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"showTitleIcon\":false,\"titleTooltip\":\"\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"titleIcon\":\"flood\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"iconSize\":\"18px\",\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"14px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1\"},\"color\":null},\"titleColor\":\"rgba(0, 0, 0, 0.87)\"}" + }, + "externalId": null, + "tags": [ + "progress", + "weather", + "environment", + "flood", + "flooding" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/flooding_level_progress_bar_with_background.json b/application/src/main/data/json/system/widget_types/flooding_level_progress_bar_with_background.json new file mode 100644 index 0000000000..66351866eb --- /dev/null +++ b/application/src/main/data/json/system/widget_types/flooding_level_progress_bar_with_background.json @@ -0,0 +1,30 @@ +{ + "fqn": "flooding_level_progress_bar_with_background", + "name": "Flooding level progress bar with background", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays flooding level reading as a horizontal progress bar with background. Allows to configure value range, bar colors, and other settings.", + "descriptor": { + "type": "latest", + "sizeX": 3, + "sizeY": 2, + "resources": [], + "templateHtml": "\n", + "templateCss": "", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.progressBarWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.progressBarWidget.onDataUpdated();\n};\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '280px',\n previewHeight: '180px',\n embedTitlePanel: true,\n defaultDataKeysFunction: function() {\n return [{ name: 'flooding', label: 'Flooding level', type: 'timeseries' }];\n }\n };\n};\n\n\nself.onDestroy = function() {\n};\n", + "settingsSchema": "", + "dataKeySettingsSchema": "", + "settingsDirective": "tb-progress-bar-widget-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-progress-bar-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"function\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Flooding level\",\"color\":\"#2196f3\",\"settings\":{},\"_hash\":0.2392660816082064,\"funcBody\":\"var value = prevValue + Math.random() * 2 - 1;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 5) {\\n\\tvalue = 5;\\n}\\nreturn value;\\n\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]}}],\"timewindow\":{\"realtime\":{\"timewindowMs\":60000}},\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"padding\":\"0px\",\"settings\":{\"layout\":\"default\",\"autoScale\":true,\"showValue\":true,\"valueFont\":{\"family\":\"Roboto\",\"size\":24,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\",\"lineHeight\":\"32px\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":1,\"color\":\"#224AC2\"},{\"from\":1,\"to\":3,\"color\":\"#F77410\"},{\"from\":3,\"to\":null,\"color\":\"#DE2343\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"tickMin\":0,\"tickMax\":5,\"showTicks\":true,\"ticksFont\":{\"family\":\"Roboto\",\"size\":11,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"ticksColor\":\"rgba(0,0,0,0.54)\",\"background\":{\"type\":\"image\",\"imageBase64\":\"data:image/png;base64,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\",\"imageUrl\":null,\"color\":\"#fff\",\"overlay\":{\"enabled\":true,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"barColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\",\"rangeList\":[{\"from\":null,\"to\":1,\"color\":\"#224AC2\"},{\"from\":1,\"to\":3,\"color\":\"#F77410\"},{\"from\":3,\"to\":null,\"color\":\"#DE2343\"}]},\"barBackground\":\"rgba(0, 0, 0, 0.04)\"},\"title\":\"Flooding level\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"units\":\"m\",\"decimals\":1,\"useDashboardTimewindow\":true,\"showLegend\":false,\"widgetStyle\":{},\"actions\":{},\"configMode\":\"basic\",\"displayTimewindow\":true,\"margin\":\"0px\",\"borderRadius\":\"0px\",\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"showTitleIcon\":false,\"titleTooltip\":\"\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"titleIcon\":\"flood\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"iconSize\":\"18px\",\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"14px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1\"},\"color\":null},\"titleColor\":\"rgba(0, 0, 0, 0.87)\"}" + }, + "externalId": null, + "tags": [ + "progress", + "weather", + "environment", + "flood", + "flooding" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/horizontal_flooding_level_card.json b/application/src/main/data/json/system/widget_types/horizontal_flooding_level_card.json new file mode 100644 index 0000000000..a37a2032b4 --- /dev/null +++ b/application/src/main/data/json/system/widget_types/horizontal_flooding_level_card.json @@ -0,0 +1,29 @@ +{ + "fqn": "horizontal_flooding_level_card", + "name": "Horizontal flooding level card", + "deprecated": false, + "image": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAMgAAACgCAMAAAB+IdObAAAAn1BMVEUAAADf39/f39/g4ODg4ODf39/////k5OQjTMfg4OCRpePk6fisrKzx8fHIyMg9PT11j9zOzs7y9PuQkJD09PT5+fmtvOqsvOpYWFjI0vHV1dXb29u3t7c+Ys4wV8vCwsK8vLy6x+5aedXn5+dohNlmZmaDmt+enp5aeNUrKyt0dHSfsedMbtGdnZ0/Ys6CgoJLS0vW3fTW3fUxV8pKSkpA7yNPAAAABnRSTlMAIEDfv1C6kOEmAAADcUlEQVR42u3a53KbQBSGYUV2DivKUgQSRTR1F9lOuf9ry9kVUkjGQyyT8WDN91iGBVx4h93xD3kEAAAAAAAAAAAAAAAAAAAAAAAAAAAA8JG+fHo6Y3xjfHaTm6/cYUT06YXGeHQb0hWIbkcTugoThAwMQoYGIUODkKFByNC8FmI9egm12dOpLW1quaep0z40qEV/aX/9Q3IhRD636CzeydSekqNu1+AAx3HpwCM11CddQ503+Ihf3E29BA9m67fXM+0dIVtxtJ6fQ2zDsadGvIlpunGl8bK5I5fce9dWQx0yjV0ZGwfbjn9WPUPmguXnkqXQLg8xxVn+0IRs7iVPrx3F6R3JDQ9c/WFPn3moQ+7s5/vDLjZeprtNvxBLiOS7KZbUeBLveyKJOFvu6yZEqnVyUCHuXyH2KWQhDeclJnehZmG/B+LxthAWHYmcfgusIEhqvvRtlnSHWHkrhKgdYvCD4an1M+XBXROihjrk4G4kxTbZbrzrF+IJNQ/WYk5aIPZktabLWt1grebbY1dI0HQUa978COhPjv7Um4ZRSfd0sbXvFzJvtto38aMQwgvO896crTli9lCIuiNkK/bNSit4n9C/OPZzSp36hxTbbS6W5yeiHpKw1K2aHSHW3BKM+z3ebamv/iEUBETWacmYegEJoYadIexJzUGimV4kvfUPYXrJXBaSLAuhrWvB5gF9uK1e7EuRnP4eWvqwvizkSazVItmrtV54efPTQnpF6Px9IqT/IRFLPZfUjNJd5numVh0QJbOEyJrNeFhbpCx0DL+cjLQoomjiqxMTivh4Za8oyrLjBT7RKykXnvmo1ue8SVKHHl0WQsGsJm6prSboFJKmfialz6OSyqysokXpp6n0K8evIiJ/FVZVRqGvL/iyovez1JzYBipkzYffczXTgwtDtoUQuae/dalWu/U7ZBFKf+UfQ1ZpxmM+t8r8UuqQSZZxiKxWMuTcMqQeAis47luHr+laI/t6novCTDxRbBOzSEix/az0F6ksQ/VE/CorF+FC+nzO4Rv3SYVE6omsKltdSMuSPpgOuVi26riYyozeYBAhUdR1MaS3GETIECFkaBAyNAgZGoQMzWR0ewVvsxOFt6OxcQVvtEfGeDT6ejMxPrub8TX9Uw0AAAAAAAAAAAAAAAAAAAAAAAAAAADAB/kFV7oA4xEmmqQAAAAASUVORK5CYII=", + "description": "Displays a latest flooding level telemetry data in a horizontal layout.", + "descriptor": { + "type": "latest", + "sizeX": 5, + "sizeY": 1, + "resources": [], + "templateHtml": "\n", + "templateCss": "", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueCardWidget.onDataUpdated();\n};\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n horizontal: true,\n previewWidth: '420px',\n previewHeight: '90px',\n embedTitlePanel: true,\n defaultDataKeysFunction: function() {\n return [{ name: 'flooding', label: 'Flooding level', type: 'timeseries' }];\n }\n };\n};\n\nself.onDestroy = function() {\n};\n", + "settingsSchema": "", + "dataKeySettingsSchema": "", + "settingsDirective": "tb-value-card-widget-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"function\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Flooding level\",\"color\":\"#2196f3\",\"settings\":{},\"_hash\":0.2392660816082064,\"funcBody\":\"var value = prevValue + Math.random() * 2 - 1;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 5) {\\n\\tvalue = 5;\\n}\\nreturn value;\\n\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]}}],\"timewindow\":{\"realtime\":{\"timewindowMs\":60000}},\"showTitle\":false,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"padding\":\"0px\",\"settings\":{\"labelPosition\":\"top\",\"layout\":\"horizontal\",\"showLabel\":true,\"labelFont\":{\"family\":\"Roboto\",\"size\":16,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"labelColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showIcon\":true,\"iconSize\":40,\"iconSizeUnit\":\"px\",\"icon\":\"flood\",\"iconColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":1,\"color\":\"#234CC7\"},{\"from\":1,\"to\":3,\"color\":\"#F36900\"},{\"from\":3,\"to\":null,\"color\":\"#D81838\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"valueFont\":{\"size\":36,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\",\"rangeList\":[{\"from\":null,\"to\":1,\"color\":\"#234CC7\"},{\"from\":1,\"to\":3,\"color\":\"#F36900\"},{\"from\":3,\"to\":null,\"color\":\"#D81838\"}]},\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"dateColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"color\",\"color\":\"#fff\",\"overlay\":{\"enabled\":false,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Horizontal flooding level card\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"units\":\"m\",\"decimals\":1,\"useDashboardTimewindow\":true,\"showLegend\":false,\"widgetStyle\":{},\"actions\":{},\"configMode\":\"basic\",\"displayTimewindow\":true,\"margin\":\"0px\",\"borderRadius\":\"0px\",\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"showTitleIcon\":false,\"titleTooltip\":\"\",\"titleFont\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1.6\"},\"titleIcon\":\"\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"iconSize\":\"14px\",\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"14px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1\"},\"color\":null}}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "flood", + "flooding" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/horizontal_flooding_level_card_with_background.json b/application/src/main/data/json/system/widget_types/horizontal_flooding_level_card_with_background.json new file mode 100644 index 0000000000..0dbe99ca95 --- /dev/null +++ b/application/src/main/data/json/system/widget_types/horizontal_flooding_level_card_with_background.json @@ -0,0 +1,29 @@ +{ + "fqn": "horizontal_flooding_level_card_with_background", + "name": "Horizontal flooding level card with background", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays a latest flooding level telemetry data in a horizontal layout with background.", + "descriptor": { + "type": "latest", + "sizeX": 5, + "sizeY": 1, + "resources": [], + "templateHtml": "\n", + "templateCss": "", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueCardWidget.onDataUpdated();\n};\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n horizontal: true,\n previewWidth: '420px',\n previewHeight: '90px',\n embedTitlePanel: true,\n defaultDataKeysFunction: function() {\n return [{ name: 'flooding', label: 'Flooding level', type: 'timeseries' }];\n }\n };\n};\n\nself.onDestroy = function() {\n};\n", + "settingsSchema": "", + "dataKeySettingsSchema": "", + "settingsDirective": "tb-value-card-widget-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"function\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Flooding level\",\"color\":\"#2196f3\",\"settings\":{},\"_hash\":0.2392660816082064,\"funcBody\":\"var value = prevValue + Math.random() * 2 - 1;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 5) {\\n\\tvalue = 5;\\n}\\nreturn value;\\n\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]}}],\"timewindow\":{\"realtime\":{\"timewindowMs\":60000}},\"showTitle\":false,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"padding\":\"0px\",\"settings\":{\"labelPosition\":\"top\",\"layout\":\"horizontal\",\"showLabel\":true,\"labelFont\":{\"family\":\"Roboto\",\"size\":16,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"labelColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showIcon\":true,\"iconSize\":40,\"iconSizeUnit\":\"px\",\"icon\":\"flood\",\"iconColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":1,\"color\":\"#224AC2\"},{\"from\":1,\"to\":3,\"color\":\"#F77410\"},{\"from\":3,\"to\":null,\"color\":\"#DE2343\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"valueFont\":{\"size\":36,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\",\"rangeList\":[{\"from\":null,\"to\":1,\"color\":\"#224AC2\"},{\"from\":1,\"to\":3,\"color\":\"#F77410\"},{\"from\":3,\"to\":null,\"color\":\"#DE2343\"}]},\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"dateColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"image\",\"imageBase64\":\"data:image/png;base64,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\",\"imageUrl\":null,\"color\":\"#fff\",\"overlay\":{\"enabled\":true,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Horizontal flooding level card\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"units\":\"m\",\"decimals\":1,\"useDashboardTimewindow\":true,\"showLegend\":false,\"widgetStyle\":{},\"actions\":{},\"configMode\":\"basic\",\"displayTimewindow\":true,\"margin\":\"0px\",\"borderRadius\":\"0px\",\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"showTitleIcon\":false,\"titleTooltip\":\"\",\"titleFont\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1.6\"},\"titleIcon\":\"\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"iconSize\":\"14px\",\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"14px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1\"},\"color\":null}}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "flood", + "flooding" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/simple_flooding_level_chart_card.json b/application/src/main/data/json/system/widget_types/simple_flooding_level_chart_card.json new file mode 100644 index 0000000000..465fd01ab0 --- /dev/null +++ b/application/src/main/data/json/system/widget_types/simple_flooding_level_chart_card.json @@ -0,0 +1,32 @@ +{ + "fqn": "simple_flooding_level_chart_card", + "name": "Simple flooding level chart card", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays historical flooding level values as a simplified chart. Optionally may display the corresponding latest flooding level value.", + "descriptor": { + "type": "timeseries", + "sizeX": 4.5, + "sizeY": 2, + "resources": [], + "templateHtml": "\n\n", + "templateCss": ".legend {\n font-size: 13px;\n line-height: 10px;\n}\n\n.legend table { \n border-spacing: 0px;\n border-collapse: separate;\n}\n\n.mouse-events .flot-overlay {\n cursor: crosshair; \n}\n\n", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueChartCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueChartCardWidget.onDataUpdated();\n};\n\nself.onLatestDataUpdated = function() {\n self.ctx.$scope.valueChartCardWidget.onLatestDataUpdated();\n}\n\nself.onEditModeChanged = function() {\n self.ctx.$scope.valueChartCardWidget.onEditModeChanged();\n}\n\nself.onDestroy = function() {\n self.ctx.$scope.valueChartCardWidget.onDestroy();\n}\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '300px',\n previewHeight: '150px',\n embedTitlePanel: true,\n hasAdditionalLatestDataKeys: true,\n defaultDataKeysFunction: function() {\n return [\n { name: 'flooding', label: 'Flooding level', type: 'timeseries', color: 'rgba(0, 0, 0, 0.87)'}\n ];\n },\n defaultLatestDataKeysFunction: function(configComponent) {\n return [{ name: 'flooding', label: 'Latest', type: 'timeseries'}];\n }\n };\n}\n", + "settingsSchema": "{}", + "dataKeySettingsSchema": "{}", + "latestDataKeySettingsSchema": "{}", + "settingsDirective": "tb-value-chart-card-widget-settings", + "dataKeySettingsDirective": "", + "latestDataKeySettingsDirective": "", + "hasBasicMode": true, + "basicModeDirective": "tb-value-chart-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Flooding level\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 2 - 1;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 5) {\\n\\tvalue = 5;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 2 - 1;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 5) {\\n\\tvalue = 5;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"layout\":\"left\",\"autoScale\":true,\"showValue\":true,\"valueFont\":{\"family\":\"Roboto\",\"size\":28,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\",\"lineHeight\":\"32px\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":1,\"color\":\"#234CC7\"},{\"from\":1,\"to\":3,\"color\":\"#F36900\"},{\"from\":3,\"to\":null,\"color\":\"#D81838\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"color\",\"color\":\"#fff\",\"overlay\":{\"enabled\":false,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}}},\"title\":\"Flooding level\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":null,\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"flood\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"18px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":true,\"decimals\":1,\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null,\"units\":\"m\",\"displayTimewindow\":true,\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1697382151041,\"endTimeMs\":1697468551041},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"timewindowStyle\":{\"showIcon\":false,\"iconSize\":\"24px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":true}}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "flood", + "flooding" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/simple_flooding_level_chart_card_with_background.json b/application/src/main/data/json/system/widget_types/simple_flooding_level_chart_card_with_background.json new file mode 100644 index 0000000000..6377995405 --- /dev/null +++ b/application/src/main/data/json/system/widget_types/simple_flooding_level_chart_card_with_background.json @@ -0,0 +1,32 @@ +{ + "fqn": "simple_flooding_level_chart_card_with_background", + "name": "Simple flooding level chart card with background", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays historical flooding level values as a simplified chart with background. Optionally may display the corresponding latest flooding level value.", + "descriptor": { + "type": "timeseries", + "sizeX": 4.5, + "sizeY": 2, + "resources": [], + "templateHtml": "\n\n", + "templateCss": ".legend {\n font-size: 13px;\n line-height: 10px;\n}\n\n.legend table { \n border-spacing: 0px;\n border-collapse: separate;\n}\n\n.mouse-events .flot-overlay {\n cursor: crosshair; \n}\n\n", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueChartCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueChartCardWidget.onDataUpdated();\n};\n\nself.onLatestDataUpdated = function() {\n self.ctx.$scope.valueChartCardWidget.onLatestDataUpdated();\n}\n\nself.onEditModeChanged = function() {\n self.ctx.$scope.valueChartCardWidget.onEditModeChanged();\n}\n\nself.onDestroy = function() {\n self.ctx.$scope.valueChartCardWidget.onDestroy();\n}\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '300px',\n previewHeight: '150px',\n embedTitlePanel: true,\n hasAdditionalLatestDataKeys: true,\n defaultDataKeysFunction: function() {\n return [\n { name: 'flooding', label: 'Flooding level', type: 'timeseries', color: 'rgba(0, 0, 0, 0.87)'}\n ];\n },\n defaultLatestDataKeysFunction: function(configComponent) {\n return [{ name: 'flooding', label: 'Latest', type: 'timeseries'}];\n }\n };\n}\n", + "settingsSchema": "{}", + "dataKeySettingsSchema": "{}", + "latestDataKeySettingsSchema": "{}", + "settingsDirective": "tb-value-chart-card-widget-settings", + "dataKeySettingsDirective": "", + "latestDataKeySettingsDirective": "", + "hasBasicMode": true, + "basicModeDirective": "tb-value-chart-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Flooding level\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 2 - 1;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 5) {\\n\\tvalue = 5;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 2 - 1;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 5) {\\n\\tvalue = 5;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"layout\":\"left\",\"autoScale\":true,\"showValue\":true,\"valueFont\":{\"family\":\"Roboto\",\"size\":28,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\",\"lineHeight\":\"32px\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":1,\"color\":\"#224AC2\"},{\"from\":1,\"to\":3,\"color\":\"#F77410\"},{\"from\":3,\"to\":null,\"color\":\"#DE2343\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"image\",\"imageBase64\":\"data:image/png;base64,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\",\"imageUrl\":null,\"color\":\"#fff\",\"overlay\":{\"enabled\":true,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}}},\"title\":\"Flooding level\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":null,\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"flood\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"18px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":true,\"decimals\":1,\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null,\"units\":\"m\",\"displayTimewindow\":true,\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1697382151041,\"endTimeMs\":1697468551041},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"timewindowStyle\":{\"showIcon\":false,\"iconSize\":\"24px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":true}}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "flood", + "flooding" + ] +} \ No newline at end of file From e08c744d4f997221e831f0d3ffa7d9cae2d745c3 Mon Sep 17 00:00:00 2001 From: Igor Kulikov Date: Wed, 25 Oct 2023 17:44:56 +0300 Subject: [PATCH 41/43] UI: Outdoor Environment: Illuminance widgets. --- .../widget_bundles/outdoor_environment.json | 12 ++++++- .../horizontal_illuminance_card.json | 28 +++++++++++++++++ ...ntal_illuminance_card_with_background.json | 28 +++++++++++++++++ .../system/widget_types/illuminance_card.json | 28 +++++++++++++++++ .../illuminance_card_with_background.json | 28 +++++++++++++++++ .../widget_types/illuminance_chart_card.json | 31 +++++++++++++++++++ ...lluminance_chart_card_with_background.json | 31 +++++++++++++++++++ .../illuminance_progress_bar.json | 29 +++++++++++++++++ ...uminance_progress_bar_with_background.json | 29 +++++++++++++++++ .../simple_illuminance_chart_card.json | 31 +++++++++++++++++++ ...lluminance_chart_card_with_background.json | 31 +++++++++++++++++++ 11 files changed, 305 insertions(+), 1 deletion(-) create mode 100644 application/src/main/data/json/system/widget_types/horizontal_illuminance_card.json create mode 100644 application/src/main/data/json/system/widget_types/horizontal_illuminance_card_with_background.json create mode 100644 application/src/main/data/json/system/widget_types/illuminance_card.json create mode 100644 application/src/main/data/json/system/widget_types/illuminance_card_with_background.json create mode 100644 application/src/main/data/json/system/widget_types/illuminance_chart_card.json create mode 100644 application/src/main/data/json/system/widget_types/illuminance_chart_card_with_background.json create mode 100644 application/src/main/data/json/system/widget_types/illuminance_progress_bar.json create mode 100644 application/src/main/data/json/system/widget_types/illuminance_progress_bar_with_background.json create mode 100644 application/src/main/data/json/system/widget_types/simple_illuminance_chart_card.json create mode 100644 application/src/main/data/json/system/widget_types/simple_illuminance_chart_card_with_background.json diff --git a/application/src/main/data/json/system/widget_bundles/outdoor_environment.json b/application/src/main/data/json/system/widget_bundles/outdoor_environment.json index 64f427fd69..1d30ca6b8c 100644 --- a/application/src/main/data/json/system/widget_bundles/outdoor_environment.json +++ b/application/src/main/data/json/system/widget_bundles/outdoor_environment.json @@ -155,6 +155,16 @@ "simple_flooding_level_chart_card", "simple_flooding_level_chart_card_with_background", "flooding_level_progress_bar", - "flooding_level_progress_bar_with_background" + "flooding_level_progress_bar_with_background", + "illuminance_card", + "illuminance_card_with_background", + "horizontal_illuminance_card", + "horizontal_illuminance_card_with_background", + "illuminance_chart_card", + "illuminance_chart_card_with_background", + "simple_illuminance_chart_card", + "simple_illuminance_chart_card_with_background", + "illuminance_progress_bar", + "illuminance_progress_bar_with_background" ] } \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/horizontal_illuminance_card.json b/application/src/main/data/json/system/widget_types/horizontal_illuminance_card.json new file mode 100644 index 0000000000..d07223f469 --- /dev/null +++ b/application/src/main/data/json/system/widget_types/horizontal_illuminance_card.json @@ -0,0 +1,28 @@ +{ + "fqn": "horizontal_illuminance_card", + "name": "Horizontal illuminance card", + "deprecated": false, + "image": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAMgAAACgCAMAAAB+IdObAAAAolBMVEUAAADg4ODf39/g4ODg4ODf39/////g4ODYGDjdNVH1xc2srKzx8fHOzs6QkJDiUmn98fM9PT364ubIyMjz8/P5+fnb29u2trZ0dHTj4+PCwsLnb4K8vLzn5+fwqLTri5vpfY/409pmZmbaJkXV1dXumqjzt8Hu7u7sjJzkYHbU1NRYWFjfQ12dnZ1LS0vgRF0vLy8hISHwqbSCgoLpfZDofY9vEfvyAAAABnRSTlMA7yC/r7BI7FImAAADHklEQVR42u3a53LaUBCGYcDJsmqoC9QLiGJip9//rWUlOWAcTMyECTLzPeD10dEf3jEyzMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM42uhuO37sPI+kYrujd04ejwQedbsDqbjCmmzC8lZAxQnoGIX2DkL5BSN8cD/mp0HtzPCRmem4aapqr0Z4+ob55GWLFlswsJlGX1Jm5k4k20XUKKWwnae2CdF3uckhhd3BRVp1/c6ih1vmSnqisvCkk488WddZsPg+RG9n0ZWZXVdUt3IdtpWmPlU3fq2042douXdCahVLuVs55IZTnZK03n+OSStP6M+QrTbTQpuY208JJNdNmZOs2LcJH7fuMLsdhVsuclWalqGXB5nkhwlG4sSZxOmSbPOxD7Kkb0uVkvJE5Z4cKLoisOVu7EMtp1o7MkyEKd9QXIYvH6sthyMN224bQpHoMH+xKu2iI2YZYZPJSVp+43IU4PHdkKM7JkIyfmPSS/uqG3o0LshSunYJjkhCV2rkLoZxjKavp1ZDaLKjg30g1TbqaksVn62iIVMby+/WQXELifcjyiiHyWDe5wuujITKZHaIznlpXU3PcXiPq0RA58Yn+EmIp3PlG17ThTGYsU34OL/anl5b6jf9+c9rx6Ahv9XLDowuK+YdMhZdU86Z9MaF9iMPzJc+tkyFiyWJDe9M2Ru6rgFq+T/7YaDbG5MtxqqXkB0F3QjYukKQyx7n5+8rOFc6fhWzkqOD4byEli/gwZLEwAtc1ZBVRFESJP42MxcI1kpWR+ERG6iVJQJ7RnjDchP7ZUmFm03l6iswL2odkbZ9cPydDxDLLMucw5P5+6rlGanQh6X0ga9lLAyNy25BxEEiIm6SuJ7mRR//OcqyD1flv41XTLOgZzQgiY7pwI0+SIiMJoqk3dQ3ZW8kDN6gJ8Zu/SJpozYlFFNH/cjrkk1LQCUFKr7t3A7qCJuRsvn/qpEdv0YuQPkJI3yCkbxDSNzcUMqSbMB7c3cTH0/rHwWh4AyX6sPnqw4fxeze8Gw0AAAAAAAAAAAAAAAAAAAAAAAAAAAAA4Fy/AL5F9/papj6AAAAAAElFTkSuQmCC", + "description": "Displays a latest illuminance telemetry data in a horizontal layout.", + "descriptor": { + "type": "latest", + "sizeX": 5, + "sizeY": 1, + "resources": [], + "templateHtml": "\n", + "templateCss": "", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueCardWidget.onDataUpdated();\n};\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n horizontal: true,\n previewWidth: '420px',\n previewHeight: '90px',\n embedTitlePanel: true,\n defaultDataKeysFunction: function() {\n return [{ name: 'illuminance', label: 'Illuminance', type: 'timeseries' }];\n }\n };\n};\n\nself.onDestroy = function() {\n};\n", + "settingsSchema": "", + "dataKeySettingsSchema": "", + "settingsDirective": "tb-value-card-widget-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"function\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Illuminance\",\"color\":\"#2196f3\",\"settings\":{},\"_hash\":0.2392660816082064,\"funcBody\":\"var value = prevValue + Math.random() * 7;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]}}],\"timewindow\":{\"realtime\":{\"timewindowMs\":60000}},\"showTitle\":false,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"padding\":\"0px\",\"settings\":{\"labelPosition\":\"top\",\"layout\":\"horizontal\",\"showLabel\":true,\"labelFont\":{\"family\":\"Roboto\",\"size\":16,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"labelColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showIcon\":true,\"iconSize\":40,\"iconSizeUnit\":\"px\",\"icon\":\"mdi:lightbulb-on\",\"iconColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":1,\"color\":\"rgba(0, 0, 0, 0.76)\"},{\"from\":1,\"to\":5,\"color\":\"#FFA600\"},{\"from\":5,\"to\":20,\"color\":\"#F36900\"},{\"from\":20,\"to\":50,\"color\":\"#F04022\"},{\"from\":50,\"to\":null,\"color\":\"#D81838\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"valueFont\":{\"size\":36,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\",\"rangeList\":[{\"from\":null,\"to\":1,\"color\":\"rgba(0, 0, 0, 0.76)\"},{\"from\":1,\"to\":5,\"color\":\"#FFA600\"},{\"from\":5,\"to\":20,\"color\":\"#F36900\"},{\"from\":20,\"to\":50,\"color\":\"#F04022\"},{\"from\":50,\"to\":null,\"color\":\"#D81838\"}]},\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"dateColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"color\",\"color\":\"#fff\",\"overlay\":{\"enabled\":false,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Horizontal illuminance card\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"units\":\"lx\",\"decimals\":0,\"useDashboardTimewindow\":true,\"showLegend\":false,\"widgetStyle\":{},\"actions\":{},\"configMode\":\"basic\",\"displayTimewindow\":true,\"margin\":\"0px\",\"borderRadius\":\"0px\",\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"showTitleIcon\":false,\"titleTooltip\":\"\",\"titleFont\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1.6\"},\"titleIcon\":\"\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"iconSize\":\"14px\",\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"14px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1\"},\"color\":null}}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "illuminance" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/horizontal_illuminance_card_with_background.json b/application/src/main/data/json/system/widget_types/horizontal_illuminance_card_with_background.json new file mode 100644 index 0000000000..1e70bae331 --- /dev/null +++ b/application/src/main/data/json/system/widget_types/horizontal_illuminance_card_with_background.json @@ -0,0 +1,28 @@ +{ + "fqn": "horizontal_illuminance_card_with_background", + "name": "Horizontal illuminance card with background", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays a latest illuminance telemetry data in a horizontal layout with background.", + "descriptor": { + "type": "latest", + "sizeX": 5, + "sizeY": 1, + "resources": [], + "templateHtml": "\n", + "templateCss": "", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueCardWidget.onDataUpdated();\n};\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n horizontal: true,\n previewWidth: '420px',\n previewHeight: '90px',\n embedTitlePanel: true,\n defaultDataKeysFunction: function() {\n return [{ name: 'illuminance', label: 'Illuminance', type: 'timeseries' }];\n }\n };\n};\n\nself.onDestroy = function() {\n};\n", + "settingsSchema": "", + "dataKeySettingsSchema": "", + "settingsDirective": "tb-value-card-widget-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"function\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Illuminance\",\"color\":\"#2196f3\",\"settings\":{},\"_hash\":0.2392660816082064,\"funcBody\":\"var value = prevValue + Math.random() * 7;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]}}],\"timewindow\":{\"realtime\":{\"timewindowMs\":60000}},\"showTitle\":false,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"padding\":\"0px\",\"settings\":{\"labelPosition\":\"top\",\"layout\":\"horizontal\",\"showLabel\":true,\"labelFont\":{\"family\":\"Roboto\",\"size\":16,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"labelColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showIcon\":true,\"iconSize\":40,\"iconSizeUnit\":\"px\",\"icon\":\"mdi:lightbulb-on\",\"iconColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":1,\"color\":\"rgba(0, 0, 0, 0.76)\"},{\"from\":1,\"to\":5,\"color\":\"#F89E0D\"},{\"from\":5,\"to\":20,\"color\":\"#F77410\"},{\"from\":20,\"to\":50,\"color\":\"#F04022\"},{\"from\":50,\"to\":null,\"color\":\"#DE2343\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"valueFont\":{\"size\":36,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\",\"rangeList\":[{\"from\":null,\"to\":1,\"color\":\"rgba(0, 0, 0, 0.76)\"},{\"from\":1,\"to\":5,\"color\":\"#F89E0D\"},{\"from\":5,\"to\":20,\"color\":\"#F77410\"},{\"from\":20,\"to\":50,\"color\":\"#F04022\"},{\"from\":50,\"to\":null,\"color\":\"#DE2343\"}]},\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"dateColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"image\",\"imageBase64\":\"data:image/png;base64,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\",\"imageUrl\":null,\"color\":\"#fff\",\"overlay\":{\"enabled\":true,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Horizontal illuminance card\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"units\":\"lx\",\"decimals\":0,\"useDashboardTimewindow\":true,\"showLegend\":false,\"widgetStyle\":{},\"actions\":{},\"configMode\":\"basic\",\"displayTimewindow\":true,\"margin\":\"0px\",\"borderRadius\":\"0px\",\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"showTitleIcon\":false,\"titleTooltip\":\"\",\"titleFont\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1.6\"},\"titleIcon\":\"\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"iconSize\":\"14px\",\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"14px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1\"},\"color\":null}}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "illuminance" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/illuminance_card.json b/application/src/main/data/json/system/widget_types/illuminance_card.json new file mode 100644 index 0000000000..f118b2dd61 --- /dev/null +++ b/application/src/main/data/json/system/widget_types/illuminance_card.json @@ -0,0 +1,28 @@ +{ + "fqn": "illuminance_card", + "name": "Illuminance card", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays a latest illuminance telemetry data in a box layout.", + "descriptor": { + "type": "latest", + "sizeX": 3, + "sizeY": 3, + "resources": [], + "templateHtml": "\n", + "templateCss": "", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueCardWidget.onDataUpdated();\n};\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '250px',\n previewHeight: '250px',\n embedTitlePanel: true,\n defaultDataKeysFunction: function() {\n return [{ name: 'illuminance', label: 'Illuminance', type: 'timeseries' }];\n }\n };\n};\n\nself.onDestroy = function() {\n};\n", + "settingsSchema": "", + "dataKeySettingsSchema": "", + "settingsDirective": "tb-value-card-widget-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"function\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Illuminance\",\"color\":\"#2196f3\",\"settings\":{},\"_hash\":0.2392660816082064,\"funcBody\":\"var value = prevValue + Math.random() * 7;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]}}],\"timewindow\":{\"realtime\":{\"timewindowMs\":60000}},\"showTitle\":false,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"padding\":\"0px\",\"settings\":{\"labelPosition\":\"top\",\"layout\":\"square\",\"showLabel\":true,\"labelFont\":{\"family\":\"Roboto\",\"size\":16,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"labelColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showIcon\":true,\"iconSize\":40,\"iconSizeUnit\":\"px\",\"icon\":\"mdi:lightbulb-on\",\"iconColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":1,\"color\":\"rgba(0, 0, 0, 0.76)\"},{\"from\":1,\"to\":5,\"color\":\"#FFA600\"},{\"from\":5,\"to\":20,\"color\":\"#F36900\"},{\"from\":20,\"to\":50,\"color\":\"#F04022\"},{\"from\":50,\"to\":null,\"color\":\"#D81838\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"valueFont\":{\"family\":\"Roboto\",\"size\":52,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\",\"rangeList\":[{\"from\":null,\"to\":1,\"color\":\"rgba(0, 0, 0, 0.76)\"},{\"from\":1,\"to\":5,\"color\":\"#FFA600\"},{\"from\":5,\"to\":20,\"color\":\"#F36900\"},{\"from\":20,\"to\":50,\"color\":\"#F04022\"},{\"from\":50,\"to\":null,\"color\":\"#D81838\"}]},\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"dateColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"color\",\"color\":\"#fff\",\"overlay\":{\"enabled\":false,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Illuminance card\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"units\":\"lx\",\"decimals\":0,\"useDashboardTimewindow\":true,\"showLegend\":false,\"widgetStyle\":{},\"actions\":{},\"configMode\":\"basic\",\"displayTimewindow\":true,\"margin\":\"0px\",\"borderRadius\":\"0px\",\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"showTitleIcon\":false,\"titleTooltip\":\"\",\"titleFont\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1.6\"},\"titleIcon\":\"\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"iconSize\":\"14px\",\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"14px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1\"},\"color\":null}}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "illuminance" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/illuminance_card_with_background.json b/application/src/main/data/json/system/widget_types/illuminance_card_with_background.json new file mode 100644 index 0000000000..7cdf502d79 --- /dev/null +++ b/application/src/main/data/json/system/widget_types/illuminance_card_with_background.json @@ -0,0 +1,28 @@ +{ + "fqn": "illuminance_card_with_background", + "name": "Illuminance card with background", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays a latest illuminance telemetry data in a box layout with background.", + "descriptor": { + "type": "latest", + "sizeX": 3, + "sizeY": 3, + "resources": [], + "templateHtml": "\n", + "templateCss": "", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueCardWidget.onDataUpdated();\n};\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '250px',\n previewHeight: '250px',\n embedTitlePanel: true,\n defaultDataKeysFunction: function() {\n return [{ name: 'illuminance', label: 'Illuminance', type: 'timeseries' }];\n }\n };\n};\n\nself.onDestroy = function() {\n};\n", + "settingsSchema": "", + "dataKeySettingsSchema": "", + "settingsDirective": "tb-value-card-widget-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"function\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Illuminance\",\"color\":\"#2196f3\",\"settings\":{},\"_hash\":0.2392660816082064,\"funcBody\":\"var value = prevValue + Math.random() * 7;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]}}],\"timewindow\":{\"realtime\":{\"timewindowMs\":60000}},\"showTitle\":false,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"padding\":\"0px\",\"settings\":{\"labelPosition\":\"top\",\"layout\":\"square\",\"showLabel\":true,\"labelFont\":{\"family\":\"Roboto\",\"size\":16,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"labelColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showIcon\":true,\"iconSize\":40,\"iconSizeUnit\":\"px\",\"icon\":\"mdi:lightbulb-on\",\"iconColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":1,\"color\":\"rgba(0, 0, 0, 0.76)\"},{\"from\":1,\"to\":5,\"color\":\"#F89E0D\"},{\"from\":5,\"to\":20,\"color\":\"#F77410\"},{\"from\":20,\"to\":50,\"color\":\"#F04022\"},{\"from\":50,\"to\":null,\"color\":\"#DE2343\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"valueFont\":{\"family\":\"Roboto\",\"size\":52,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\",\"rangeList\":[{\"from\":null,\"to\":1,\"color\":\"rgba(0, 0, 0, 0.76)\"},{\"from\":1,\"to\":5,\"color\":\"#F89E0D\"},{\"from\":5,\"to\":20,\"color\":\"#F77410\"},{\"from\":20,\"to\":50,\"color\":\"#F04022\"},{\"from\":50,\"to\":null,\"color\":\"#DE2343\"}]},\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"dateColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"image\",\"imageBase64\":\"data:image/png;base64,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\",\"imageUrl\":null,\"color\":\"#fff\",\"overlay\":{\"enabled\":true,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Illuminance card\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"units\":\"lx\",\"decimals\":0,\"useDashboardTimewindow\":true,\"showLegend\":false,\"widgetStyle\":{},\"actions\":{},\"configMode\":\"basic\",\"displayTimewindow\":true,\"margin\":\"0px\",\"borderRadius\":\"0px\",\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"showTitleIcon\":false,\"titleTooltip\":\"\",\"titleFont\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1.6\"},\"titleIcon\":\"\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"iconSize\":\"14px\",\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"14px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1\"},\"color\":null}}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "illuminance" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/illuminance_chart_card.json b/application/src/main/data/json/system/widget_types/illuminance_chart_card.json new file mode 100644 index 0000000000..1ff8482347 --- /dev/null +++ b/application/src/main/data/json/system/widget_types/illuminance_chart_card.json @@ -0,0 +1,31 @@ +{ + "fqn": "illuminance_chart_card", + "name": "Illuminance chart card", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays a illuminance data as a combination of the latest and aggregated values. Optionally may display the corresponding historical values as a simplified chart.", + "descriptor": { + "type": "timeseries", + "sizeX": 4.5, + "sizeY": 3.5, + "resources": [], + "templateHtml": "\n\n", + "templateCss": ".legend {\n font-size: 13px;\n line-height: 10px;\n}\n\n.legend table { \n border-spacing: 0px;\n border-collapse: separate;\n}\n\n.mouse-events .flot-overlay {\n cursor: crosshair; \n}\n\n", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onDataUpdated();\n};\n\nself.onLatestDataUpdated = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onLatestDataUpdated();\n}\n\nself.onResize = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onResize();\n}\n\nself.onEditModeChanged = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onEditModeChanged();\n}\n\nself.onDestroy = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onDestroy();\n}\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '400px',\n previewHeight: '300px',\n embedTitlePanel: true,\n hasAdditionalLatestDataKeys: true,\n defaultDataKeysFunction: function() {\n return [\n { name: 'illuminance', label: 'Illuminance', type: 'timeseries', color: 'rgba(0, 0, 0, 0.87)', units: 'lx', decimals: 0 }\n ];\n },\n defaultLatestDataKeysFunction: function(configComponent, configData) {\n return configComponent.createDefaultAggregatedValueLatestDataKeys(configData, 'illuminance', 'lx', 0);\n }\n };\n}\n", + "settingsSchema": "{}", + "dataKeySettingsSchema": "{}", + "latestDataKeySettingsSchema": "{}", + "settingsDirective": "tb-aggregated-value-card-widget-settings", + "dataKeySettingsDirective": "", + "latestDataKeySettingsDirective": "tb-aggregated-value-card-key-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-aggregated-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"Main building\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Illuminance\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{\"showLines\":true,\"fillLines\":true,\"showPoints\":false},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 7;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"lx\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"#4caf50\",\"settings\":{\"position\":\"center\",\"font\":{\"size\":52,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"1\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":1,\"color\":\"rgba(0, 0, 0, 0.76)\"},{\"from\":1,\"to\":5,\"color\":\"#FFA600\"},{\"from\":5,\"to\":20,\"color\":\"#F36900\"},{\"from\":20,\"to\":50,\"color\":\"#F04022\"},{\"from\":50,\"to\":null,\"color\":\"#D81838\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.9408410830697858,\"funcBody\":\"var value = prevValue + Math.random() * 7;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"lx\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta percent\",\"color\":\"#f44336\",\"settings\":{\"position\":\"rightTop\",\"font\":{\"size\":14,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"20px\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[{\"from\":null,\"to\":0,\"color\":\"#198038\"},{\"from\":0,\"to\":0,\"color\":\"rgba(0, 0, 0, 0.87)\"},{\"from\":0,\"to\":null,\"color\":\"#D12730\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":true},\"_hash\":0.06392321853157967,\"funcBody\":\"var value = prevValue + Math.random() * 6 - 3;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < -25) {\\n\\tvalue = -25;\\n} else if (value > 25) {\\n\\tvalue = 25;\\n} \\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta absolute\",\"color\":\"#607d8b\",\"settings\":{\"position\":\"rightBottom\",\"font\":{\"size\":11,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.44695098620509865,\"funcBody\":\"var value = prevValue + Math.random() * 4 - 2;\\nif (value < -6) {\\n\\tvalue = -6;\\n} else if (value > 6) {\\n\\tvalue = 6;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"lx\",\"decimals\":1,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1691927717318,\"endTimeMs\":1692014117318},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"stack\":false,\"fontSize\":10,\"fontColor\":\"#545454\",\"showTooltip\":true,\"tooltipIndividual\":false,\"tooltipCumulative\":false,\"hideZeros\":false,\"grid\":{\"verticalLines\":true,\"horizontalLines\":true,\"outlineWidth\":1,\"color\":\"#545454\",\"backgroundColor\":null,\"tickColor\":\"#DDDDDD\"},\"xaxis\":{\"title\":null,\"showLabels\":true,\"color\":\"#545454\"},\"yaxis\":{\"min\":null,\"max\":null,\"title\":null,\"showLabels\":true,\"color\":\"#545454\",\"tickSize\":null,\"tickDecimals\":0,\"ticksFormatter\":\"\"},\"shadowSize\":4,\"smoothLines\":false,\"comparisonEnabled\":false,\"xaxisSecond\":{\"axisPosition\":\"top\",\"title\":null,\"showLabels\":true},\"showLegend\":true,\"legendConfig\":{\"direction\":\"column\",\"position\":\"bottom\",\"sortDataKeys\":false,\"showMin\":false,\"showMax\":false,\"showAvg\":true,\"showTotal\":false,\"showLatest\":false},\"customLegendEnabled\":false,\"showSubtitle\":true,\"subtitle\":\"${entityName}\",\"subtitleFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"subtitleColor\":\"rgba(0, 0, 0, 0.38)\",\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"dateColor\":\"rgba(0, 0, 0, 0.38)\",\"showChart\":true,\"chartColor\":\"rgba(0, 0, 0, 0.87)\",\"background\":{\"type\":\"color\",\"color\":\"#fff\",\"overlay\":{\"enabled\":false,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Illuminance\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"mdi:lightbulb-on\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"24px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":false,\"displayTimewindow\":true,\"decimals\":0,\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"24px\",\"icon\":null,\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":false},\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "illuminance" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/illuminance_chart_card_with_background.json b/application/src/main/data/json/system/widget_types/illuminance_chart_card_with_background.json new file mode 100644 index 0000000000..bac5f3d382 --- /dev/null +++ b/application/src/main/data/json/system/widget_types/illuminance_chart_card_with_background.json @@ -0,0 +1,31 @@ +{ + "fqn": "illuminance_chart_card_with_background", + "name": "Illuminance chart card with background", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays a illuminance data as a combination of the latest and aggregated values with background. Optionally may display the corresponding historical values as a simplified chart.", + "descriptor": { + "type": "timeseries", + "sizeX": 4.5, + "sizeY": 3.5, + "resources": [], + "templateHtml": "\n\n", + "templateCss": ".legend {\n font-size: 13px;\n line-height: 10px;\n}\n\n.legend table { \n border-spacing: 0px;\n border-collapse: separate;\n}\n\n.mouse-events .flot-overlay {\n cursor: crosshair; \n}\n\n", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onDataUpdated();\n};\n\nself.onLatestDataUpdated = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onLatestDataUpdated();\n}\n\nself.onResize = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onResize();\n}\n\nself.onEditModeChanged = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onEditModeChanged();\n}\n\nself.onDestroy = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onDestroy();\n}\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '400px',\n previewHeight: '300px',\n embedTitlePanel: true,\n hasAdditionalLatestDataKeys: true,\n defaultDataKeysFunction: function() {\n return [\n { name: 'illuminance', label: 'Illuminance', type: 'timeseries', color: 'rgba(0, 0, 0, 0.87)', units: 'lx', decimals: 0 }\n ];\n },\n defaultLatestDataKeysFunction: function(configComponent, configData) {\n return configComponent.createDefaultAggregatedValueLatestDataKeys(configData, 'illuminance', 'lx', 0);\n }\n };\n}\n", + "settingsSchema": "{}", + "dataKeySettingsSchema": "{}", + "latestDataKeySettingsSchema": "{}", + "settingsDirective": "tb-aggregated-value-card-widget-settings", + "dataKeySettingsDirective": "", + "latestDataKeySettingsDirective": "tb-aggregated-value-card-key-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-aggregated-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"Main building\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Illuminance\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{\"showLines\":true,\"fillLines\":true,\"showPoints\":false},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 7;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"lx\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"#4caf50\",\"settings\":{\"position\":\"center\",\"font\":{\"size\":52,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"1\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":1,\"color\":\"rgba(0, 0, 0, 0.76)\"},{\"from\":1,\"to\":5,\"color\":\"#F89E0D\"},{\"from\":5,\"to\":20,\"color\":\"#F77410\"},{\"from\":20,\"to\":50,\"color\":\"#F04022\"},{\"from\":50,\"to\":null,\"color\":\"#DE2343\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.9408410830697858,\"funcBody\":\"var value = prevValue + Math.random() * 7;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"lx\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta percent\",\"color\":\"#f44336\",\"settings\":{\"position\":\"rightTop\",\"font\":{\"size\":14,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"20px\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[{\"from\":null,\"to\":0,\"color\":\"#198038\"},{\"from\":0,\"to\":0,\"color\":\"rgba(0, 0, 0, 0.87)\"},{\"from\":0,\"to\":null,\"color\":\"#D12730\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":true},\"_hash\":0.06392321853157967,\"funcBody\":\"var value = prevValue + Math.random() * 6 - 3;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < -25) {\\n\\tvalue = -25;\\n} else if (value > 25) {\\n\\tvalue = 25;\\n} \\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta absolute\",\"color\":\"#607d8b\",\"settings\":{\"position\":\"rightBottom\",\"font\":{\"size\":11,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.44695098620509865,\"funcBody\":\"var value = prevValue + Math.random() * 4 - 2;\\nif (value < -6) {\\n\\tvalue = -6;\\n} else if (value > 6) {\\n\\tvalue = 6;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"lx\",\"decimals\":1,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1691927717318,\"endTimeMs\":1692014117318},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"stack\":false,\"fontSize\":10,\"fontColor\":\"#545454\",\"showTooltip\":true,\"tooltipIndividual\":false,\"tooltipCumulative\":false,\"hideZeros\":false,\"grid\":{\"verticalLines\":true,\"horizontalLines\":true,\"outlineWidth\":1,\"color\":\"#545454\",\"backgroundColor\":null,\"tickColor\":\"#DDDDDD\"},\"xaxis\":{\"title\":null,\"showLabels\":true,\"color\":\"#545454\"},\"yaxis\":{\"min\":null,\"max\":null,\"title\":null,\"showLabels\":true,\"color\":\"#545454\",\"tickSize\":null,\"tickDecimals\":0,\"ticksFormatter\":\"\"},\"shadowSize\":4,\"smoothLines\":false,\"comparisonEnabled\":false,\"xaxisSecond\":{\"axisPosition\":\"top\",\"title\":null,\"showLabels\":true},\"showLegend\":true,\"legendConfig\":{\"direction\":\"column\",\"position\":\"bottom\",\"sortDataKeys\":false,\"showMin\":false,\"showMax\":false,\"showAvg\":true,\"showTotal\":false,\"showLatest\":false},\"customLegendEnabled\":false,\"showSubtitle\":true,\"subtitle\":\"${entityName}\",\"subtitleFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"subtitleColor\":\"rgba(0, 0, 0, 0.38)\",\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"dateColor\":\"rgba(0, 0, 0, 0.38)\",\"showChart\":true,\"chartColor\":\"rgba(0, 0, 0, 0.87)\",\"background\":{\"type\":\"image\",\"imageBase64\":\"data:image/png;base64,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\",\"imageUrl\":null,\"color\":\"#fff\",\"overlay\":{\"enabled\":true,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Illuminance\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"mdi:lightbulb-on\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"24px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":false,\"displayTimewindow\":true,\"decimals\":0,\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"24px\",\"icon\":null,\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":false},\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "illuminance" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/illuminance_progress_bar.json b/application/src/main/data/json/system/widget_types/illuminance_progress_bar.json new file mode 100644 index 0000000000..f90aca3d94 --- /dev/null +++ b/application/src/main/data/json/system/widget_types/illuminance_progress_bar.json @@ -0,0 +1,29 @@ +{ + "fqn": "illuminance_progress_bar", + "name": "Illuminance progress bar", + "deprecated": false, + "image": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAMgAAACgCAMAAAB+IdObAAAAn1BMVEXg4ODf39/g4OAAAADg4ODf39/////YGDjg4OAhISH29vbj4+NYWFiQkJDx8fE9PT2srKzIyMjdNVF0dHS6urriUmkvLy/64ubv7+/wqLT1xc2enp798fOGhobsjJyXl5faJkX309qpqanpfY+CgoLnboLumqjfQ13aJkTV1dVKSkrCwsLzt8Hc3Nx+fn6xsbHx2d3wqbTkYHZmZmbgRF3eeSPoAAAABnRSTlPvIL8Ar7DvmsykAAAEHklEQVR42uzYXWsaQRTGcW3Ckxxm58zIbKchUySltlRv8/2/W8/oipYQt5ALn8j5w67zohc/dBfZxd3yy+Lxs3e/vFssF0/49Kkx7hU30JP9rHATLW4F8ugQshzClkPYcghbDmHLIWw5hC2HsOUQthzC1gXImBVBBmCQgPcqDRxdgAyymoVsZQeOPgjBiuXx3v9CxmiYVdz2YyybgP0JGjMQm8aSYYVWYke3pu2woq2/zwqxtIBT14IUmyBKtiPVKrX0UzjsS01JZAOMte5ERiDVVEUKEJLYVutbYsMzCQHkVW2WFBtpE8SWQ63ATgJWfSX1rSpA2Q+qajJE7thjBJAI5Ol0hABIAktDkDRNOkuMh1x0lAKgJpzHCwmDWBOkf6xv74tyCKeYIUlWinOIHu/OTV5zD6euBhmBzQykG/QcglTV/EPYXzlQnHUlSJOUY52BVIl59w+kyS5HSX1ScksEFzuKSJ37RrZJpCTREwSGl8FetYgNrnD7fZsGzBf03SW1wdv8369D2HMIWw5hyyFsOYQth7DlELYcwpZD2HIIWw5hyyFsOYQth7DlELYcwpZD2HIIWw5hawby4/n5G459txlYuwj5/fJgfZ0o6z57WYOzS5D1w6E/e8mvafYTlF2A/GW/DlYchKEoDO/OARddXAhBCUEpSVy4mJa+/7NNHK0MjEQKQ3tL89PS2lW+xkS1JDu4M2kAtOTNwgqp8/QqQCYyAHA9RwBX0gLotE5JAdKSLXKGBNAzYa6nQGMFyP3PFwrgSIO5REJjBQiE4wR40gP2DjErJA5QVQlihex7MmAHIi1UVYI4z7nx8u6QGxnaKGTch0wDMGjxlHctD8AJR7cLifl30bIZFyCGtMhFsv27a2UIzNmLg47KELfOTASWy+L8mTaI7fVc5guQK5dhBnICwnLUkWGDQEYtE3KwRmS51xL3I5ABnZB2g3gxWpZICYLAtQm5M5c87hDLi1VzbpUgaIU5s47VC8k+YoNIANSs9sMnxMH9PrLQ2qc8s79PFaKtCtFWhWirQrRVIdqqEG19AMQaPr301Rz1OCTxBZnmsIchfElN7lR6PQ4xfEEpj/W/Z8QmPj2zrJHT/N7/0nzwrvVmVYi2KuS7vbtncRiGATDstHcvxSUH4TwIihBkCybJ//9390HmQtrBaqoXvOvBg0Z5KyDeugOpvRUal+sIiJnJNtB+iKhgM03LuiowVgZj1iyL7IdMNyjNv0QUUCEv1BXGYT9kGN1Avv9fKQHxAlGBhfogRJbMbaJpG8RmJmM20Ot+CEV7o20b5Kr2J1j7vvAAhJzxkmwDvfdmf60C4q2AeCsg3gqItwLirYB4KyDeCoi3AuKtgHjrQJDEIbqk0wFOT8PXZ+qSl+s0TyS/jHP3cXn10qk7/wALYyfOKq+pZAAAAABJRU5ErkJggg==", + "description": "Displays illuminance reading as a horizontal progress bar. Allows to configure value range, bar colors, and other settings.", + "descriptor": { + "type": "latest", + "sizeX": 3, + "sizeY": 2, + "resources": [], + "templateHtml": "\n", + "templateCss": "", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.progressBarWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.progressBarWidget.onDataUpdated();\n};\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '280px',\n previewHeight: '180px',\n embedTitlePanel: true,\n defaultDataKeysFunction: function() {\n return [{ name: 'illuminance', label: 'Illuminance', type: 'timeseries' }];\n }\n };\n};\n\n\nself.onDestroy = function() {\n};\n", + "settingsSchema": "", + "dataKeySettingsSchema": "", + "settingsDirective": "tb-progress-bar-widget-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-progress-bar-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"function\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Illuminance\",\"color\":\"#2196f3\",\"settings\":{},\"_hash\":0.2392660816082064,\"funcBody\":\"var value = prevValue + Math.random() * 7;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]}}],\"timewindow\":{\"realtime\":{\"timewindowMs\":60000}},\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"padding\":\"0px\",\"settings\":{\"layout\":\"default\",\"autoScale\":true,\"showValue\":true,\"valueFont\":{\"family\":\"Roboto\",\"size\":24,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\",\"lineHeight\":\"32px\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":1,\"color\":\"rgba(0, 0, 0, 0.76)\"},{\"from\":1,\"to\":5,\"color\":\"#FFA600\"},{\"from\":5,\"to\":20,\"color\":\"#F36900\"},{\"from\":20,\"to\":50,\"color\":\"#F04022\"},{\"from\":50,\"to\":null,\"color\":\"#D81838\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"tickMin\":0,\"tickMax\":100,\"showTicks\":true,\"ticksFont\":{\"family\":\"Roboto\",\"size\":11,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"ticksColor\":\"rgba(0,0,0,0.54)\",\"background\":{\"type\":\"color\",\"color\":\"#fff\",\"overlay\":{\"enabled\":false,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"barColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\",\"rangeList\":[{\"from\":null,\"to\":1,\"color\":\"rgba(0, 0, 0, 0.76)\"},{\"from\":1,\"to\":5,\"color\":\"#FFA600\"},{\"from\":5,\"to\":20,\"color\":\"#F36900\"},{\"from\":20,\"to\":50,\"color\":\"#F04022\"},{\"from\":50,\"to\":null,\"color\":\"#D81838\"}]},\"barBackground\":\"rgba(0, 0, 0, 0.04)\"},\"title\":\"Illuminance\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"units\":\"lx\",\"decimals\":0,\"useDashboardTimewindow\":true,\"showLegend\":false,\"widgetStyle\":{},\"actions\":{},\"configMode\":\"basic\",\"displayTimewindow\":true,\"margin\":\"0px\",\"borderRadius\":\"0px\",\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"showTitleIcon\":false,\"titleTooltip\":\"\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"titleIcon\":\"mdi:lightbulb-on\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"iconSize\":\"18px\",\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"14px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1\"},\"color\":null},\"titleColor\":\"rgba(0, 0, 0, 0.87)\"}" + }, + "externalId": null, + "tags": [ + "progress", + "weather", + "environment", + "illuminance" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/illuminance_progress_bar_with_background.json b/application/src/main/data/json/system/widget_types/illuminance_progress_bar_with_background.json new file mode 100644 index 0000000000..47877fee13 --- /dev/null +++ b/application/src/main/data/json/system/widget_types/illuminance_progress_bar_with_background.json @@ -0,0 +1,29 @@ +{ + "fqn": "illuminance_progress_bar_with_background", + "name": "Illuminance progress bar with background", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays illuminance reading as a horizontal progress bar with background. Allows to configure value range, bar colors, and other settings.", + "descriptor": { + "type": "latest", + "sizeX": 3, + "sizeY": 2, + "resources": [], + "templateHtml": "\n", + "templateCss": "", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.progressBarWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.progressBarWidget.onDataUpdated();\n};\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '280px',\n previewHeight: '180px',\n embedTitlePanel: true,\n defaultDataKeysFunction: function() {\n return [{ name: 'illuminance', label: 'Illuminance', type: 'timeseries' }];\n }\n };\n};\n\n\nself.onDestroy = function() {\n};\n", + "settingsSchema": "", + "dataKeySettingsSchema": "", + "settingsDirective": "tb-progress-bar-widget-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-progress-bar-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"function\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Illuminance\",\"color\":\"#2196f3\",\"settings\":{},\"_hash\":0.2392660816082064,\"funcBody\":\"var value = prevValue + Math.random() * 7;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]}}],\"timewindow\":{\"realtime\":{\"timewindowMs\":60000}},\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"padding\":\"0px\",\"settings\":{\"layout\":\"default\",\"autoScale\":true,\"showValue\":true,\"valueFont\":{\"family\":\"Roboto\",\"size\":24,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\",\"lineHeight\":\"32px\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":1,\"color\":\"rgba(0, 0, 0, 0.76)\"},{\"from\":1,\"to\":5,\"color\":\"#F89E0D\"},{\"from\":5,\"to\":20,\"color\":\"#F77410\"},{\"from\":20,\"to\":50,\"color\":\"#F04022\"},{\"from\":50,\"to\":null,\"color\":\"#DE2343\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"tickMin\":0,\"tickMax\":100,\"showTicks\":true,\"ticksFont\":{\"family\":\"Roboto\",\"size\":11,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"ticksColor\":\"rgba(0,0,0,0.54)\",\"background\":{\"type\":\"image\",\"imageBase64\":\"data:image/png;base64,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\",\"imageUrl\":null,\"color\":\"#fff\",\"overlay\":{\"enabled\":true,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"barColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\",\"rangeList\":[{\"from\":null,\"to\":1,\"color\":\"rgba(0, 0, 0, 0.76)\"},{\"from\":1,\"to\":5,\"color\":\"#F89E0D\"},{\"from\":5,\"to\":20,\"color\":\"#F77410\"},{\"from\":20,\"to\":50,\"color\":\"#F04022\"},{\"from\":50,\"to\":null,\"color\":\"#DE2343\"}]},\"barBackground\":\"rgba(0, 0, 0, 0.04)\"},\"title\":\"Illuminance\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"units\":\"lx\",\"decimals\":0,\"useDashboardTimewindow\":true,\"showLegend\":false,\"widgetStyle\":{},\"actions\":{},\"configMode\":\"basic\",\"displayTimewindow\":true,\"margin\":\"0px\",\"borderRadius\":\"0px\",\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"showTitleIcon\":false,\"titleTooltip\":\"\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"titleIcon\":\"mdi:lightbulb-on\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"iconSize\":\"18px\",\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"14px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1\"},\"color\":null},\"titleColor\":\"rgba(0, 0, 0, 0.87)\"}" + }, + "externalId": null, + "tags": [ + "progress", + "weather", + "environment", + "illuminance" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/simple_illuminance_chart_card.json b/application/src/main/data/json/system/widget_types/simple_illuminance_chart_card.json new file mode 100644 index 0000000000..831ebac2da --- /dev/null +++ b/application/src/main/data/json/system/widget_types/simple_illuminance_chart_card.json @@ -0,0 +1,31 @@ +{ + "fqn": "simple_illuminance_chart_card", + "name": "Simple illuminance chart card", + "deprecated": false, + "image": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAMgAAACgCAMAAAB+IdObAAAAolBMVEUAAADg4ODf39/g4ODg4OD////g4ODYGDghISHj4+NYWFisrKx0dHTx8fHHx8c9PT2QkJAvLy/64ubri5vaJkSfn588PDz98fPdNVH1xc26urqCgoJKSkrV1dXxqbTiUmllZWUXFxfnboLzt8Grq6vumqjpfY/kYHYJCQn309rsjJxDQ0ORkZGBgYHfQ13Q0NDAwMD41NmSkpLgRF1SUlLcNVGnmCfWAAAABXRSTlMA7yC/r1EOHTEAAASiSURBVHja7M9JAcAgDAAwytEf/u0OGdAlDtIAAAAAAAB+p4/I181+HrHX83b0Ngs8zmS0XCVElUiKXEbkNh+7ddMiKQyEcfz0SFWSysshHtQGvQndzQzLfv/PtqXdLLuY6dNgR8Y/gVCUl99B9ITU1gmprRNSWyektn4A5P6JI1WGCIBrXu9nlwiQhXHYNma8vzLk2j+WZPHM0gtIh/dXhjQ36ema5Y4txHug83q8vcBb1umiZ5mgs6LYsu0EEKvbZSxC94BoNBFNv1CAOIPlMmloyQxtEoT4mDxicq2Bp2CSAUIylNHR0AbBpn0gWR0qkRcQvZIDU7dCRghlRI+O2CspEywxXEBwurLYtAMkz59uhcwf4/wKogImu0IcQBEXF8IDYgl9gCY0GKOrTTtApJHbAyLSbCHD15DgxP8HERbqvfeMTTtANCFtupfekT4xhzJE1BL/QvSS0cAMLPFtEDQTTSNKEG4pDWWIKsiQf0KWqeXleTLvgyDN8w3lWPBVwoWJi4y9IE2u4Xv9DZCP628cqR/w93uwTkhtnZDaOiG1dUJq64TUVmUQn2PM/vCQnGgtxENDeCBjGZBupMDHhXBIHZ51beDDQkLif1RtkINC/rBnRjuqwkAAfZpMC6XQboUqChtX1+iDyc3N/f9fuwPEiiwEyBoCCedBRsPDnExnWsFnJ6ghWbRQkdCDF4TiixTxmWy0jBKLFAn30CBih0WIHPydbOsQR6C8BYhUW1/oP5IOY/hBxOR8RORGpBvekqPn88Npz9Kg2grblhGVZC4i3GNMKcYEb3pEjyBMfT9V6tRaNibfIKK3SS2+uvhs7eA2UCoKSCdtnDg4E+6WT0auKYdW9iH/rcjNIGKuy/iaU2wzqPhAHHzmiPnDyIMngfu97xE3Vy8mAQ/Ginwj/qP0TWGiDZrcImZjRSLmstgxHxwpOwyv6WMeBFKoonhCjhHRiMfS4BsAjmjJJ0czViQU4Nh7tUkbjToRh2Ljb8hCldeYRt1wkS/EKxTJ3wESxDPFW8TtU0TrhMKELgP36h2LngsOxtCsxIlUUj5cRNPlgrkzIJ/MiRT1IYVbcVsnXvy6zgQv9VTMYRzN3pDCzcE+kaRcVLrMfVtVBxA/ahUx9E0j3dUJZ6dGxzBPCPWWt3BcxPthzZ4ZtLnBC5QiuiFSfhpNzZNAJ4I1MuapF4ZCwlsIgmEiyQUJk3WKJBYNYtbT6hPRLUJp2mx7pEzbRSo/PPYfy7uZRCSrkj+i6egRoq8gMfQwhQiNK+fzB/EL3BR2IjdENN0tkvYWZBIRamMgzoVIQgPqxz5STiwabd0eEfQwiQgZ3AC0LX0uaEjnL8U1kRwtReTWhtxP5NHf7HdEY7FaVNogWkNxTSQrG8Ri3jrkWbyDaegfv8dCI99Cgc4pvpOHE9H2scWcoUEQlWf36ej/P6KTp5fWMAwZjt+6Z/g0nnssljCMOYtslBre5HMW+RQjmmPOImNYRVaRpbCKzI1VZG6sInNjFZkbq8j/du6EAAAQBGAgfvSPbA3EuwYrsGqEVJMxTgsZq8dyZ/eZIMXc+bqxZgAAAAAAAPzmAmkgqmF9nMW/AAAAAElFTkSuQmCC", + "description": "Displays historical illuminance values as a simplified chart. Optionally may display the corresponding latest illuminance value.", + "descriptor": { + "type": "timeseries", + "sizeX": 4.5, + "sizeY": 2, + "resources": [], + "templateHtml": "\n\n", + "templateCss": ".legend {\n font-size: 13px;\n line-height: 10px;\n}\n\n.legend table { \n border-spacing: 0px;\n border-collapse: separate;\n}\n\n.mouse-events .flot-overlay {\n cursor: crosshair; \n}\n\n", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueChartCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueChartCardWidget.onDataUpdated();\n};\n\nself.onLatestDataUpdated = function() {\n self.ctx.$scope.valueChartCardWidget.onLatestDataUpdated();\n}\n\nself.onEditModeChanged = function() {\n self.ctx.$scope.valueChartCardWidget.onEditModeChanged();\n}\n\nself.onDestroy = function() {\n self.ctx.$scope.valueChartCardWidget.onDestroy();\n}\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '300px',\n previewHeight: '150px',\n embedTitlePanel: true,\n hasAdditionalLatestDataKeys: true,\n defaultDataKeysFunction: function() {\n return [\n { name: 'illuminance', label: 'Illuminance', type: 'timeseries', color: 'rgba(0, 0, 0, 0.87)'}\n ];\n },\n defaultLatestDataKeysFunction: function(configComponent) {\n return [{ name: 'illuminance', label: 'Latest', type: 'timeseries'}];\n }\n };\n}\n", + "settingsSchema": "{}", + "dataKeySettingsSchema": "{}", + "latestDataKeySettingsSchema": "{}", + "settingsDirective": "tb-value-chart-card-widget-settings", + "dataKeySettingsDirective": "", + "latestDataKeySettingsDirective": "", + "hasBasicMode": true, + "basicModeDirective": "tb-value-chart-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Illuminance\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 7;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 7;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"layout\":\"left\",\"autoScale\":true,\"showValue\":true,\"valueFont\":{\"family\":\"Roboto\",\"size\":28,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\",\"lineHeight\":\"32px\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":1,\"color\":\"rgba(0, 0, 0, 0.76)\"},{\"from\":1,\"to\":5,\"color\":\"#FFA600\"},{\"from\":5,\"to\":20,\"color\":\"#F36900\"},{\"from\":20,\"to\":50,\"color\":\"#F04022\"},{\"from\":50,\"to\":null,\"color\":\"#D81838\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"color\",\"color\":\"#fff\",\"overlay\":{\"enabled\":false,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}}},\"title\":\"Illuminance\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":null,\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"mdi:lightbulb-on\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"18px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":true,\"decimals\":0,\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null,\"units\":\"lx\",\"displayTimewindow\":true,\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1697382151041,\"endTimeMs\":1697468551041},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"timewindowStyle\":{\"showIcon\":false,\"iconSize\":\"24px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":true}}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "illuminance" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/simple_illuminance_chart_card_with_background.json b/application/src/main/data/json/system/widget_types/simple_illuminance_chart_card_with_background.json new file mode 100644 index 0000000000..0549e98e77 --- /dev/null +++ b/application/src/main/data/json/system/widget_types/simple_illuminance_chart_card_with_background.json @@ -0,0 +1,31 @@ +{ + "fqn": "simple_illuminance_chart_card_with_background", + "name": "Simple illuminance chart card with background", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays historical illuminance values as a simplified chart with background. Optionally may display the corresponding latest illuminance value.", + "descriptor": { + "type": "timeseries", + "sizeX": 4.5, + "sizeY": 2, + "resources": [], + "templateHtml": "\n\n", + "templateCss": ".legend {\n font-size: 13px;\n line-height: 10px;\n}\n\n.legend table { \n border-spacing: 0px;\n border-collapse: separate;\n}\n\n.mouse-events .flot-overlay {\n cursor: crosshair; \n}\n\n", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueChartCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueChartCardWidget.onDataUpdated();\n};\n\nself.onLatestDataUpdated = function() {\n self.ctx.$scope.valueChartCardWidget.onLatestDataUpdated();\n}\n\nself.onEditModeChanged = function() {\n self.ctx.$scope.valueChartCardWidget.onEditModeChanged();\n}\n\nself.onDestroy = function() {\n self.ctx.$scope.valueChartCardWidget.onDestroy();\n}\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '300px',\n previewHeight: '150px',\n embedTitlePanel: true,\n hasAdditionalLatestDataKeys: true,\n defaultDataKeysFunction: function() {\n return [\n { name: 'illuminance', label: 'Illuminance', type: 'timeseries', color: 'rgba(0, 0, 0, 0.87)'}\n ];\n },\n defaultLatestDataKeysFunction: function(configComponent) {\n return [{ name: 'illuminance', label: 'Latest', type: 'timeseries'}];\n }\n };\n}\n", + "settingsSchema": "{}", + "dataKeySettingsSchema": "{}", + "latestDataKeySettingsSchema": "{}", + "settingsDirective": "tb-value-chart-card-widget-settings", + "dataKeySettingsDirective": "", + "latestDataKeySettingsDirective": "", + "hasBasicMode": true, + "basicModeDirective": "tb-value-chart-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Illuminance\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 7;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 7;\\nif (value < 0) {\\n\\tvalue = 0;\\n} else if (value > 100) {\\n\\tvalue = 0;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"layout\":\"left\",\"autoScale\":true,\"showValue\":true,\"valueFont\":{\"family\":\"Roboto\",\"size\":28,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\",\"lineHeight\":\"32px\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":1,\"color\":\"rgba(0, 0, 0, 0.76)\"},{\"from\":1,\"to\":5,\"color\":\"#F89E0D\"},{\"from\":5,\"to\":20,\"color\":\"#F77410\"},{\"from\":20,\"to\":50,\"color\":\"#F04022\"},{\"from\":50,\"to\":null,\"color\":\"#DE2343\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"image\",\"imageBase64\":\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAQoAAACACAMAAADESdfxAAADAFBMVEX7+/koIh8qIyAlIR8sJCA7LSU5LSUjIyIyKSNJNCZFMiZAMCZuRigtKCQ6KyMmJSQdHiA0KCIvJSEgICFsRysoJCIqJSI4KyQ+LyUvJyImIyEyKiUyJyJvSi5wSisjHx41LCcsJiJDMidwRyiMXTRuSCxMNicvKCQrJyRsRilyTC9ySSkyKygvKid3TSwwKSU2KiNzSyxzSit1SytALiR1TS6UYzc0KiSOXzVXOyhTOSgpJyUxJiE2KyVwSCo9LSSJXDRRNyd8TSpHNChqRSksKCY9LydCMSVoRCmQYDVpRit4Syk3LShZPChPNiaTYTVvSSt5UC9ySyxySChcPihrQyc4KiIbHR9tSS5UOylWOidjQytPOCg6Lyh6TCpHMyV3Ti2fajtmRCqIWjJlQiiRYTeYZjl3Ty9fPygjISBrRit2SilMNCaVZTqAUCxnRSuOYDh8US5hQCmGWTJ9UzBFMCV6TyyDUipiQiqRYDV0SSg3LCaEWDKbZzlqSTBdQCtTOCY2KCJoRy5gQSs/MiltRSeVZDiRYztlRi6lcD+NXTOYZzxaPiqkbT2ibDyPXjSLYDxqSC2YZTeLXjc8KyNcQS5/TympcT+daDpvTDGIXTl0TjGbaTyAVC9MNyliRTBhQy5sSzJIMCVlPihoQiaTZj+fbD2LWzJQOipWNyY+LCOWYjZYQTFhPSeNViqIVCmtdUIgHh1PNCawd0SBVjJjQCZaOSZDLiR3UDJTPi9cPCeqc0JXPitoSjRJNiirc0D8/PuDVjB6UjJnSDGSWSqnbz1eRDJPPC9IOC5DNSyhbj9MMiVfOidkSDOEWjiOYj53SSloPyhMOi7/+e5TNSb+yY60ekZvQymcbENsTDVxTjSHVS3+zZX+1aT++/SWaUGkYiqxaSuqZSudXir+xIaXWyr+3LL+0Jz6nkpzRSr+2az6qVylcUR9VjfPeSz+v324bCr+uXP4kzvYfjD+9OPkhzPAcCr8sWjsjzzIdCv+6cz+79f+47+7cjLcllLCezjHpvWIAABhwElEQVR42jxZa09adxyuFwygkmBUQJkb9QhzF6WTcjmx5VIyOTLAC5KBBkXQUaV0glZxOHFN3WQqmXPqMl0WWWRqWJxtdcFlxiW+mb7QxMwXfoJ+iz3/s8ufi7ZoWh6e2+93br1eVfD6L3lVBVUVVRUyhUTzCYfzoJf3e0+PcTrYnat/WVLy4xNrp+nCGrZ6LzrfC994TeHJ97pqm+53daUt6cvzy/I0TjbddR2+vPCueC9eXZheXeC8uk6nu3Lb28azzUPV8o5eqVTOzCiFohmXQDQjEOhVKpXApV92zcwIZ4QuPf+w9yf3D599+6vBMLj+6M/FI9+fW0dzvvX1R4/U68z6+uAgpTVoo1rGoI7NUswsQ1FqrVrtP4mOfNTXUd4/EQzoPAm73RgyGu37RnL25T1yuZzfy29pEavEHI6gSMQt4t67x5VwpQoul/sJl3tPg/PGG9UKxZu3Hj58/Zeq1x/iVlAhq1RwRSJOcfEDea9x3v3UGbHUtzU8a+g0hcfDYWBhHcbzzcVFuMTbddl1mT43p7vKzebs5f10+tWri2tT+PoiHDaZTK9M1xdd6a7L8+y2cWysV6US6zkCZbNUKVQqgcWyS69fVulVghmX0uUCFEpRsep7mp7+4sO3fo1T6j+P5ubWj47mjo62Hq1/qR6cGsSTepAx+P0Gg1rNLA1o1RQ1oKVisUzmJN7eVndnIhJx6jz7Ro89YaftCQ9tp3XAwc5/wOvlF6uKizkCTpFSJFIKNQBBgoeCq1BU33ujuvqNT/BUWnrrIWjx8JfXXy+oqqqqrORyNUWcBy1yntxot9kmAgFz/f1hQHAT7rzwDltvOsMlprDJW3vhfXV5aU5fmuvS2UuQYqgrnb2+fnUNBHDC1/i+C1AdZLe390NjLTscgWBGpJQKhUqpUinUKwXLy8t6gQBQuEQzQuEMOMLv+Wl6+sMPRw2GqTXf0dHe3OLe0Z9/Plp/9OXsAEDQDhiY2QGKmmUYbUatppKMI5VkBpZOovGNvo6O/n7ntCdhSxiNIfsZmJFI2I20nReSh3p5fD5fVazXFwuKOEUc0T2hRiPRSABGNYGDgPFGdWM1WFHw8GHVw4cPK16vqsqTSWQaDUfZ4u4NuXVuXaS7PHC3ocH0LDw+bv35Ythq9YY3bqwrJlP4Vfh+fdY8FEyfX56fZ88vty1d6evr+xcmr/fVdfgagFwCoezBwdXmFUih1+tFQohDKpUqNWVAQ89xiQQugYtQAneBoKW3x/7bp198O/pH9OO1tePjv46OwYmj9fUt7TpIMaWmHIw2yTAMBTowVEobo5ZiKcMu48+ctI+0DVmCzmCONiaIREKQhs5opG06I88u7+X1tohb9GJxkZ5TJBJBHlAFaIG7orqaiz99UP3GG41gBSAoKHhYlVdQVVBRmo8XxGJ+7/dj39AeW39gomOoYeTJE5M1vOKFSzSYvBvwjHHvs1prkzmds6TTuXPyOEinzy25y1eA4JXp1atX4Ac4AZS298/gFC07eteMslkobBaWlUkACCGDYEYJKPAsFLoEKvED+U9PP/30uxf+jx1rc6tHz/cAxNbW1pdbgwPqR7PMFFCIG/wGBsSIaxmHdpYZXIolGX/yZKPvbt1Q6+MInCJkp2mjHYi4aR2t67G7v+/h8Xljt28XgxUcSFSkLAIWGriFBoyQEGJUVwOJd6oJFGBF1UOIpKAqr6yQK1VygIXc7ZbrdMAikL1fYjJ5L8CL8A2+KRnuNHnDk6YGb1N9Np1tPcils5Hz3EHu4PIye/nqkvXLy2t8Az+9PD+4Mu5vjo2plgUCkXJG2twsbS7Ds1AoUkIbItHyjNIlFAoFyyq+nLY9fe27P158rPXNzR3P/fV8FZ45N+j7XP3xI8OAwzGoZvxLai2VpCgDpdVCJo4laMTvP9l40nGnvDXo1OloIx2yJ3DTGVmzsMvlYAX/dksLX8zRiznvCwQc/NOaZo0GlAAQ5Kaprv6kmvUKeMTrBXgqwKmUSIWaItXtMXmvW6ebDvYHhurNfZPjXqvVNBnOmOCInd6mEWu46zoN/t9J57Ln27nt84Pt3Pnlwfl5+rKLEOLae3l9jddBiu1NHqAYU4EUkIcQOEilzfgCVQggDJYrSpdAz5fLdY8ff9j+wsBMLa4+Pz46Wlg/+nNra3D9y0fUwJJD7VfHklG/n6Io7YA/FltimBQzC1yi0ZG+hjtD/ZEJZ8LmsYcSME6jx7PvoWnabad75Dwe/0GLSozD0Ys4Ivim8p5SCEbAFhWN8IrGNwAFIqT0Vn5pZZ7sYQWgqJAUSoUkQPg8Xs88bZxwBupedrz3xDTsBQY3N96wKWxFOhA3qO1KRyzZgzTe7PZBLrK9fX5+cJAlMXJNbjjpLvLi2f7m5iGQELBIEFIQZgANF1QBIFxKcEKpAg/nJyY+/O5FdGDQN7e3ure3ujg3NweBrK8zs1otaBCLUVSUcRiiS4w25lCnHKklR8wf3TiJjzbUtJonkB82YhVGe8JIwzFstBEK6eHJf+fzb4v1xfoWIAGJFGmUSq4QronmgEAlAnnnjUawQnGrQlaKUoFiUZlfmS9TivBL+Ih+o3W2p5GJOrP52ZOwyTqJLnGxUuv1XlxYS8K1pq4mcySbzgVzBImI7Wp7O51FWlxm05fX5NZFTJOgsw9WqFR6gUsq5JYRTpQVSqUaKcRCkmQGqSIkFaOFR88//uruaFQ74FtbON4jN9/CFtJjUD2rVs9Go0k/Q/n9jAHiQIYySUatjqUYv3/Dv/FktK0etHB6PB6j0ZNI0AmdUedxT+sSPT10jx0BIi4WFwMG2CZ0ek+EJiFlwxSAAAXWLRob371VUZBXUJBfUfF6RUF+KbdMVATX5NMwiu6J1sfmkpdNyA3YxA2KhfdmcnzYOgljLLGUR7Ln2XTk6upsG2c/t311DjiyaWKY4AQUhJcPrvbBibGdGcE/jJAUNkslrERAv2YlwMCZEYhbeD3u7v7XXsT9zMLUwt7z073jrbmtvcE/twa+HHj0tTo2wMSZ2Uw0HqVADa3WwVBayuFwwDU3RkZO7rxX1x/I2TxGOgEg8KxL0DYk4Dw40cMjXiFGhBGB4AiL8K9ypYQOEkUj6ABM4JvVjYpbsvy8yryKqny4haySq+EqBbe//4mncxudHwbLA+UlDbXWt2GZ46ablXFv2GuFhz4bvj8UCHqCaVvu6oAOXW1fne1fgR6wzi5Aga5FqsYlfORqc3Nsc0wlgEKlgKKwsBDPZQBECjCELBIiOAVPTk9PvPXWaJzync4dP3++sHe8cLzw5+yXA+v49NVaEMFviA6AMw5qgHVM7ZJa7UhGTzIbI313aupaJ3I2W8IDeSRodKx5u8fm0Xnm8T2NCGlB2QQUgvcFontF+AAQp+xRAAtuo6Iaj3cU1e/cqiTCqMzLz8srkMkkKFgc/pgc9WQ+MpGzmO+/92zYO74ybIJldpqGx8Odw96mcNd75Zac7enB9Pb+/tnm2eb+2X7ibPsgS9wCBRwxegmtZEEKJOnhsorjIk4BICSFAIIIhYWC1YhIrxrrASk++6g9Tg0Mbh3vPd87Pj5eXIVVfPnoz0dfa9WzWkptoOInUYCijVOOmGGJWlpKxWInJyfxkT5zR72lP2dzghJBYw/brTw6t8djs+lomtfD57W0qG4XC8R6vDfYhUaDXiFhi4VCUtrIZQWCutl4qzKvUCaT5VdU5lfkcRVSkfj2gwe8n+RGpyfXP2SpKRkZWVlZgV2sjJNjmmyaLLnfNZQNRA4ObNueTSMmjM3NM+M+oDjYPs9en0MfKOX/9Kuzs8OdsUMkqVDaXFiYX0ge0rLmMiGgIKEKt+Do+fwe2vlh6x9xg9q3uHj6fG9v7vkczhaq5qz26y/hD5Q6GqUMqBVqZoB4xiATizGZaCYafTJ6t6ajLRCJ2BI2XQKOCcPQGWmnx6bTGd1uWAWPjCB6TrFehKpJzEKDYqEkaYojaYRIuEQnjY2EFYV5hXkkShVlGpGo6LaY/xNtm7c9nYi8bGuo/9FkNY1bO1eQIMQurJO19+suLelI0AZ5AAZ87GOHV5v7+1dXB6ieqJ9pIMHS4mCbvKw6FMwIWV3k4+QVFiJFQAz0LOWMEL1T9YDntnV3fzTqp9SLc8dHz1ePV49OAcWX60jSrz9mtAMfGxiSmxSDKIVnxhyUOulw+KMncZDiSRtad8CZIyDQNjpkTCR0NpvNaJtG0ZDbe8b4iFI0LAFxTpgFxjEp9x4bIAhT4hcK9O5GQFHKLZRJyP8S3MCsphQXP/i+x65zT3dHLJb7XQ0mU+0Kho8b6w1msYvapveuu8qz2RzoZ6T395GVKmCxuRk6uyJ+Qbz0PM2eA1jF1ebYoZ4UyjLCijIWi7wyaRkiFcQgR6mCZ+rmW0fbG7QUKgV8Yo7gMLfg+9M3uDb4Jd67IQqz9DNRA+U3+DMM5o+pVGbXkUmetPf1Panpqw9MOJ05J/TggSxgGB4a4vBM22j0CjKBFItJmkIeoiJU709AC6KPUoVCVloKKHAARuktzB353Pw8IAEo7uGHOcW9qnn7U8/jQGvgTu3bkya0CowdSBGczuGm+npztj8XibhpOyxx7HBnR4USdbaZuNrf30bPOk8TmwAm2/DTQ5VqBwVC2VwIUgCGvPz8QhkpnGykEKcQ98rdTx/3333xgmJ8p8+PV9lWcfTn3OKfa4Mo3RTGjo/j2mTSkTTAPh3JFAzTkYox0Vj05KT97h0kaVtkYsKGXuGBKIwY0+dpFESnbd6tM/bweC1YB9wWwDYxm3KUGtE9djRFkkpKCSlKiTwURCAQTT4kXCHLzwdS78MqWvg/hXroaWdr1lLzdufwcHjlZsV0Mwy3WJnsfK+kMxuw5HQJnf0sxFJCJcD73VRt7m9eHSBXYRigBaBABzWejR0uLxN9lBFKEG8mfgHjBDPYIHXpVTza1v3Za+0b/l3f4urxc+CweryIPcUCprBHWsPHLx4Rs/DHtKNxvzZqSPpRMmOxFJWKonOPbHTcrbHUTExEbDYnmIDMQLUCJPNPQQydzs5Dw4JtFqtACozHYIUSWGi4RB7so5G9wStKbwEhvCCDiPMlGo2yqJj/fYgnt+mmc5HuQE1Tw/Ck1zRpugmvrNyYwieTJU11lqFgMKHThUJjwGB52eVaFuwQjSBR9w+ugAShRPYAUBAkdggSeO+Am1ACD8AC4ywTkoIhaOH30k8/++qt9hNqybdwegyjeD53tLiwuOhz+NQMNjRaP4QRT1IxbZJKxgf9KWrJMbWrTvpHR1+8aC9vq79TM1T30jkB8yJpShuNCR3k+9SjsxF9sHsbZCn6VRFWN1CJkKvRKMAJBSKkFOYJWkAlqFgf4G+5ebK8fEkhF+VcLBDzQVlULKfz8cuG+yhYEAiBwYta0fme+X4u2N/t1AEK+aaAIDGzs7ysWj7cPNzchF0Ai+w5DpwCrQK1AlDNSIEEDnEK4tGF7ChSpgQcAv2YHD1z6G57ancJ6YHx43R1b25hccG35Zt1zM7OIiaS2gxl8CNAmEyKYtRTlNaRymhPTkZG2u+2tXWUl1ucGNEBhc6mQ+020gBlOuJx2jGEwCp4YigEOyzwooiYxb1PCCu4ilIFwpQrkxCrULyDcQzCwR/zZYUKmYKrLFKKb/PkPDeAmOgur7/fVHITxv1mHNRA+bbW3v/Rkgt4chgCMWTtCPA+XTjLO8skSPbRPaGQbJqVB1r32Y5q2SVsbgYRwDoc4hYEi0JUcDKJAHd6+umHdaPRpGP3dO+v56enCwunC8e+qbXFJbXhkdoQZ7RaUCPjp05ACPWuOsZAHfHMyUZ8tK/9bntHXWskMhGEWaBUeQAFtIsdDswC07WRh31eMXFNQAEk8CAKARR4zxIIBE8yUAIKARTYUJSVyWSVOBKJRslBTZV/b/R0B3ORl4ESrxe1apzs89Cxxleswz9asjYnjVmYPzamFyhnXHA/l3BmGVAcnp2dwTivDiCQS5SMK1jFjmpG0Ey2FP/BwBpnPiJECixACj6sIvLaKELBsbAIShzvLcIoFqYW16ZiS9pHaq1hABvNuJqJ+h1UzL+bTDIpR9LBxDdORvvudrTdaWuzlFsCjwNOz4RTR+bRhBFZmkB62NxGbPR+f8B/wCkm+0SUChKmGiVZbspQKWTAAWCwxUJR+uYtqUSjKJS9nl+VX0nKZpG+hc/7Xj5vc0ZaW1E2vZPAwouWBV6sdJY01QcCweC8vVe+yVcJsHhpRgzgLO/s7GxuolwiRa5QO4HIP1Ppsr55BkiQ+Pj3sOUCdgEkUCowknZ/9eFH1IB68XT1+erp8fHCKoJ0anF2nTEwaFSIUDUVx1aTSsWTsaQjg7VNZtYQj/eNtLd3YFNR3v840N9qiwSDQdDCg5Ll9gANsIKmSX48aGGjlM0PEeQh+gTm2AhCcCWlMAsZMoS4JqDQSOEeZciPUvRirlLER6/o1dHzE1/1B2vqa5+hbY9jhxceDo8Ph1/++GOkPzi/H8JCRIXCACRIiSbT5c7OIdyCrVowDAxnxDQPd5YFLiHkQQAo+A8KHNACvypSYXNo6//qo7h/YGnh+BhJenx6uri1uLawtubbnRpE0Y6iWCRTWiaa0VKpFIIjQ2X8qeTGxsZI+50OQom6/vIIWfIGUSlo4psJI+oF0QhmdEwgt4s52OXpCRBko6dBv8IBEKgVKBalMM53GqsBxScIWBmrY1mlVCoSicHZn2jj/HR3f3nXk9rJJ1aM6J2mG8xhw88m77+MBBNI614+H/2tWSlEc8KbEgiW0SphF9DI9j784hydApxAxLiUaFf5BAmcvILXWYWQkQx8EmM1opt//NrduFa9uPD8lMwevtWFtaW1RfXUlMMxS0EdhiQWV8xJjIrtZmAoGcZAwUoNoycjH5lramrAira6ugi2WE6Pk/gEwQJf52m3jqxusK24DVogPohp4oEoJbVCBtOEX4AVpaUAgg1TDaCQVFTI4BVlyqIWfTGPJw/NG51OS435WS0c4oasM4dN2GU1vXw7kHPqjCEej7QWATt5F7LDhEulAisOkaiEF9uY0/CHMVKvEKUID0w4BArc0fL/HcpEyygVzu7Wj17EB6gFMpyjUJyu+nyDg6kp39LSrgN9gtL6tejbDGNIOvyZTGb3xJGhXrwYfdL+0d2+cnN5jbk8YLFYAlh529CujDo6REMogAWfGJsgLcXLYjKDFLHjGBYWGjZNoQ2JrBQ5QkrWO6XvAgpSN/NQsfIqJRqhkiP4Hpsbt8f5dKI/2FQ7bMJYTpwC1z/ebip5Zn5pCSaMod5evWp5xsVOm+RdEYmoUDvZerFJJhKy3z0kO02lUlrItqsCMAJY/JMhpFxIOSpVr9v2+K2OE8OgD+PH6tzq6twa1OGbig3GBpMYQRkMX1pstVMOBpTQphy7qV2K7DNPNtrv9JnLh9raajpePm6zYCDL6ZwkQVAs3EYd2AEPxcKb/4BfrCdY6Iv+2+dp7ilIr4A8iD7I481GPG6RFUYhJvRKHI1IwBHf/v53mp6fdj4eCpS8XWt9dmOyesdNiJLOhvramhxYYTvjqXZaVC5RswQfLz5jKJ8EqoplBqxzE0BAHnAKlwDyYOODhSIfe/W8fxIEGbLc0vu9Ldjf0R73D/pOfcfPV1fJHs+35ltcW9tNLaWoTBLzF5omJAIw/P7YroPBFi/6YqRv9M4dWKa51dJqfs0MTlgmJjwkTLdBjZAO86QOromLY2NjLSqOGFmKRMCFEGy8hWjVxDRl5CgqwQt2GnvzFmb3/MqqCsILrkLDwZqc/xPP5p63TUR+7GwYrp0cxpVBdq3pbbpvMbfmnLjKAH0si7DL/7c6lbESWSZgjOGEQiG2lKsE/3du1ikABhEJaZ1I1zIhp0Uut/W/1rZh8A+enp6CEQsLC2tba1NoFcm15BLjxzSaoXax493NxBwpB+FEJhM/MWB31YB2VVc+VBeoa+03t5YHJoJOG7bcoZBRbjTiCojN2INhPfQACiGLf1K5RaxE7imriWlKAMWbwII1C4gEvUKiKcyvqoRXIEuln3CKsdrE1EzPP9VZzCXoVeO4JIYv6N/DG7VN5pwnmHD38m6rOEpc9wMhwHeIhHQEnH9GM+wzQyhgRB4z+BlJYWEV9PE/GHkEDKSpSH87RDsft5YbDI5Fn291dQqtGz1zYWlpatAx5WB2k1EmGY35Uxi+dlOxZCa2FNuNRrHQPHnSsdH0UU1Na025pbXNXN5v6Z6wPQUUiX07b38fM5lHR7uN9p4eZMjvYrZ1QyBids2rYZFQQBmVb1ZWvln6JkkRfLmFv8UwBjBQvblFotvIYSwE3U+7g9lAbf2zZ9ZazGKdVlxBNj2ptZgDQQwfvfj4lQKyhADzCeMJLWaUmEVwxzKzd4yH+WSHJCnrmUSAeQCBvbOsIL+iBCt+m+5v/yhucCBA9xa2Fnxk9liawmbXMMgk1X4Hk4ylUifaTCqZSe1ihadOJZOZ+Ai2FB015pq7Na24qvuypm6orXXCSQRihzzsdoQHjV2WvIcOwStQNrHMI1WTZQbC9J5Ghs4NSkhKK2UyZCohReUtCT41vB8ypBdyPykqfqDiu912ncc5YXn5pLZz8pkX6/5OlApwo6vrxyFkqR2lQoU1rQw2gPdI3hmZKmZmXLgUCo20YHPFksLlwpzBjucsKYhdvP76v77JhT74PNvEa2+1v9DCHeCXi1t4wDZ9sz71IJZ3GUcKolhK4Tm2NBuDWyxh5x9H4x7p63u7ra2h/E6NeagVQAQsgW40LDQJjKbG3pDR3SO30wBD3oMwRcd6X0xqBaAgWcoOpiwWlaVv4g5aKEjFQvnEarMKQ7oMDatYj33e97R7fj4YeGkpsXZZreHhlWfDVsBxMdxZa4ngcksohKYpUiI+WDtkoSiEDWL9IFjW76h2VC1jMI4dF0wTULA/9Q8l8GAzFdfhJCKOqpee737to1FDyueb8636Vud86inf4tIaclQdZbRMCkzYxY4fFwQHd3fx3W6M8qf8G6O4HtZRD2G0tiJD6obKh1pbnU7nPGgRsvPIysId6rHbe0I98hA6loqd0N8vgqY5ItgmQYIVCAoEDgkQoEEE8jfV5hrTdhmFcZ0DBSrKLGwiVKEULY2V0pUxdVxGHQUc9AbZBkJXCnSATmiF0dGIzqISlFAUMYox2ohKBpHQaYjRYPCLGqNRP+nMdDrNljjn/a6/8wdvby/ggsv6cC7Pec7zbmT/ccEG8uNqfjShsqwSKX777kP+Gp9N29/dAt3cSSPBXdESaYj3Hdu9mEQDKduclcWHxJzBr1nKhWCBVQIi8TzbYqKCRTlBQQ4pkwf5cSVHCQ45l6dt3pL8SvOdbMQCJfX1D0hmTDOD7ad3hOfqR+oHq/MGZ8fH20YHo/Vz9W1z4DMYpmJQKWb6PU5jaWmX2h7XqDU2Z5Gly+l1C8Uarlis66nL76nY3dzMmrC5Jx8VS6IigahQ5lIJChF4oZoZPNJz5JAeAsVGsED/34hyU4i5IrUqieUY69J4n09Tqnch4u3UIngTHTtdrljMvzw8vJj04tayzYUbc5SPeOV6iogwRZakpuEfEUYhnAJVm/RQ8uOAACHAgbq0kG2JW9jBHbm7YCgwOBrGR3D/q4JER3F4bmSuuGSkhOUPO9G5udG5ufrwdH10LhoOR1kPrgQYz4tURSaTvVSn9+jsTqu9xuvrczdBJnp6kip6rq/oaSY56iQ/8lspFmABEIIFIq/sjgFDqqagISfnOrIk5zx+oVenswq5gAkEQa+sakt+czM6kNvvsxq0htqp2z4MvTNQW0s3jagisWPuip6ep6rKHuJzo8OscWmhkBxF089qTKBiiH+iMesuUXRFslF6ByYOpVYohRaBFx/BWNN9lqXyWZTu1/c/gGy1P1xMjpSEoyPtMKsARoLxOY50jjB0fI4ustK7MmPpNRrNNk2XXWM0WRx2jSZb7fc3MYRcj82kZ7FHRL3m/ArCg5Up2n8u2zHWx1IrCg8XQjZBAm6Vk87JyKFW5HBophv45dI+Nly96XISJIX/MSmpgkHPq477WA2GpmpDkZ2uEPJmLBZ/99j24YqkpBcxzBQyWqwXQkmvtWGTiT01ofEhpDPgSAOu9ZmUnwOKFwQNdnGwsrRCGP6zY3cXBNtKRjr2w7DCD5Ah0eIwJbJ6MG+kuB7lrryejgGvGh2Phsejg/VzozDNlX6PoV+v0fs0NV16p52wqPHu8fr7+vbV7asYJi5ahVxAMfJbyY8q2QilSIYkQru3Hd4mg6loV1TMjPSM9Gv4knPxNYTFeXQUeh1Q4ERB+0fwTnpi7/Vknt+m15p3alu6d74TctVqW0KqSEODj5FvWAhcWSNBsfYRlfQHCUWcIiqgF+yLRcgrFCGPxik/BwprGSKFk3SC1rIIymZ3XgzVhGzv3x+d3r8/jDZD+xhlQ4y+P8jeZ3CuDZtRPYCE4dyjKysf9s70F6lVRbbSUp3VaXc6PWrdwUP+O3eLyIvPhieaP1KFvFgf5+bmEhcpDGSHiQs6qTKWwrAyriEoFDAIDOkg8k+9gLDIkVqRsiW3FVSHx9y7+9Rxa/fO0MCHvEVaQvRSvcp21L99saK1iuhHpVvDYp1AQrOgnFAt3DTs/sruKpNNEHMrKEt6/Hvk5zcVbqmqbB67byJ7aaU6GoVkStWcezDKJhSRe7w4j49eUjxKcsC254qjUWoFLYSgQKYwOE1mk1FvV5vtOovRbqFWsD5Gz8unaKLMQnfrmtFt5OApyGUiIy6UVnqYCV2i4mKKRQZAAMY1OXRU8Dhv48YMEuSCC3JgwmkJKVsrm5PqmlEH/f4+q95Qq3XVsintfmenq7ZbFff5h/e9KdoUOt1mugOxIMs/DjsvnhsVJQdnlSiaImco8i61VUmQAzzWYwh+tRXnGy6018oH2YlJPEzDMJEzi1n6zNbPYhmgl0Kx8uZoIUDBa3SWNZCjn/GjSKO36axFJotJ4yRHJrxNB91gQZGgOPD56/LXgXiiNR/WSLEACxrI4R0cyQ+CAhR48C4ZkkGCMDPnMCRRPjZtKkxlj3QHlrTd+/x+N440g2snKERcLS0qrdal0sfxA6JgoU08D5lMTSUPOIicDOx3ZclHBwr+FCgekv6RRsMVkVvIJmetWhBJm9IaE1rzrx+bePS1pcEoIfFgeGQkHO5oLxnvGI3OjRez70G3m2Uejc7Wh/OKp5nYmUAoFb2OGbNZY7KprTbECvqIQ6N2Hqxp8vUp+2MFilayhN7xRCtbwtak/Mrk3JQyEoS4YALZIa4j+iesO53hS6AgKjJIkA0sCklf0iQL6b8MMb619Xq0TXef3RtTtYSYP1B3a6mdEYMN0ezY8CItBGr94h1JdXVvLr45vDhct7jI0EHWgEcaQKRupZVuWS+bYCFppEChPMmPG9M25z6Rv52dcbC8bfzBBx+YHtz/AAmC02xktppQgFeODrZ1zNbnAUFHHnSzPkxQzI4HPTBNk5qgsOnUpiKLTmN3WogLn5+oGKuoIzdaKZyIr0mtgJJUmVyVDBLUipRdiaLnKYIe+w/pIJIiIAEW9FJcN5dLhc8Ubemiix7aWpV8BwyLDu23+qwRHAUhUOh2dYdqDaqG0uXl5X3PDS8uJkk21j131BePx2NxOcvDi0+RNSh7qWWNvDXyvGtTITmz4R8ogIEXtHNDVmFqStJe+oeF+aMY8W56rmM6PBKFTiFoM3EwfABDG+2jnFlkVKwFkO7Z2RmkCrPDpCny2NW6Lp1H7XRq7BbxKvb1HVGa6WIPPaQn6QliAzCSReUVHStFhhBq5uHDJIgyj5EVChLypGpKrchJp6yBBSnPGiQZgoVYvK/PH/fFIw2u/lrjzpCh+51Q9zsGW4M1vnzMD6UbrnhueHnZ1xARXaeltsXlisSOLlNEkK04D/FFqkWalI/1RrPGLHhKCF6UoPjQ7svuLGkb3x9+5MHo4P7pker6YqT9EXaCmChGaSH4dkvaVtrr2/Ki8KxxVufsw4wOs1qjMevVXZoik8dpCbIB0HknvEcwbooVrQcIksnyZPJDfFhiQKoiKBTuvSNhR6IQb9y7dNC/awUthDesJlcLPWARkgVPhFfc0Zq0d7vf7dXV2LSqULdWGwqFtN0hl0rF7982fOyYf9/2YffyciQ2tXryxIkTn3zy6YnV+amQanl5GIU7NXUrvRSrrpgyGUEkKDZQN//bQDBWJLc2vzz2aIHDkTdHUHRMj8C6aaOoEtX0kJLq2XK+a6sfxbuKfXd8kM7SttK2Emzr7Tc7NExhdtKjy9Rl0pk0Hk1XV1ef231kuxuiqUQDiZGc9Iq8VVZW5cKVhG7uIkVkNN2Gu+RqSQ8igsMXXtQK/qUHNgj/o+/tSNiVklTVXJe/j7rZ5fOpug0tPCMGl0tVq1KV+mLLR5eXj+3bfvRYzFq7cPLTE59+8snXX//w89efnlydisSW2RNRRpnUWQzgWIZ7yhwvUK9zLOrmAWDfvDklv3nvkfs6h9h2MYLJnniOmEDaLp6tb8N3RtWsLh8aHyJLWH/MSnIECIneIU+/0WKxq3Qep6ZIY1E7PSZTb4FzT42bU7F9b92blDGiAdvRK7mvJD9Rieig9NKUxM27EqVWiHHzKropdZOHQMFTcoQOkkHICi/IwnyUgC/qlVacTN5Ddp+1tFbiwugKaQ0qvQuCFT/qB4y+ZV9cP3XyxKdff/X9Tz99//1XX/3889cnPp+v1R5L6pHxHMfq80RHY+Omdba5hsTauRKKX1iGleDOiT0FsO48FoThkY4OzDV8/rzBPOrm+Cg9JK8tQESwM6aVVI/SRhG5g6ZeMWma1Da9Rg3t1vcWGT3ObGdNXIZ0dE2cDne0JtM4kHfJDt7ppFU8tshkSjcFjB3CKxg7CItMwSJTKRk3nXd+RsYFmcoy86LCHbBh/pq6imH/9kN+vVZvNtSau8GhQdXQHYlh9Y8fpUwuH20IDZz49M+fvvzyyzNnznz55Tc/ff/tV5+cWJiKDaNpChhsU5URPUshFkorVbCQcsEAkpaakr/3zoMFjkB1tGMaLgEQI4xcxXNzbHzYieZVt1WP5pXzH+XlswGEmyVZh80Eex1Ok6VIY7dbdTqTyWAx9ls6PY5sna6pye3GwAuvUFLkjjuSkxSloio5l6+oN3QQ2QiBRJrYK4RZXCMBsZ4k8E3KpuLDkv7BsFhWVZWUj9PEfcjrs6v03caQywCjaFBFVOChiumpF4wmroWTvwMEOPz4I29raPxw4uRU/Ng+GqtIFtJEaK5KVFCXFSSUHgLrzkosq3x27yHciXhSow+E2Zm3Y5rgwCQC9YPtlMuS0RK6yFBgpW1oNjq+EpgJzNBHTR4LmaE2W3VqI1XT7OknUCxGiIW3qY+VELZNJrA7kjnkRa5SJXLhmyBBWOzaRQdhTMd8RTvNoVZKSMghV24472qlrJHQl1++Y1tCQm5Va37PsNtNB7GWqlrMRoMhog01uGIql6oh5ovp49ZYg7n25O9ExI/nzn722Wdnz54Djy+/+eb7rz45OeXz41QTRbyRsMgqZEJD4FaqJkCsvZ2/Ma0sJf/Z3e49jmB5/UjHdLS9o76+unqwOG98ZLC6nq0Hj3YMzCyNUXo5WFUdvTPBGU+nxuJU2w/FrXq7x2OGYQDFTK/a09V00N+ElwC6SUi0KlAIDluBITd3ay6adxnTGHFxeG0IuU5oxTWCRGamBMcNGRkkCEEBFWZTxDDGvgoOX8eS6ZDXilxhoE4wqnfHYg2RmKpBb9M2uJjQVn//8syP5z46fvz06dPHj38gaChYfP25FhcjiobIeWCRhv4ptQIs/skQ7hekleUm41nN7hwqyRuZjnZE2/PCeaMydUWZw+fKi8vbh5C72Y0NjbfNzgwFgqwFPZZejcdiR/C322xdxiKN0dxv7PQYPTPBTtbpTWN+t6zGoFgUip6qqjtQHau2pGytqhQrFgtk9oXUzW2sQa5iZ3odpeKaTFIjM/OS9PRLGM3OS0/fcD61ArUiq3ALK2eiAhPo7r5lvV6lZfAwGEI00u5Sg6FB36CKxbq1RaGBT788c+6D06dOgYPAcfyLD86eEyx++HrehfkIa7e4CZ6/kWYqDG7DWtmEWPAG1yxMSa7ce8TbOTNEo2yvxzFR3d4h9txo8XhJfXH7SPVgOUExhMmmPDAzNLREkTDRNzxFrD7gVFZSxG4yYO7uDZotHktntu7gnpoj7uv3VcCvcKiTIZIc9A3qBIXiHqJi1y5mEPQ8iQo2H6Jb0UAIirUcAQpwUFjFppystESMnrTi5uuH3f6uPpvV3N8PoajlFYo1WFUqXvDOqZaFb8+c++LUqePHv+AIGoDx2RnqxVc/fDJ19Gg8fux9aaqNijNPnDYAwVnvHxuBAtPqoQm0bj442h39o6SkPDrSNospUzaDXIVpv5XdqDhMVoJA4bBoNE6N2WnVq016p05jUplMRpPH3Gsy9/dqTLrsmiavG+8VHJjpVCqmsG2g4DCJiYol7XQzhBPJ4gqMvDQQIRZAocwhl6TfcB6yTXr6+TmERVYhSg8zCHtCjIjePp/eAL0yGAxavYGSGbGpfHEVZKu79sSXP35xChw+4hz/gm+IjI+UsPj5h9WQCq/78iIZwowGsyDixAupcApemRsu2rw1t7L5zrsnOoMrg8X109AJDLqEARvz6o72Djyr1e23ExAjaHrlgaWgpTPYaULdrjHZIFQaGLfawgBidjKpU0ZN4r3pwu9+BMW7gnmsp5WaiUVxa0oVicHyWGg3h6A4DBQ7dlx30cUYKhS9AijkyFyGb5PdXc5Gyvq2xELwE9t//u6+g4d8NFMEvZZuldFgjtBDtPGnraEWbHoDf5756PRxgPjgIzl8I1h88CNh8e3PX6MJTzUcfT/peeh3WmOWbM/+CYtLJSqyNqdgWj0y0WlZaSuJYuTHhNc2NCk+drpnx6xcjpIN+uRQSVs716GWOnstpk6jjktqah25YVJiw2TSGD39nZ7e3gD9NFvj9W8fq9i3WFfxJgyL4YMGAhYphEaZaLwpicI316Z0Id5AQXqsIXFA3m+44bw13xxl/vK0wtRUuBnz3BhV069XGaAUWnPIEPG59Hp9jNWxvrZ2auG2gT8+EyQ++OADXnLA4vSp058plfPn+akFsIjvexPqzYaZDKFXQ2klKIRrwl9yn2geu/PuAkdedTQMhZCOMTl5u1z/ub2c70vCt7aX3B6YHGpbok50Ont7dfgGujQ19q4apg+mc7W6xmJiKqNsBo1GTEhenZed6XAFblJFz0xpFYqJBYubUjKUggcUCzDQbq4CCJ5AoWCxHhfMIOlsQdBuNpEfhanIgK3wiuax3X6bT6/v79a6DA0RlRZWoReCZXBNTc3Pf34GINaR+IzDd8TFqY+AgrA4ObWwMNUSPzoM4WSXKMQbOqvQiktfeAGqScdOzn+5qcYRnB2PPhhFteTTlxQTBuJd5vv2vJLbO24vDwTKAyAR1HQ6Wf1k+6xqfY1aU6NjRLfaLRpZHxuhGtSRTkt2dtORIyLdILaI4r+VPkpMCAzEBPmBuLmLUYyQuGIb/nZWQNCKNRgulOcll1xyXroU+ExoRVaWuI+AtK4Ztum3Wa1mbP8tQBHRahtiDfEGrXZn7cLA/OqJs6eUYBAgFCgAg7g4fUaB4pPVhYWdtS7tWxWsyrK4JcWYLuI/CpZUzYwsWdaPHdlTEFiqHuHGJC8xJPK5KZ3UTBoHMTF5e3n50tJQ0KEOQqmsJidr4i6brUYYt92oMfWa7Op+i8XomHEwmqJj+cfce3fvvZ7+l6RMplWw7QQBAgiEVChWd+kfV1wlrEKpFBRN7sJceOEBpZ+ex75UogI2jIjAaMBp3s1CKE5OaLsNjGIGg0vF9jSGkMN1uvkP5z/56AuhViBxFhzWKwZh8aMCxderAwN449+JP8eYKouQdWV8vVTkXJ66Fap5xBIsYeoKt4fDVIbJocBkOW7VvMk8/MtAAjL8wVAwOOOQoqhjXY6hRK1jMufdriYrHCL8wyqMvY5ejebgIXophpvFfHgRtQLhJYWDNY9rTwylioaVuG3H4auuglWABVGxnh4HLsw8cEkmUHCVECQQeTddlNhYVclMBxTb3b4am14FFKGIiyZK0Yy59JGWloGF+YUP/zz9wbmzZ89+BhaCgRzeFSi+//bnHz5f4AxMvXOs5/ky7BVMZOsJAtvM3LgRQ/0rzXvvtnTmUSOnHxwvHmEO5wmnWnq7bXKpnDNEjIDD0GuvvVaQnd3l61LbeHBnyWaya/SWLiOpoTZanA5P0YyHsOjMPoingEss17MeFMFCbpbKhTERKRJ27SoDD4wm0IpbWI5h08Sxeo0QrAOZFx64kIuE8CzKptygw1PAYJrKaMAlbFlEu70+tR6q6TJrQ4wgiu4f0e7cCRQDA3+ePnvu3LmzHx2HZJ2CYMmBXpwWKL76QaCYn18YcDU8d0cjYbFJ6Obfgt6GDVlpKUmvvHznxGvBQBhTSXikulziAjza7x0KLE0SDUNLgeASVWKpoDPbaSrwer1Y8Kx6q8/nZTnoMRmdXDfuJWl0jl6UHIvTlK2eYBwbw3vU05oPw6qqhGhuyeXjNybgzFvLDqR/RnQZQTjXXb7eQLhke+GFF17CN5IgIvKyUN/G9riKoEA2d/uR/m3IvCSHGSxUKsCITNXKh1z98Pfj534898HxU7/9opzfflMQOX3qHyjmVz8f4KrZ8pvcMBa+CRhXKnHB1MctpORnX757IlheEt1PVFSPsPnJu/3WvLZ2ysTk0lAgIIblYDDo3ENIdOkmDnq7eED57Gq72omQ59RoTDKhWuDijhV+MntP9qG7/W48FbIIkQm9krCgd8jc8VAigaGQCtrHNojFVdwixKDIBAa7OnAhSABHJmUTJEiRdLkBwZ3gKpDgUsJef43KrrcaY5GQyiC7oJjWpY0NTIEECfL7Z+eg3b/98ut3a+fXX4EDPCAWAsXqwuer/NjUO0ePYdBLU8SbNb1CptLCXclP7H15T8FQeZStOW6Kdkb0W4vby28N3A4Igdc6g3SN1xwvPZadnV1QU9NV49PpdN6uIp/VZjdr0KyKPCa7yeJxGIOmfpOjcwkrq87iPtS3nQSpqxBNE1ue2Co4siaVIqEEBnGx7fBVAgVHeEUm6cERLC65JPM8xQmTKXeltlFwod2t+c0V7rEam01vKC2NQDhdWj1DKdPHwsCAhP78pz+e/eiUAPHe+gGMX4mOs2e+hFd8Pb968vOTq/MDUw1vPfUQ9lUlQ4CC+eOCy7MSt7zS/OyTexwlI+04S555EEAev5X7xYzp7YG2obeDnQWdj+2xFLz0WEH2xJ6JCW+NtyaOBc9Kd8d9byzqL9KY7bTSTo3D6RDcHE6aKXqFXLlF8m+tA4xkqmZuAoRiy2Zm8x2Jm2/ZvGMX6QGtOHzFDqJCFsZSMsHiMl6XSFRcIBePz88Ai6xUbP8imI/tpYP0AUV3qSqkbQhFQEIVqZ36UIAAjxNnSI5fAeJ/5+P3fj11Fix+QPA8eeLz1dWBd5Zb2RYChkh69A+RunFOVz778H2POtpGOh584JFn3uBe6eNcoZxsv31ycqbc8ZqjgLQg4icmDk54Dx5s8tpslE0fy2KbXaMyl5YKFHoP0dFrcjiCvcGgBZn34ETTEXeFQCHCphIWshDjcHdOMRMkJu46fHPiVTdzMUYu2F5xLco/+QEWl/EADKKCk/EXYeca1XQdxvFuWMayOq2wyzjmHLb/dLWtqVkug4G0WY0tamtIQMgK0oXRIuVSIB5IsLMuIIGExVlUR6Sg5ASHivANvalT+qKLR0Cskx0vxy5advk8/3G6Zz8m2IuOna/P832+zzVC3Hnn8S8k3jucwg4dK6aFxG+jJtnkrNOUdNXVaXwfMugtogIwxo8c/BGj+AOEfWe8G3/7ftzz1eFxKfxOTvY8un7HLa8m3DULDxH/kAYISpMlC65UtC2fd2usoaUh1tCwJdaQH2uPxZ55iJBaVqZgDa3hqL826AqXA0YBcltbyORTcbLdataYHclas82qzbLlJXvLvHmICrtSagiTl97GnCakiYcIEvRJb2bxGpq4DprAKhDdfDZwoIGduXhaygK6YMGDOM89Q+qOyE45YjBr9ty5QMrg5/3lhR6T0eqw2Rz6LmudvotKVm4z/gEj7hz95YAYxbd/xyEOxk8HTlD1HR/fP/Whe8cbM9mWYm5ToIApGOEgkqYEXmi1z3ussqmFNfxBWRxk45qDHWuWP/N8WX+bLuryh4O1wWBBuauQZihmUVjY5XF6nA6cw2y02swOq9kKZ1K0kXJeVkhxactrgo23sW18r7SBHkmTwVWYAnWlxg/ysIQNGYLDqjlzlhFMiabICvEPHOSSS1BZRJAzJYAw6j6fdCxhBXCm5NxDDSuz0GI0ma0ED58tE2GRrQcJgaLns5+PHPji1I9AITjs+zMOZ8jb98WJk99/f3T/6M71xlcemUWv8Exe3Ciuong6/NzQ9rb+oqJYSx84NPT2MbjaxFYQSDzTH9K1tfqj9ajo8tpwcN26da5y5qyKjYUamaWwOfLMZnzD6JFWKYWc/qy8kawsJRT2h2trG1NYpcQq1GwsjYsVs5moUBfGLsYcVJpYtWHDSnhzzhzq3cRSoqgAwS/s4sIzrqDKK7Q5nzYhZUBkRY7MmdzvzDTabKRjdXofCov5NHcqQEztHJ385fNjB4Q1/2wRZwADH36BxecQxvjEZM/O7Md3qXPNcdaUSHoXojvQ6R+oWJQf293LmhhnKtTH1nXRM/0jAwNtwWiwmsUvpsFYxHCFCzKdOCu5ocNkSSYrhzjNZgfTNqjMshDyigFnxR6tDVc3Ll1KqxSqEDBgzbnnEzSkgoeDSFtsMd+AYtpBKOxK/AAHsYpLQEVok6EbqWIlJbC+NDwz5YallDaLjUaH1Wa1mkRx6zV6t6Y5ThWjuz9Ha3556icViGkY/vo+/gHNOTG5s3nHKywJkZHhITz6b0kJN6/o7qzSjczLb9jC5RJWjfe+M9jLgQboc80z/f0jIzo/wrGWpgYdbKwinLmDQqbDarU5BAiHhxJOnsNSTNN4W1bIEiKG2Ik06G5WYbrxjvOlKzZM3V+K3ORg6mLQdJ1izow5iwGCcxXzr5UAQjAFB3kYBbpCmvyXnnP1VeclMSjGYmVKTuM95dik1mGyuR0aE0ULclNNdvPOzx7tQWHtPXjg2JE9p779+Ix/xUHej5KVTe7U73jrg10yuakqLEpl57HQOxwgPe9nu7Z3sPedwb2sSO3te6dpd8tgO5XMshElWlN7J6nVbbKnxOiPM3NdF3ZgMmssNquNYQKr2ZtncOblier2hEJZ2IUi/1J1Y2Pglu6UmUisuTTG5mIWhA+y0QS4MmnZqg0zNizGJlZeuRJRQQoCFBcKUUw/POSMK4Q1Gc9aLHNYTFLSPJYBb5EVPodVo/FhnHV1Pj372CAxOjX6y8EDR47tOfWxyhL/BgQusue7k3BFcxc1TqCIewjy6rzrmMobqm0re3jTFg6XDO7t7dvLwzR6e/O3Fj1UUTbQqkJRfWc5fLXuznVvv9lltBpNRqm8OwxZVHUNkp178pweBGeeTgGIkFfR1QSBgpUHBGIanTHq3BxqoLAbl1YSS1dSqFjM1xy587PgWrgCq/gDClwEq4DULiN+QBWzzh9OGWavkjaI16n12HDQbKtJL9LCaWrGQ0ZHe6ZUKL78Ee/4DyDELL46fHT/ztzsN2fueiLeIJNRgquSElakdVd3ojSLto6xbt2yFyj6+vpYQ2+J5a9+qKy/VaHwUE5pjgEo1l0yyTwcGqvearMZrWaK/WbswgBhlFrModLSEbvCptCAYtDVTlsFaWkKA7zDaXPV3seMBKFLmIKKJr1SfEMeVjE/XfJSlTT/zBUULERsXpdE75geWweLiffDFTZTRKNZ32VSjQLibHY3wxWjU4eA4sjX32IU/w0FbDE+2VOS/coHWMVNkqNLKzIpie5MoLpqpOKORfl9u1taevsG4QrBo1c20B+uGFBqwuWN9LluY6Nx3TqnsxggHCarPmLCOyIOixmdWZzHRoyBFSEMIgQWdiUUdQlXLGXwqiONWsXcmdL9SFRTj4TFwCCkKeXdDRsEDFV2p192418cRKBAc5119VmXk8rPTrwXiRUINDLUnGlx4KB6jcZUZ/WRqK9f7y7pIZiOjgoUB07tI1qAxH+9PcePTow2d93zwa5ZF08PWNApRdfnkJT2z3uaTbE+No057iNAQBe9TUVFyytCoWhBOSxx251vst8sp6j0Do2NdiU8QWuM8lVBsgMctF6XPQscQvbQiH1A0fmDtdU3BJamdMwEhPOH7xXaPF+Ku+Ib0OUyuQJG+iGHbcRBFuIgyIrfrUKUxSVnnC2Vx0tlmXBGUuKKYSr/Af5CCsqdyVZ8g47ph1SxWJUimrJ+3EMs/frzA5//tO80SPC+FKvw6Xe8eP0TcdrEKJjfXdGRU93JoM3TW95paNrd29e3V3ykFzBatm5dVFEx4tfVNlI4YrRqnZOTEclOm8lndZgJn/gIxSuxh2QaASGLJ4v+h90+ohgUuy4MV1TfHliakzZzGIGVxnSJnDKZoXaByDykDUTRZqWYBB9o89r0ay5EYl3y+4M2SVTpIF9Lx5T/UsRm99Ic6ZgaoIqIzaRx+Hx6GoWmEiZ6hSymJn/5Ys+BL7/FKk4HxRfHx7GK7LdevP46oBC0mQpNSEzr7m5sHeH0AnP+vSzCTDMnbNGQv+bWZypC9ui62tvK6cKgJTLxDFPE57OabBEiSDJA8MvgYdyI+lWpQBEqU3CPEZCor4U2WXkAAx5gzE0kfsyW1BzfkBrFYomj5xE/2K+9ciERRKAQLC56Pc4WHI7DKIhziy9Oulm2CZdyBQootB6zVUNaatL4UFnZbACU5DYTREZ7fqV49cXH+0DiNO/zuINgFVehu6XizWGwxDTKV/WKfclrsvnB6jmXjkACq+hlR2p1//IyXbH//nVBwiiuocm0GelAmdymXJsNWcXYqtdCaS9Z0YbyLNJHRlzpFF1bKKqrqekkRR+ivkClQihzWE5h4SGqVayU63BS3hWWWIBN0BvDKmBNkACKiy7i++/BFN29bEYisiIFWUEoK0/2mk0iNommJeQgYLGeuV4pd0/8sGfP1/8HxZHjR1Vhcfuzs266nPYYLePrZhNJA51VSv+Sonw57IOaaOoVmkBY9BYVbaL7E/KG1xFECyhY0Zuzmtxuq81E5lGKxrF4zRYa6MnEC4tFkboN5asBu6JTWuGKF+CKxjRIE5OQzhhQSAqStIr2oFQoBIb5oigAQ9UV6RJBVIUFEry42iQZm794cVIG/ZOOmTndcvEn05CspTkmFd5spDcDBQhOOVZAPvbLkSMHgeJ07+NDjFuM5ma/de+rNNPVoR66kMirofr6gXnLK/MFByFOyAL/4J+aKmFNapQFwaCITAcK0wZvW3NT3dZUDb4KU5i12mSLFrvwF3stobJSJYRzKG26AR0Kq3ooJ8C0ETewGKkADzELHGSV2gMCA54AARILrl2w8NqF6ddcdiEVLIGCLx5QnI3UuPoCdEXSirlpKQFYs7G63GXwWCgMaKya9VTyqOchLkpUKKjc0DCFK073fvpKxnBSX6IvdDEFb3Wom52CjkB1q7+/Ykklm+ctW1k9F3sADxawY5T1oIpi19v3FzJon4nMLbHm2hh5wz3omcOacISXAw0GzEHxiE1IkYec3q8L1xNBhrpzOlIgTHIPvgQKsFhF3YbTNmISc+RexwLUFViwSilFrHP/5CAqV1D4pVzBnAkjN/cSQIYaa8tdmcy/ORxmd7bVockGDYpZPmbeUZxTk78eOvbT6aE4eIL5gp7c7E923SULAhjFVc/efH5Hd2N91UjZQ5VNINHCZ8s7XLYR4mzYumj1kiUcHjCUhwuDdGs1DrMNjlibGsnVi9C0IbjJRp12/op0tNSJoll2uGKEaleoPlpVUzv0XHcO7qGOHaUlChJgEecKGVq9lid3KvgGEFjFwmtuvGLaQaaxIIKwIUS5YgN7Y2kEO8Rmddjl8cr4gjXXpC8pcegxCT1lLDcVb5EWk4cPHdx3Oiz2HTv+/eTozg8/+oTa5uWwJkZx81x8r7MmPLB8dVHl7t7dW5rYfGgabIEpON8xVrRkXkWFvdRlCEoBzVZC8IrklkTMpT4bRZNiB3WKAq8nmfjhxXeVLLQVfKELtQ3oWnWt0ReC1d2B4Q5CBxAIEJgFSGQkrspAZWIVcltTPc/AqrG6YZt+2aUXkqP/AQW0icRCbLI2RuFmGIU1VO0Kuui5oG2sazmKhXP4kJ3Z6zUluXRMR4mnE8ePndZDTp04PD6105399huvzrqYAAJpEp6YgQxGldDDRVt2D1LWbIItWoioewf3trSMta+5r39bSOuiPlFgLGau32SCJ3AOfS5pqURSj9aleHU4icWuo5ypy8IklLY2zMLvr+qsfm6ouyMNsxDHEKbgJ09tiKldINUe4Evcgx/4B1aBWQhTxLFAYsEUl1PuxpLOZwW2IyXQWK91MQsp4VxvhScEjWwaZF0ad65ax9o/Nf7dF6eB4ttDhNKp3Lo3P9n16k2iKlgKmDX7kZR7GoPMdC/hnCaLlLu3skZJUrYXB+nNL9rcvrw/y27WZhbItI/NYXWnStOes5ZEMUckj018i9MOQXhdhmQqFIqdSh6FHkVp9bfW13c+Vx3ozhmO20Iia0FAslFmmVfNkQrFYiwhDsYCfrdw4cL0dIJpnDbBQR5QcGtTVkzVyuYwxIZVYBSImQiDJrJ7bWJU19hVp4ErUFmpUrSYnPj+BPnYfyHxw3dHJ3p6Urt2fHC9bAcIUzwxe/bMpdUF/pGRZ1Yvamp6B87kMAPnGRr6gKKPq4F0QexZeQZ6P5lED3eEP2wtcJCgM1EhGrNYduYM9I0VpAVZWFaZThdVFH9bNFrT2Vk9xBLhMBFE7uUBBA//SAALGURTMzDQuHrhlQv4ge6+Jv2aG3GQP0PBvU1ZtbwcrZmBeg/IMmGwXGuxl0VKEf9mslP2CoU0TXpfCQH1UZFZ+8cPH/ov5vz22HcnKWE1d735ygezZKGQlBR5tSKnulrrKlvyJGPMLbIQtIn1qFhMvTHayyXe1RUV75XmZVLRLXaabHIFmDia6o6g9LRMonnpixW6ktlAVxSDF5KANpVi4mjU3xqN1tcOVQfgio40ZphRFACBtgALCabxvAO2lGFmRAWsuRCFdQ3Nc5CYhgJHkbnNS2HNZctorA13dHcHGoPBsIt7Uwy/wd2MpLlNRlizRHqncqhYiHP//qOHD/27Xfz0A+W8/SjNrjc/wSiukh1WRqYTkW73++0Pz3sK12ipzG967bX8rbGxGKm61HpjWMW8h7l8pn3T5TRbbe4I9wDMuVQRS63aZA8tdFdYqzN4iz06BKY2pCMTQ1GITbSiNaVcMRTonjYKVV+lSfwgmEqVmzg6/3L4QXqlMrvKVzpcIVAIFnfH0YArCKZS+sfF0tJyAkO1ndUuLz0oc8Skj8AT60vqNA6nT/NmNgpcNk6p4OzfP/Hz8a8O/hOLfQfphIyPTz2aWvc2WSmDJjL9x/rH7A4WjV0jGMVWTj6xbH1rTJAYa4hRzuqTgvdDD28LeSxeSrpWUy4HIlK3lSCvsEpncbHL4io2wJmuPAUTUYAgqhugEBpt8yM1/TW1nSAxTIYOV9AfTFAD6dyMjI2rVuEgkn1cO1/duCaKzkdTpEMWQCFcIRbxOxQMtM6/fAYBJI28NIBV1Orsyfa8vDyJpIwm1vl80ios1GTriSRc9aCYxXD39ydPHPtx37t/EZmnfjhxnGJ3D1Wbrrde3EULJC6vmFboCNRG7fe9/Fhl5ZbdW5htn1dJ0ZtD3WNUs74Za9/M/ZJ+AkOyUWs0R9hjdMMVtshawofXo3N6wswVaA0ui6KQjrWFBgiiA5hFFUhgFPUvwBUdHdO0KQMmG6FNHnU80lHRmBfgGKx9iKIQfZWejlGIWcRxuFugeECVFcTeGUCRFuge4jZTpscMaeaWQpsy+k8wFWHBB/3dnEuXbEqwGD95/MSxr6XcizXs+/jbU3sOnWB0E554NLUr+5MPrmchRNb38Y+biR+BIP7x9KJ84uhuWujtRbGiypbYIJd4v8mPbd7M7FH/NqtZSxJIO5CzrxwGkIhutRmLDckAgZwoVryGYp3O3hbyKwpQ6HStrVX+qtaaGqDAQTrUQp6MU6AuNuIn4iAb5jBGAGnGz1RgGECC7AYK0RV/gYJgSl4qjTTyUjq7rGC7tFrIImK2YRamkvVUep2m7K7MbI2RBQB1sqBnUh36P3n8uxMMszLNOz3oTRClWZqq2bHjll3XT2/asRLERtpQY71SxlGSrQirpvynWa1dtGZzrL2hfWwMq9i8adMz9/WXlq61Yga5ZnaeOccVoZFvNJB0OOkfhxGZXgMW4qFVgncoUWU7QNTwquqr6jsFieHhFdAE1d3EjRnylZFBXZcqxYIrF8haEEaBb8iHWHqBWIUqNwEiDoUMZF3ARSzxkBU5OaK6wy4LQJSWbjObSxjmFZHlzKYtVGdiBgksCCJU9ibGAePnn78/efjw8ePH+XZSmh9TPc1uH5u5tz+469l4JD3rpgRmvPA7Fim5+YTGhC42FQkSmyu3xMbaY4Nj32xuX71myTYmVc1ldL9SEbYs79kcNqo3mR6XV+sqKHZpdTpOPylICpFWA/wmCk1sr6mvquqsfa5boJAtsY0ggT0kAASd45XLVkKbcMUCOAIoAAGlKcx5440STUECKFTiFOENVssyZghrdnQPBThEG022RPJYLyCa2ihkMaOn1wAGIit7OqBKt3xq/yRgTEwcPUozbHwcz6ALlJpaxwTr228wwvrEEyCBf1w8KyHlQS416gaW39eEUZB75JOTb4rhIlvzx8bG2sc2j615SOaxSlk3t5nXfihMwZ9PQmim3IxdGLQuvklCRgChuzygo8vcWrO96tP67VXYRG1cbM7diFEIAhsTM2CKDBxk1UoMAyguYAX/snSVJeSDwkr/3SrA4m6BAt6cfwEFYfW0SweXYYMGu8VstWyzIW+YxDIbnfTToYkuukMojPV6NYggwEfxkkmCycQEgOyneb4zN1VfyKId87TsG1LrVs/mSU7KSTSlrV+mS3bDFPn5i7auZoygfU3+ovaxWMNYfjuN9OWr3wOKSOlat/w/FkxrrbY4TzgNYYDwG7R2RQsK+IYfnoA4W1ujrdu3f1rTKWoTo+iANNM2MrXLmKaKRwYBJA4FHgJbin9gGRI/hCxuFCSmoZiOIJciu5fNIINBVwRuqA6Hky15pRGgMMNgJrejS+9wdjk1Qhb8nqqWlHBQ4CSpADI1CQpTPaOMKOo1hYVvc0ybkybskKlFTSa6OQLN7d2atrJ5T1e+Q2IOZ8aeZv8Dw9gUq9wUa2jnnP1mFuWWv/deWWTbWh4ZaQmc6bzfkKl1oTL5KjAYdF7F7vXb/dRq2nTA4W/d/v72F2qq3n+/thOrUM1CMEiC96YfoRQkaH9Q45bxxHT5AAQB5M9y8+5prkBtUhnHuZBYIrvrDS5vFgvwCAuSQnOJm7K3z1hYp8l0+Iz6LrfGx3gaDVSxDD6CBjM2nEqqy97Bjh0rCGyhsm9LpUKGY1kJmkliYygru/Ux7sG1DObnb9m0edGa1XwVibRoFyzWgAwHRt8rhaLgTF9JxGryFANEJhyhDWuLkQ9+yEGSUeyhjEJFa6sCYW7fHnz//frnnhtCHqpQAAbpKDbBT3BZOU2cF9AblGW5hRek3yiqGzSmefP3CELhRhLT39o61+fWxiiMm3E7iNuIS8ekjkuQltJ0WpQTh0ZVHUbrMiGKk+mFsGUrqm4pSXWH7ZJMJ0hSTTJOTI0aZtRIaJhpZk5Pa5qYfjBpfOg/0P4PfmvvLQxWstMexwd5rPWs533ftdY7cugSgYJc6h9M2B8ggTz1lPiFzc0wRY5lSCLHPA9LYj3G3h4LJaotGGJA5Qn2zSt0Kb/DdIv7pAPV7KCjx9QY18D21RVn3H9LZIIh3YjMTzgsHd8cV5QxXVfoRtePLuj65sJRZW5OZdYR7WH4xNTzzzKfgkw64KdCkYITpCarDZ+jLciDwsoU94vhVFsk4gtHcpV8LJkDisWlnyEL1uUkjv7Z00BC3kdG8Irrjtxw3V3ICsJDfAIksGv/wRXkkAskmXItyKGLT+2/hF3Y1UdnZgYHfbT0Tr0w5SGdkkC6PKzFvA+T8I+5KHxvt71Dyz5dlVwD8PG9DGn9+NknfiM0IIn7rv6VuUeU5Rkj5SQ+qCMw+sSiiaE3vnr1009kYf7p+JvCFD3jqjKHY0hO1RcU3od7rmJOh4TH8+1dYOGxe6ftoVAoEHA6gsEQlTigABIJh6EoMplwKlWBNLHk8qPiFH2iMFl49PMDyhQcxGRMN7qKDAIGkAQ+IVg0A0SwEF0hjYXX3HRopH8Wsnh0JhqLBNgz4yyug91FOT32kEi9AwO2Y7ZRD/Wb3gcfpGGf+2HIJE+wC07hro2s8aXcw/DkD5fQJcUlMEa5JlAw1OKRu+9+fNU/8dmL730lEyQZDfchDYTykts+9IUv3tTH9U0dVK6S7g9J4ndOPdjlYmqJnf5qv59qrFAwiNSOOCYc+EbR15aBKTJECLoiFsvmcrlkEtYECWSmwHDqyAhICGfyPnidCIvriQxB4iKAOBc4BIl/JFOBQrbzWI29jsL6uW8JhUXWsw+jK8hrre2y697l8XpdAzYXgHhcD7NYv/fB136jIfmJB+/lSOCdh68cGPh+8se3mCgiVz4YnUGoTLM7iNH555xxJnNcMiuMyfuQbTzUJt21Y4fHx1RF1SlsXhjXlYX5BWV+oYcpxKxPIYuOFwgP2bt4Gp9IJGDOgN0nsQFdUp/EKszX1oiQRgEiloxlkyZrojHxiVm4Em8wkOiX8Dhy3Q3Xs59JWFx70a0XiluYPkEGkQBpQnEyEqvlGqpSZjd+BonVmag/QVn9VIdsMne2e1xP2N7psqG8B7zs9npt1N9wdPgsTQF4wx/P2pgONPrjj7TF3y9zw26nD52qbqAwetFpjqJSQQ4/1lZehCk+YOvug3FlXDhyrGfuKgU8lKOKIgpLU1X1Zm7DmWKWDRVGtJIGpkcn/dFBvyPkTECag22DLEuLvmIx4iN5pCJgkQ9ns0mwWE4aCeQsAkQWo7IKGxk5jfgwqYKl+fUirIDCggHXAArcwooPEwpuUzp0k8RX388/wxW5mWjrxEQnp09kEbfH9Zr7mNvm8di87bZj3oErr7SxIrny2QfbOUj9/JjXyxUiX98nAwKoGUVLEBkMraA1iBdQQBUCxYyj+7OeN/GK3989es/RufGbX72Z4sSeubExdWx8jgSiq5pCz9RVNNYytaS1q1VUZijgn54OYf5gBCwynAdCEhlHphgON/L5ME5RySIpsFUzl25ssOwgKMT6+SnZg+orAuR6yMJgCvEG0wCjCYWYJNOzBQrWcqxyV1dXQ4kECveFiamppx7o6vZwkO2hrsBl83o8Lg+kyeKMoyIgoS7neypjfpykOQctcTf6Uto/DJOGGCOTcvPK449O+yZWPmL2lQwXPfrFnP7m2Huqqh+d67mqh1yCAGcxoivKAuTBBDBkVtfwMHk0NOn3+ylXfHraEYj4SCEJH1uZ+EUqkwqL5Su5SjZbSeZWk6XS4iIJZENIc0Te+ISpr3hwCzZ2gcIAQB7zbXmFhYUECFgcONTfDxbk0lwuQjgOvdD5FFtGT3XZPJybuqXDEq5of+dZ0ki7izYRt9ftGbB9//XA94xgoqPxTC45MPqjcAmZj8bhvExGaqHqjy3/FMNFWZy/KxdHERxcGDU/d9X42BwaE/bU67q+ILn1zbGrhC0+62BPNxCYDkwO+gkQ4EjgGomUrMNAJAUgqMxYoxLLZrdyZFLhitJS3/aGLMv7X58FBQkOjM/r5MwYrrhLaNOCgeDgJU5heQVYSAZhRtYBhPessTBNJnP+kG+im2bGqS5PO6cRbg9vjpFZhlCb5T7W3s7nlWxpUS72/fdP/8iAB+pnhSeMlgcMJOBM7OSWA6eeCb4hlObcBxSf/fThuzo8OXczjYQKIaKqC6hvRRO2+ELpUWX+rIyFaw1SqUjfT4BRlxIeDsznS8hJWIoUmsnjEbFwJVzO5rZyW9nk8dVSSZLpLNYvRHHkdSM8hDMt3kRYAETTLSyzaNPkitPhCiLktEPkUnR3cnUmEglNDL3ANGRqA9s9o552CiZdx9xSgOOx2ahfnDLUj+0B7+jk95MMz+5Fad99O6PLyR4SGYZXAATH5yhNKip8a29c9enRX36iKJFI6JlTSB4q7WH64fkxRYUodExbYKVO09jKS58N250BLOQPTQci/miCyIjhqpBmuK2RL4IBVFEJZ7Hjya3k8eNJQWL7hCBhRgUlJdAEbyEK4kP2a1BWuIJl/PJPhSU5BIklZHEp+qx/Ee2aTGYlQF56ofsl6KK1yznsdrPF5mIH3uWCHujSp8Gw3dbl9fKH0ac/BwuaO5nxAhRMUMMn4ExzOgHxIRM7emOZNUqOwIE7o/ABfaznZi4TmyeFHlbUw5qm67z5C8T42GGaaz/rpkHQJwOpAwE/9bzGRlWCTx8s0WjkG6lwqpIvZ3GHJJLi+PLyckm44sTG7MYsLnEQKCg/AweCA1xAwrCL7rpQvj+Paf9UWGaACBRHBIq+xdKjyZlkLMQm6lDHUMfU1NQwRb00QxAjA25X1wAN+y5vO7WLuAXYMPt0dJohyXSBM6dOpqO1sC7HJzg6N6CgefDnXsqYV96YO8oC9NtvP2DBofSgNMfu0cfxgXlV09S4otUlRHq0Hrrp3uC8cDgYmh6Uit5pfyQQSkUSqVi+jdyBtkqRQcUn8tmK4RTHsWSytFTa/vmKDciCzHEQz7BiQ5gCpzgoSJiy6p9A/L2hZ0FBm/4NB4U2+1Cbq8lczOdgZ/OlCcYjTFFj73LTLuQW1enhNN11pRQWg42LUhDv5CjNOeYgEWZZMozUHB5I04N4xYWn3HTO3dQoJIpvzCuM5/59b5MlubJJwwP3XIDDvKbzUtV5raAgvRVNo9Cb83RiIcSlg4JFxJ+IsdTgWJRtmgZqosEWRTm/k89ulbMVoQleyyXcYn1xY6MfKGYFAXlwCgMGfEKgMJblJgLywvhhcYUlvJ9BY13z+ghh1rddWkpyJVzC5xgiPLqGnK1sXLg8Xll5jKK90d9kUM52yaSeAZd34MengYKZSE9y49yp1rpD0qgYPc0tUnIUjaWKIEF0cN7BnR+aptAjR50/eGhjWgG/KNR0rQBx6kCh0oU/0W33S1GqPxqa9odCEV8kEUv5wvlUBp8gQpATW1viFWXxi2VURWl9e/sETgEUuAPPpQKGICEn50TIXbyuBwoDAYsy/rFGx4Q2GRd2A+Ksf/ZE31IJuZlwZDh66iRAnqJslMZnt43c2YHSJEL48E51tbKhg5sM2CmRYTwyUxKeZJAjFxC2nGIiYbb80/xBcWLYsfKiQk37T+xhfoHYVgkGsujYiypfXElrBa0W39Xr9Touwj+i7doxZCd9RkGCx8/pF6wZduTDRWIjk29UKuVyeasMFMkdqILwgCzAAiis0BAQRnhYe1jRIVjcZa3A8AYzOsRMKHigTSObXipe8fPSEmSBrkggDkVZPMVCYKjd1emmvgAdQSaFMVmWuJlg0OH2QpsDk9OPMZaVqfc/SC49cJs128YsZD4AVSzlHGsrY+oXm5ucje4tEAf4wjyOwUskppae1/CLQn1XU+oK4nvlpRXE1GDIj1PMxKZRWXAmKjscjoTzhlV2GgRHeQssSKNGdIDECWwDqWnlDQwsoEwiRJDgLVgYADQ//ukVQIFXXHPpkUMjnByI2CQyWQXTevPZU9RGdrqHqZ61e9BT7i4y6b1eIOng6RrosDO12B6aiT72+HNnsF1zu9yddAot3QKFOT7xAPEx48+sVVWFE4+fvv1J3yRTaLoCO6gaFIlXzPOzABSILKSWqlarb7zBKsMRCcxEZ8ABl4AlWG6IrGo08AtExY7pFvBENrm8nFxeX18vAcTGhpFJTa7EN4zQkEewwC3M1ai8mswpJ4RNiSWFWNccHJmFNpcWS6xtIokMVbIvTHR2wp4PtDOurnPANtDqNtsx6FBHiruNx26X+77Q3cyMYNQig0YJEIHBGBV3+Sk3MTJwJrY2cVjVoYpN4mNhTNOJDpiyelitquCxYGSQXb2g7xZ0TUur1LwPkThDUcIjF52O+f1hyDMShjArjTBAwJllYiR7HFuGKnAJEwpjX/eIRRLm28TBChCAsNyiGR5NiWVAcToBcumlR0Y2+ja2uWY2GQsLbU68MNHNub00X9hJInTzeT3yG8VyuEUrqXTK7XQ5g9NPM62NCTN3k0zxitta8AnBQuKjhaIKUd37VU1f2Pz2p729OrSpKkRHNa0JcRIQuIdYvVbX6joeMp9e2S8WfY4YASIphJVyzM9GFSCgtBvEx06Z4NjinRUkSoaqWDaYAjOXYCAADhYQOIaBBWYA0cymFhS4hBkgl51MArnm0BEW6ScMqohFUrKrXOwedji7KZOklZFiJJcg4fQgsnAHureEPtz2IMl0htuMZEzCqefIFFZzpiRQMMeFluszVnOxl1YOK5t7X+z9tEfxMsSgjhEUVahCfle0+fS8XtC0XWEMvQB1VNf2M+zVRaO5XDQaZT8bnsAXUoQGzrCzs0NsZEkhxMaqAcP68vp2iQRiyAqMLCoGUYCCkISBhLl1ZSHAZzOX/u0VJ0sGOYjE2mA5llzOxcLUbxSHMpRy8Ka4gaEZrXxrb5BOPrcbEORxSYPGqF1SSLSXcbhcDilLkJYWkZrmLGJmltMnNhPOrKVhzb3fv93bVDbRUppAAAB8pgWIuKbFC2pht74LeaparbpSpJImHJMSdn8O4R2JwZl4RQy+3Ak3yuUKWbSMsuINZxqkuV6CN5tOYWFhcoWwBEeDFmtizehobv5bwpttLKA4Mtt/xWKptIrwjsVSKQ4ahigUneh+ACx4OYM0x3OXEwUxw86uKZKsZ8htt3OgOxmN9nILwJmXECBcbNZirMS468CcU0HE5UFCL3yB6K7XCQRFw9Lz6aoKLygq3AkQhUK8vlvXdgu7hXi6ur9fTPlykZlcVE448AnR2cSGqG0hzMrO1nFhCgkNsihgbEsGEZ+YbcYHTkFgyFtQQFigKu6CK6zQkI//ZBDUJqVaRoBsl5ZXWaSHZSXMSRzLn2FWRlwByKidUUpeOKlyO4Mup6dj2NXa6eLYajTAZK6HDOV9FvOsDxgzGhjIZ1FF3xJOtp9OEyBYvVAnAuIafKBqb6TFMdKisNK1WroQL+zuavxtLY1XUI0Ziflz7+fYaq3EsFSYGNlpAAU4lLeObxlMYYIBZa5LLjUjBNo0U+j1Ta8ACzECpBkhmEkVltqUR7wCWcHCHihOrJdWs5VwKrGG3MdoCR90tLKfBgz27oBTRqswmot5VIxB7eZ02zE4OEkr+B1LT/ZdcTvC+7YDpxjxIbOITzm//xLOP8Kp/bSmAwV3Ohd2jaBAXKdJIRCGKE0VhaXGtVoBkYV3xOPV6lpG9m8hCxZEuVilkmUF1mg0dsRwCwMLUodYCTuxvb5+Yh0oDNqU1CFVqiYOpuLGmk4BBv9E4jwxS22efhEbPLSizm70lUpwxVYlnCkWiyDhmHAGg93dnXxjxzDRwPAEzm+JC9KsvRVWdbLBEoU276dniyt1b3wbsrDW5/TM3XQqlwckw6liNV6ob363BxsU+NKI63SVVzpuuEBcS8fTNfl9t1AnVGrx9Np+cS0f9sdyuexMMseiK5eFKogNaEJwAAiiwzAzk27ziFcIEk3BDRyIK/EKU2maYtNanDdNZIWVQkRXXAsUJFMyyLZwRSXPudPaWoaWtm6+bmuCHVYxJ73yzmkHoz477QzPGMAtOOL2y1VnvYtXv8y8jBtvQnmbA8wZJHnotDMXV7Ph/f1qQavv/VQnAmrxmlqLx9V5sCA4qtUCgABKDQgKGP9GIQ1VZGTtmcsSH7lcLF+J4RmSQsv4BPFRJjiIDh6IQqJDFiB/Q2HFRVNbYdCmGR7/RqJZXmFxBYcl0CY73uvby8lkhRTCGcMa/fETbcPd9jZnyBGxOzqDxImd00schO4t7+ADDqec10jLW+8ijXxcUgNtggSFoJbqZoM3JwGCV8AUZAiwwAfS1XmetFaNy5/4LAAPSBXqAtZ+tbq/lipy+lehmCZLwFZi+WzDyKK8yBy8cQuLJ8CBlwHFrLUIsYAwf4jMbBJFkzWbSDS3K8w1CGU5B0fwiu3tpVJSnJFkupYxjhzaBvn6PlghFOSXgKOTo/0glXLDrUwHsNs5s2Kh0Hsf/Wt9V7DzD1WY8XGZtA+e1ffo+8lwHq+oG6SJQZCGVasmCHFBR5wlLrxJjAAUbrHWKObD7GXzqgBIpQJZ7ogZ8SEOIThggCAv8YoNzOAKiQsxPkFDoAAIsWZ8/E8uFa64ALV5rRUgZOdkmTUP57NtGaM73EGzhX2Qoh9Kw0CBrOoAnM4HiBwk2KDPHgzRB9lLzWTf3XK72aWXo7yZYsJQ/5vIziTnDEjAiHs1+V++W6vGBQhBAobg4Se/AwVcka7txvmJVxTR19kKXMHJVzmXzxIT4MADWUAVmMmYkAR5FCCMBEKESIAYDCFmsaZpeISIzf+hCkHC4opzrz37BqDo3zixvr6czOYqgEE6S0kacfgm2nxOmsR9pA4JjmBrEGScjlbfA86ACAt2mh7tpRdchMXFTG8EClpM6FE8xCRi4qOxD2sCxS5GgqhJUFSFL9PG167xg0de/DWMESdE9vc5AkRScAaIl4qeAogGHgEQmBBFCa+wGNPEQXSFER/WViZmCe9rBQjLK5rJtOkVTdo8T2q8geL6g7OiK6DNXLbSSBUjCL42gKCqIzjIXjOfCV9QSj6M3VYnlAkyTK5LBGaYjNPLyAhmvkKb8CZDjxmFzXHCFdurJJBqNb5bx4QVCzXhB3kBhVhc/giBQJrmO47HECBhaDPJfwuvrWwWKEwYdsz0YeWOZSM2yB0YSBAiI+gKEwrEthUkf3lEM4GYEcLYCl4GEpaddC4FSBehSEYQFniFqM0820VrKaaKoHQoHoYcE75AiN13O77B1aODNOrY7d2+blAKDEqHJ/XVT94t19OQTC+/UGZLHQCKvvXVZH5tv5qui8lXFVKo1gAnbSEiQSLPbpq/hCwElX3io9gIgwDZTDJpFn8QEMomFGYiJXXwLolPECBNriBAml5hkKeVSDFz4///WNNE40+EG+Vol3PYTgAAAABJRU5ErkJggg==\",\"imageUrl\":null,\"color\":\"#fff\",\"overlay\":{\"enabled\":true,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}}},\"title\":\"Illuminance\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":null,\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"mdi:lightbulb-on\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"18px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":true,\"decimals\":0,\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null,\"units\":\"lx\",\"displayTimewindow\":true,\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1697382151041,\"endTimeMs\":1697468551041},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"timewindowStyle\":{\"showIcon\":false,\"iconSize\":\"24px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":true}}" + }, + "externalId": null, + "tags": [ + "weather", + "environment", + "illuminance" + ] +} \ No newline at end of file From a452b5d2d65e73fcc6880debf41df73b8d6bcb06 Mon Sep 17 00:00:00 2001 From: Igor Kulikov Date: Wed, 25 Oct 2023 18:14:05 +0300 Subject: [PATCH 42/43] UI: Outdoor Environment --- .../data/json/system/widget_bundles/outdoor_environment.json | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/application/src/main/data/json/system/widget_bundles/outdoor_environment.json b/application/src/main/data/json/system/widget_bundles/outdoor_environment.json index 1d30ca6b8c..b0480bc865 100644 --- a/application/src/main/data/json/system/widget_bundles/outdoor_environment.json +++ b/application/src/main/data/json/system/widget_bundles/outdoor_environment.json @@ -2,8 +2,8 @@ "widgetsBundle": { "alias": "outdoor_environment", "title": "Outdoor Environment", - "image": null, - "description": null, + "image": "data:image/png;base64,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", + "description": "Contains widgets displaying outdoor environment telemetry.", "externalId": null, "name": "Outdoor Environment" }, From 02c4bf22073b604ee103077a2c4d3fd8649594cd Mon Sep 17 00:00:00 2001 From: Igor Kulikov Date: Thu, 26 Oct 2023 10:30:25 +0300 Subject: [PATCH 43/43] UI: Indoor Environment: Temperature widgets. --- .../widget_bundles/indoor_environment.json | 22 +++++++++++++ .../indoor_horizontal_temperature_card.json | 28 +++++++++++++++++ ...ntal_temperature_card_with_background.json | 28 +++++++++++++++++ .../indoor_simple_temperature_chart_card.json | 31 +++++++++++++++++++ ...emperature_chart_card_with_background.json | 31 +++++++++++++++++++ .../widget_types/indoor_temperature_card.json | 28 +++++++++++++++++ ...door_temperature_card_with_background.json | 28 +++++++++++++++++ .../indoor_temperature_chart_card.json | 31 +++++++++++++++++++ ...emperature_chart_card_with_background.json | 31 +++++++++++++++++++ .../indoor_temperature_progress_bar.json | 29 +++++++++++++++++ ...perature_progress_bar_with_background.json | 29 +++++++++++++++++ .../DefaultSystemDataLoaderService.java | 1 + 12 files changed, 317 insertions(+) create mode 100644 application/src/main/data/json/system/widget_bundles/indoor_environment.json create mode 100644 application/src/main/data/json/system/widget_types/indoor_horizontal_temperature_card.json create mode 100644 application/src/main/data/json/system/widget_types/indoor_horizontal_temperature_card_with_background.json create mode 100644 application/src/main/data/json/system/widget_types/indoor_simple_temperature_chart_card.json create mode 100644 application/src/main/data/json/system/widget_types/indoor_simple_temperature_chart_card_with_background.json create mode 100644 application/src/main/data/json/system/widget_types/indoor_temperature_card.json create mode 100644 application/src/main/data/json/system/widget_types/indoor_temperature_card_with_background.json create mode 100644 application/src/main/data/json/system/widget_types/indoor_temperature_chart_card.json create mode 100644 application/src/main/data/json/system/widget_types/indoor_temperature_chart_card_with_background.json create mode 100644 application/src/main/data/json/system/widget_types/indoor_temperature_progress_bar.json create mode 100644 application/src/main/data/json/system/widget_types/indoor_temperature_progress_bar_with_background.json diff --git a/application/src/main/data/json/system/widget_bundles/indoor_environment.json b/application/src/main/data/json/system/widget_bundles/indoor_environment.json new file mode 100644 index 0000000000..90717e5745 --- /dev/null +++ b/application/src/main/data/json/system/widget_bundles/indoor_environment.json @@ -0,0 +1,22 @@ +{ + "widgetsBundle": { + "alias": "indoor_environment", + "title": "Indoor Environment", + "image": null, + "description": null, + "externalId": null, + "name": "Indoor Environment" + }, + "widgetTypeFqns": [ + "indoor_temperature_card", + "indoor_temperature_card_with_background", + "indoor_horizontal_temperature_card", + "indoor_horizontal_temperature_card_with_background", + "indoor_temperature_chart_card", + "indoor_temperature_chart_card_with_background", + "indoor_simple_temperature_chart_card", + "indoor_simple_temperature_chart_card_with_background", + "indoor_temperature_progress_bar", + "indoor_temperature_progress_bar_with_background" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/indoor_horizontal_temperature_card.json b/application/src/main/data/json/system/widget_types/indoor_horizontal_temperature_card.json new file mode 100644 index 0000000000..a97f8d62c9 --- /dev/null +++ b/application/src/main/data/json/system/widget_types/indoor_horizontal_temperature_card.json @@ -0,0 +1,28 @@ +{ + "fqn": "indoor_horizontal_temperature_card", + "name": "Indoor horizontal temperature card", + "deprecated": false, + "image": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAMgAAACgCAMAAAB+IdObAAAAt1BMVEUAAADf39/u7u7t7e3r6+vl5eXf39/x8fHw8PDr6+vf39/////z8/MjTMc+Ys7j4+ORpePHx8fk6fjPz8/x8fF1j9zI0vGQkJD5+fnV1dXCwsK2trZYWFisvOo9PT2tra3n5+ft7e28vLzy9Pvb29swV8tmZmZaeNXIyMiCgoIvLy/x9PvW3fWesedog9lMbtI8PDxaedWenp50dHRKSkqDm+DU1NQxV8q6x+6qqqohISHd3d2dnZ2F97sdAAAAC3RSTlMAIN/fz6AQ7++/MOBJYlEAAANbSURBVHja7dppc5pQFMZxbdP1cLisIiCKiLjvS5O23/9z9V6pI60NSdWmxnl+GQNceHH+IyGTiRUAAAAAAAAAAAAAAAAAAAAAAAAAAACAl/S++sq9ryifP2mvnXNXrVSqH+kGfKxW3tFNeFe5o5vwtvKGbgJCrg1Crg1Crg1Crs1th4x1djv034xJsmp7+0k60X3n5959FI2p6JEQXZ+yQQcNqUUlHJ8uZWx0dZJc3qvRjqUz67uSSZcl3SKpNMRiw+j26EC0GsIhX5AQpvBNObfcJ8ck8n3HMQU9rIUQZJIvv8vzp5ss1IgkRe5Oj9minUi3rO6EiDbMvc1U5y/WM0JGeo8KzAZRY7A2vfmguWoszbU3N/35oEHNzG9+n5uDuem16Ks8NAerbEknkxUzGXLgsks5Y0a02BDVmI38DVo8I2Tc/T1EDL1s4HnUpJYnD73lKvOGTlOeGzRbciEPETT0VhmdzKiRUQyx9m+ICphO1cH05/kJf+k8HTI5DmkK4RxCVsvBUgh55Ayd7JcQdXud4dcQlw9z3Pem6sely0Y+pWE8I4SOby1vnZn7kGG2FmKdrVTIPBu2nHnLbGZDFfK92VheLMTSOaJfjfhoqSREX3CPfucUupzCgpO/nMN1FwuJ8v0i6y9CxizN6HHCozKXC9E5OidkxsqEznR+SKR+cZx+a0WsFJ8JbfqjtkYF9bp8xSRdLERnl450eUPK2HU75SFTzt3TXphPLcfcbuW06ku2te1YbupJPr7/oC6waXdKa9fzzLNCIvXsPeLyl8O2NMTlXK0YEtthPbRFv08UaIH24Pe/9YPYF0E71ELbJrWstdSOLRIt6afbflI/M2TBLh2rMW/UpsvuEyETznWKId/sUEv7cZrmISEldpzG9jahQM7v70LatqZCtmGaxmlCdnxWiJq49ucLuLvQmXXriZDRjBWDDiFBP01aWhj4cUCUBi3tIbDjIIkTO6RQS2yxC6mHfRki1+pJkPpBSOeFuI89OSOdZYsxotIQVeJ2eRZRmfIh62lf0L80qln0GxVygjaV0tr0sm79L8TXCCHXBiHXBiHXBiHX5u52/j1d/UA34IP66MOdo712nz7f0odqAAAAAAAAAAAAAAAAAAAAAAAAAAAAAF7ID2D6pgpcp3y+AAAAAElFTkSuQmCC", + "description": "Displays a latest indoor temperature telemetry data in a horizontal layout.", + "descriptor": { + "type": "latest", + "sizeX": 5, + "sizeY": 1, + "resources": [], + "templateHtml": "\n", + "templateCss": "", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueCardWidget.onDataUpdated();\n};\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n horizontal: true,\n previewWidth: '420px',\n previewHeight: '90px',\n embedTitlePanel: true\n };\n};\n\nself.onDestroy = function() {\n};\n", + "settingsSchema": "", + "dataKeySettingsSchema": "", + "settingsDirective": "tb-value-card-widget-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"function\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Temperature\",\"color\":\"#2196f3\",\"settings\":{},\"_hash\":0.2392660816082064,\"funcBody\":\"var value = prevValue + Math.random() * 20 - 10;\\nif (value < 15) {\\n\\tvalue = 15;\\n} else if (value > 30) {\\n\\tvalue = 30;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]}}],\"timewindow\":{\"realtime\":{\"timewindowMs\":60000}},\"showTitle\":false,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"padding\":\"0px\",\"settings\":{\"labelPosition\":\"top\",\"layout\":\"horizontal\",\"showLabel\":true,\"labelFont\":{\"family\":\"Roboto\",\"size\":16,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"labelColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showIcon\":true,\"iconSize\":40,\"iconSizeUnit\":\"px\",\"icon\":\"thermostat\",\"iconColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":18,\"color\":\"#234CC7\"},{\"from\":18,\"to\":24,\"color\":\"#3FA71A\"},{\"from\":24,\"to\":null,\"color\":\"#D81838\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"valueFont\":{\"size\":36,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\",\"rangeList\":[{\"from\":null,\"to\":18,\"color\":\"#234CC7\"},{\"from\":18,\"to\":24,\"color\":\"#3FA71A\"},{\"from\":24,\"to\":null,\"color\":\"#D81838\"}]},\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"dateColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"color\",\"color\":\"#fff\",\"overlay\":{\"enabled\":false,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Horizontal temperature card\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"units\":\"°C\",\"decimals\":0,\"useDashboardTimewindow\":true,\"showLegend\":false,\"widgetStyle\":{},\"actions\":{},\"configMode\":\"basic\",\"displayTimewindow\":true,\"margin\":\"0px\",\"borderRadius\":\"0px\",\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"showTitleIcon\":false,\"titleTooltip\":\"\",\"titleFont\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1.6\"},\"titleIcon\":\"\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"iconSize\":\"14px\",\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"14px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1\"},\"color\":null}}" + }, + "externalId": null, + "tags": [ + "temperature", + "environment", + "indoor" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/indoor_horizontal_temperature_card_with_background.json b/application/src/main/data/json/system/widget_types/indoor_horizontal_temperature_card_with_background.json new file mode 100644 index 0000000000..6fe2e71a3f --- /dev/null +++ b/application/src/main/data/json/system/widget_types/indoor_horizontal_temperature_card_with_background.json @@ -0,0 +1,28 @@ +{ + "fqn": "indoor_horizontal_temperature_card_with_background", + "name": "Indoor horizontal temperature card with background", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays a latest indoor temperature telemetry data in a horizontal layout with background.", + "descriptor": { + "type": "latest", + "sizeX": 5, + "sizeY": 1, + "resources": [], + "templateHtml": "\n", + "templateCss": "", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueCardWidget.onDataUpdated();\n};\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n horizontal: true,\n previewWidth: '420px',\n previewHeight: '90px',\n embedTitlePanel: true\n };\n};\n\nself.onDestroy = function() {\n};\n", + "settingsSchema": "", + "dataKeySettingsSchema": "", + "settingsDirective": "tb-value-card-widget-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"function\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Temperature\",\"color\":\"#2196f3\",\"settings\":{},\"_hash\":0.2392660816082064,\"funcBody\":\"var value = prevValue + Math.random() * 20 - 10;\\nif (value < 15) {\\n\\tvalue = 15;\\n} else if (value > 30) {\\n\\tvalue = 30;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]}}],\"timewindow\":{\"realtime\":{\"timewindowMs\":60000}},\"showTitle\":false,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"padding\":\"0px\",\"settings\":{\"labelPosition\":\"top\",\"layout\":\"horizontal\",\"showLabel\":true,\"labelFont\":{\"family\":\"Roboto\",\"size\":16,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"labelColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showIcon\":true,\"iconSize\":40,\"iconSizeUnit\":\"px\",\"icon\":\"thermostat\",\"iconColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":18,\"color\":\"#224AC2\"},{\"from\":18,\"to\":24,\"color\":\"#3B911C\"},{\"from\":24,\"to\":null,\"color\":\"#DE2343\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"valueFont\":{\"size\":36,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\",\"rangeList\":[{\"from\":null,\"to\":18,\"color\":\"#224AC2\"},{\"from\":18,\"to\":24,\"color\":\"#3B911C\"},{\"from\":24,\"to\":null,\"color\":\"#DE2343\"}]},\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"dateColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"image\",\"imageBase64\":\"data:image/png;base64,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\",\"imageUrl\":null,\"color\":\"#fff\",\"overlay\":{\"enabled\":true,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Horizontal temperature card\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"units\":\"°C\",\"decimals\":0,\"useDashboardTimewindow\":true,\"showLegend\":false,\"widgetStyle\":{},\"actions\":{},\"configMode\":\"basic\",\"displayTimewindow\":true,\"margin\":\"0px\",\"borderRadius\":\"0px\",\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"showTitleIcon\":false,\"titleTooltip\":\"\",\"titleFont\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1.6\"},\"titleIcon\":\"\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"iconSize\":\"14px\",\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"14px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1\"},\"color\":null}}" + }, + "externalId": null, + "tags": [ + "temperature", + "environment", + "indoor" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/indoor_simple_temperature_chart_card.json b/application/src/main/data/json/system/widget_types/indoor_simple_temperature_chart_card.json new file mode 100644 index 0000000000..890db4f9db --- /dev/null +++ b/application/src/main/data/json/system/widget_types/indoor_simple_temperature_chart_card.json @@ -0,0 +1,31 @@ +{ + "fqn": "indoor_simple_temperature_chart_card", + "name": "Indoor simple temperature chart card", + "deprecated": false, + "image": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAMgAAACgCAMAAAB+IdObAAAAh1BMVEUAAADg4ODf39/g4ODg4OD////g4OAjTMchISHHx8fj4+Px8fGQkJA9PT10dHSsrKxYWFgvLy8+Ys7I0vE8PDyRpePk6fjV1dVaedW6urqsvOqenp51j9yCgoLy9PtKSkqrq6tmZmafsec/Ys4wV8tLS0uDmt9ohNhMbtLW3vQxV8rW3fWDm+D/9RHFAAAABXRSTlMA7yC/r1EOHTEAAASnSURBVHja7M9JAcAgDAAwytEP/v0OGdAlDtIAAAAAAAB+p4/I181+HrHX83b0Ngs8zmS0XCVElUiKXEbkNh979rIiNwxEYXh14FSVrmAwRhi3F/P+rxi5e5huj8cQCHHUQf9GRWn1LQwGdUhrdUhrdUhrdUhrdUhrdUhrnUJ0jninTiEpDC8Sc/cmNNspxN8W9wIJYWEIN/x24hVXdg6ZksNrjndRnBQQlah1BEy2o1YXgI4isFhHK5zMBFCByTgBEgVnXQ/RvAzeQF+PJTFB6BMDsObEgpC5qk8rZVy4jJGA84jMC1xOw4xn10HC8gMkJSA70GHihEIIRzjaRIXzCINidMBHgFDxBVEob/fVs4sglslwhHifUg5ghFAQN4hCKS6n5ImQAJTV528QQJjSBwW7roAE1uQIWUVEv0HGCqHU7pBIsfQDJIqI4dlFEG6FA2T2irKHRITBhAVS7hCXVX34vB9tfUAszzCHXZdAMmvzAWIrOewhnrlst8wPiA7MS4INjLaNDwimgfwXH3shmRXHbL8Uqtpjb/hM7et4Lvdz7SIIbmFWnLSHoIk2yJ+krpFXif//7/fd6pDW6pDW6pDW6pDW6pDW6pC/lpXV+xTk3SG/2LG35VRhKADDV2uyEkhIEMJBoNbiqXu///PtoBjKFqhDvJAZvpk62OFi/SWhylYhF0KaV7boEIGSQmMX4W7BIT760GIfmCw2JDEdlhfx14RsYgDQcSeHm/yU5tCq9qc0PeUaXkJG8APFrXtIFX+RsKkhnRSuYmL8hat9Ta7C/WsuyK7fpTy3kGqfEqMJuXy1zMQFNDQJK30ml3tTfb6e/IoSEfUHp+i7hZjJ2pBOQYiGxqaZOSc5mNcmoDLhJui7ghmokNI+dmIPc0vlOYakcd4P0XZlXcipydoAQEhIbNNjmMZo8vAriUpKbOdnPGJg2TSXkI02P/2QPSG5zQy/yLndPxquTPYZpvgKEXn/IZjH1baZVuAhY2yrlC21SkzcNvtDSNi9q4q6Pla3uBRudFEUMM47oAxoJpCz3pQU7v/8DDkwsxdx9tKQ3F6Q/rY5wlNEeztK1AGs4Me6oUEwPHCifpYw55DQLiJremOM3H0yDOxQPIInJBEKCgYtOSJykbmEmDcFzA8R3ciSe3BzUAyewYRC5Fyhkn7gf0bIA292SEHIZX4IQwF39H5c4g6e5GWlEOV9/J1ELti8ED18TyqeDAmQgeUjD2iylejDXFQglrNCCrvVe47dgqu01jCGy94YH2gcMnDAxHZOiK7tYU9uTunO/oYR2f+LiNGMgas5Ibn9y/dVNSEbe81OMOIzAnfuIfbeO7y2Qt1uIpJPfMdw5R5iL8igyiSGcZ4fa0JSGMZ45IGDF4akdgE90CFppRUMolwxcOUeYg/G6Di8ZuxhkFdilMCEd3qupTd/qvGPvL4Hw94vZBTlKBmMWkoIkxhRmLCQkK1SPkxaSMin8GDaQkJ+s4asIUuxhrybNeTdrCHvZg15N2vIv3bu3AiAEAaCoHhOzuWfL0HgCOjOYP2tqcaQajLad4WMUeTcvuef90SQos88XRs9AAAAAAAAXrMA+iCoTuC9Gd4AAAAASUVORK5CYII=", + "description": "Displays historical indoor temperature values as a simplified chart. Optionally may display the corresponding latest indoor temperature value.", + "descriptor": { + "type": "timeseries", + "sizeX": 4.5, + "sizeY": 2, + "resources": [], + "templateHtml": "\n\n", + "templateCss": ".legend {\n font-size: 13px;\n line-height: 10px;\n}\n\n.legend table { \n border-spacing: 0px;\n border-collapse: separate;\n}\n\n.mouse-events .flot-overlay {\n cursor: crosshair; \n}\n\n", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueChartCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueChartCardWidget.onDataUpdated();\n};\n\nself.onLatestDataUpdated = function() {\n self.ctx.$scope.valueChartCardWidget.onLatestDataUpdated();\n}\n\nself.onEditModeChanged = function() {\n self.ctx.$scope.valueChartCardWidget.onEditModeChanged();\n}\n\nself.onDestroy = function() {\n self.ctx.$scope.valueChartCardWidget.onDestroy();\n}\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '300px',\n previewHeight: '150px',\n embedTitlePanel: true,\n hasAdditionalLatestDataKeys: true,\n defaultDataKeysFunction: function() {\n return [\n { name: 'temperature', label: 'Temperature', type: 'timeseries', color: 'rgba(0, 0, 0, 0.87)'}\n ];\n },\n defaultLatestDataKeysFunction: function(configComponent) {\n return [{ name: 'temperature', label: 'Latest', type: 'timeseries'}];\n }\n };\n}\n", + "settingsSchema": "{}", + "dataKeySettingsSchema": "{}", + "latestDataKeySettingsSchema": "{}", + "settingsDirective": "tb-value-chart-card-widget-settings", + "dataKeySettingsDirective": "", + "latestDataKeySettingsDirective": "", + "hasBasicMode": true, + "basicModeDirective": "tb-value-chart-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Temperature\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 20 - 10;\\nif (value < 15) {\\n\\tvalue = 15;\\n} else if (value > 30) {\\n\\tvalue = 30;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 20 - 10;\\nif (value < 15) {\\n\\tvalue = 15;\\n} else if (value > 30) {\\n\\tvalue = 30;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"layout\":\"left\",\"autoScale\":true,\"showValue\":true,\"valueFont\":{\"family\":\"Roboto\",\"size\":28,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\",\"lineHeight\":\"32px\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":18,\"color\":\"#234CC7\"},{\"from\":18,\"to\":24,\"color\":\"#3FA71A\"},{\"from\":24,\"to\":null,\"color\":\"#D81838\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"color\",\"color\":\"#fff\",\"overlay\":{\"enabled\":false,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}}},\"title\":\"Temperature\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":null,\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"thermostat\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"18px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":true,\"decimals\":0,\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null,\"units\":\"°C\",\"displayTimewindow\":true,\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1697382151041,\"endTimeMs\":1697468551041},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"timewindowStyle\":{\"showIcon\":false,\"iconSize\":\"24px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":true}}" + }, + "externalId": null, + "tags": [ + "temperature", + "environment", + "indoor" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/indoor_simple_temperature_chart_card_with_background.json b/application/src/main/data/json/system/widget_types/indoor_simple_temperature_chart_card_with_background.json new file mode 100644 index 0000000000..b9be76ffda --- /dev/null +++ b/application/src/main/data/json/system/widget_types/indoor_simple_temperature_chart_card_with_background.json @@ -0,0 +1,31 @@ +{ + "fqn": "indoor_simple_temperature_chart_card_with_background", + "name": "Indoor simple temperature chart card with background", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays historical indoor temperature values as a simplified chart with background. Optionally may display the corresponding latest indoor temperature value.", + "descriptor": { + "type": "timeseries", + "sizeX": 4.5, + "sizeY": 2, + "resources": [], + "templateHtml": "\n\n", + "templateCss": ".legend {\n font-size: 13px;\n line-height: 10px;\n}\n\n.legend table { \n border-spacing: 0px;\n border-collapse: separate;\n}\n\n.mouse-events .flot-overlay {\n cursor: crosshair; \n}\n\n", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueChartCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueChartCardWidget.onDataUpdated();\n};\n\nself.onLatestDataUpdated = function() {\n self.ctx.$scope.valueChartCardWidget.onLatestDataUpdated();\n}\n\nself.onEditModeChanged = function() {\n self.ctx.$scope.valueChartCardWidget.onEditModeChanged();\n}\n\nself.onDestroy = function() {\n self.ctx.$scope.valueChartCardWidget.onDestroy();\n}\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '300px',\n previewHeight: '150px',\n embedTitlePanel: true,\n hasAdditionalLatestDataKeys: true,\n defaultDataKeysFunction: function() {\n return [\n { name: 'temperature', label: 'Temperature', type: 'timeseries', color: 'rgba(0, 0, 0, 0.87)'}\n ];\n },\n defaultLatestDataKeysFunction: function(configComponent) {\n return [{ name: 'temperature', label: 'Latest', type: 'timeseries'}];\n }\n };\n}\n", + "settingsSchema": "{}", + "dataKeySettingsSchema": "{}", + "latestDataKeySettingsSchema": "{}", + "settingsDirective": "tb-value-chart-card-widget-settings", + "dataKeySettingsDirective": "", + "latestDataKeySettingsDirective": "", + "hasBasicMode": true, + "basicModeDirective": "tb-value-chart-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Temperature\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 20 - 10;\\nif (value < 15) {\\n\\tvalue = 15;\\n} else if (value > 30) {\\n\\tvalue = 30;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 20 - 10;\\nif (value < 15) {\\n\\tvalue = 15;\\n} else if (value > 30) {\\n\\tvalue = 30;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"layout\":\"left\",\"autoScale\":true,\"showValue\":true,\"valueFont\":{\"family\":\"Roboto\",\"size\":28,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\",\"lineHeight\":\"32px\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":18,\"color\":\"#224AC2\"},{\"from\":18,\"to\":24,\"color\":\"#3B911C\"},{\"from\":24,\"to\":null,\"color\":\"#DE2343\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"image\",\"imageBase64\":\"data:image/png;base64,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\",\"imageUrl\":null,\"color\":\"#fff\",\"overlay\":{\"enabled\":true,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}}},\"title\":\"Temperature\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":null,\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"thermostat\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"18px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":true,\"decimals\":0,\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null,\"units\":\"°C\",\"displayTimewindow\":true,\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1697382151041,\"endTimeMs\":1697468551041},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"timewindowStyle\":{\"showIcon\":false,\"iconSize\":\"24px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":true}}" + }, + "externalId": null, + "tags": [ + "temperature", + "environment", + "indoor" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/indoor_temperature_card.json b/application/src/main/data/json/system/widget_types/indoor_temperature_card.json new file mode 100644 index 0000000000..c8316e3af6 --- /dev/null +++ b/application/src/main/data/json/system/widget_types/indoor_temperature_card.json @@ -0,0 +1,28 @@ +{ + "fqn": "indoor_temperature_card", + "name": "Indoor temperature card", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays a latest indoor temperature telemetry data in a box layout.", + "descriptor": { + "type": "latest", + "sizeX": 3, + "sizeY": 3, + "resources": [], + "templateHtml": "\n", + "templateCss": "", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueCardWidget.onDataUpdated();\n};\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '250px',\n previewHeight: '250px',\n embedTitlePanel: true,\n defaultDataKeysFunction: function() {\n return [{ name: 'temperature', label: 'Temperature', type: 'timeseries' }];\n }\n };\n};\n\nself.onDestroy = function() {\n};\n", + "settingsSchema": "", + "dataKeySettingsSchema": "", + "settingsDirective": "tb-value-card-widget-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"function\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Temperature\",\"color\":\"#2196f3\",\"settings\":{},\"_hash\":0.2392660816082064,\"funcBody\":\"var value = prevValue + Math.random() * 20 - 10;\\nif (value < 15) {\\n\\tvalue = 15;\\n} else if (value > 30) {\\n\\tvalue = 30;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]}}],\"timewindow\":{\"realtime\":{\"timewindowMs\":60000}},\"showTitle\":false,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"padding\":\"0px\",\"settings\":{\"labelPosition\":\"top\",\"layout\":\"square\",\"showLabel\":true,\"labelFont\":{\"family\":\"Roboto\",\"size\":16,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"labelColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showIcon\":true,\"iconSize\":40,\"iconSizeUnit\":\"px\",\"icon\":\"thermostat\",\"iconColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":18,\"color\":\"#234CC7\"},{\"from\":18,\"to\":24,\"color\":\"#3FA71A\"},{\"from\":24,\"to\":null,\"color\":\"#D81838\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"valueFont\":{\"family\":\"Roboto\",\"size\":52,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\",\"rangeList\":[{\"from\":null,\"to\":18,\"color\":\"#234CC7\"},{\"from\":18,\"to\":24,\"color\":\"#3FA71A\"},{\"from\":24,\"to\":null,\"color\":\"#D81838\"}]},\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"dateColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"color\",\"color\":\"#fff\",\"overlay\":{\"enabled\":false,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Temperature card\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"units\":\"°C\",\"decimals\":0,\"useDashboardTimewindow\":true,\"showLegend\":false,\"widgetStyle\":{},\"actions\":{},\"configMode\":\"basic\",\"displayTimewindow\":true,\"margin\":\"0px\",\"borderRadius\":\"0px\",\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"showTitleIcon\":false,\"titleTooltip\":\"\",\"titleFont\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1.6\"},\"titleIcon\":\"\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"iconSize\":\"14px\",\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"14px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1\"},\"color\":null}}" + }, + "externalId": null, + "tags": [ + "temperature", + "environment", + "indoor" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/indoor_temperature_card_with_background.json b/application/src/main/data/json/system/widget_types/indoor_temperature_card_with_background.json new file mode 100644 index 0000000000..28243c702b --- /dev/null +++ b/application/src/main/data/json/system/widget_types/indoor_temperature_card_with_background.json @@ -0,0 +1,28 @@ +{ + "fqn": "indoor_temperature_card_with_background", + "name": "Indoor temperature card with background", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays a latest indoor temperature telemetry data in a box layout with background.", + "descriptor": { + "type": "latest", + "sizeX": 3, + "sizeY": 3, + "resources": [], + "templateHtml": "\n", + "templateCss": "", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.valueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.valueCardWidget.onDataUpdated();\n};\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '250px',\n previewHeight: '250px',\n embedTitlePanel: true,\n defaultDataKeysFunction: function() {\n return [{ name: 'temperature', label: 'Temperature', type: 'timeseries' }];\n }\n };\n};\n\nself.onDestroy = function() {\n};\n", + "settingsSchema": "", + "dataKeySettingsSchema": "", + "settingsDirective": "tb-value-card-widget-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"function\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Temperature\",\"color\":\"#2196f3\",\"settings\":{},\"_hash\":0.2392660816082064,\"funcBody\":\"var value = prevValue + Math.random() * 20 - 10;\\nif (value < 15) {\\n\\tvalue = 15;\\n} else if (value > 30) {\\n\\tvalue = 30;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]}}],\"timewindow\":{\"realtime\":{\"timewindowMs\":60000}},\"showTitle\":false,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"padding\":\"0px\",\"settings\":{\"labelPosition\":\"top\",\"layout\":\"square\",\"showLabel\":true,\"labelFont\":{\"family\":\"Roboto\",\"size\":16,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"labelColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showIcon\":true,\"iconSize\":40,\"iconSizeUnit\":\"px\",\"icon\":\"thermostat\",\"iconColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":18,\"color\":\"#224AC2\"},{\"from\":18,\"to\":24,\"color\":\"#3B911C\"},{\"from\":24,\"to\":null,\"color\":\"#DE2343\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"valueFont\":{\"family\":\"Roboto\",\"size\":52,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\",\"rangeList\":[{\"from\":null,\"to\":18,\"color\":\"#224AC2\"},{\"from\":18,\"to\":24,\"color\":\"#3B911C\"},{\"from\":24,\"to\":null,\"color\":\"#DE2343\"}]},\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\"},\"dateColor\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"background\":{\"type\":\"image\",\"imageBase64\":\"data:image/png;base64,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\",\"imageUrl\":null,\"color\":\"#fff\",\"overlay\":{\"enabled\":true,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Temperature card\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"units\":\"°C\",\"decimals\":0,\"useDashboardTimewindow\":true,\"showLegend\":false,\"widgetStyle\":{},\"actions\":{},\"configMode\":\"basic\",\"displayTimewindow\":true,\"margin\":\"0px\",\"borderRadius\":\"0px\",\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"showTitleIcon\":false,\"titleTooltip\":\"\",\"titleFont\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1.6\"},\"titleIcon\":\"\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"iconSize\":\"14px\",\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"14px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1\"},\"color\":null}}" + }, + "externalId": null, + "tags": [ + "temperature", + "environment", + "indoor" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/indoor_temperature_chart_card.json b/application/src/main/data/json/system/widget_types/indoor_temperature_chart_card.json new file mode 100644 index 0000000000..567cdbb73a --- /dev/null +++ b/application/src/main/data/json/system/widget_types/indoor_temperature_chart_card.json @@ -0,0 +1,31 @@ +{ + "fqn": "indoor_temperature_chart_card", + "name": "Indoor temperature chart card", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays a indoor temperature data as a combination of the latest and aggregated values. Optionally may display the corresponding historical values as a simplified chart.", + "descriptor": { + "type": "timeseries", + "sizeX": 4.5, + "sizeY": 3.5, + "resources": [], + "templateHtml": "\n\n", + "templateCss": ".legend {\n font-size: 13px;\n line-height: 10px;\n}\n\n.legend table { \n border-spacing: 0px;\n border-collapse: separate;\n}\n\n.mouse-events .flot-overlay {\n cursor: crosshair; \n}\n\n", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onDataUpdated();\n};\n\nself.onLatestDataUpdated = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onLatestDataUpdated();\n}\n\nself.onResize = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onResize();\n}\n\nself.onEditModeChanged = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onEditModeChanged();\n}\n\nself.onDestroy = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onDestroy();\n}\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '400px',\n previewHeight: '300px',\n embedTitlePanel: true,\n hasAdditionalLatestDataKeys: true,\n defaultDataKeysFunction: function() {\n return [\n { name: 'temperature', label: 'Temperature', type: 'timeseries', color: 'rgba(0, 0, 0, 0.87)', units: '°C', decimals: 0 }\n ];\n },\n defaultLatestDataKeysFunction: function(configComponent, configData) {\n return configComponent.createDefaultAggregatedValueLatestDataKeys(configData, 'temperature', '°C', 0);\n }\n };\n}\n", + "settingsSchema": "{}", + "dataKeySettingsSchema": "{}", + "latestDataKeySettingsSchema": "{}", + "settingsDirective": "tb-aggregated-value-card-widget-settings", + "dataKeySettingsDirective": "", + "latestDataKeySettingsDirective": "tb-aggregated-value-card-key-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-aggregated-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"Main building\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Temperature\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{\"showLines\":true,\"fillLines\":true,\"showPoints\":false},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 20 - 10;\\nif (value < 15) {\\n\\tvalue = 15;\\n} else if (value > 30) {\\n\\tvalue = 30;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"°C\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"#4caf50\",\"settings\":{\"position\":\"center\",\"font\":{\"size\":52,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"1\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":18,\"color\":\"#234CC7\"},{\"from\":18,\"to\":24,\"color\":\"#3FA71A\"},{\"from\":24,\"to\":null,\"color\":\"#D81838\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.9408410830697858,\"funcBody\":\"var value = prevValue + Math.random() * 20 - 10;\\nif (value < 15) {\\n\\tvalue = 15;\\n} else if (value > 30) {\\n\\tvalue = 30;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"°C\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta percent\",\"color\":\"#f44336\",\"settings\":{\"position\":\"rightTop\",\"font\":{\"size\":14,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"20px\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[{\"from\":null,\"to\":0,\"color\":\"#198038\"},{\"from\":0,\"to\":0,\"color\":\"rgba(0, 0, 0, 0.87)\"},{\"from\":0,\"to\":null,\"color\":\"#D12730\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":true},\"_hash\":0.06392321853157967,\"funcBody\":\"var value = prevValue + Math.random() * 6 - 3;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < -25) {\\n\\tvalue = -25;\\n} else if (value > 25) {\\n\\tvalue = 25;\\n} \\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta absolute\",\"color\":\"#607d8b\",\"settings\":{\"position\":\"rightBottom\",\"font\":{\"size\":11,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.44695098620509865,\"funcBody\":\"var value = prevValue + Math.random() * 4 - 2;\\nif (value < -6) {\\n\\tvalue = -6;\\n} else if (value > 6) {\\n\\tvalue = 6;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"°C\",\"decimals\":1,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1691927717318,\"endTimeMs\":1692014117318},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"stack\":false,\"fontSize\":10,\"fontColor\":\"#545454\",\"showTooltip\":true,\"tooltipIndividual\":false,\"tooltipCumulative\":false,\"hideZeros\":false,\"grid\":{\"verticalLines\":true,\"horizontalLines\":true,\"outlineWidth\":1,\"color\":\"#545454\",\"backgroundColor\":null,\"tickColor\":\"#DDDDDD\"},\"xaxis\":{\"title\":null,\"showLabels\":true,\"color\":\"#545454\"},\"yaxis\":{\"min\":null,\"max\":null,\"title\":null,\"showLabels\":true,\"color\":\"#545454\",\"tickSize\":null,\"tickDecimals\":0,\"ticksFormatter\":\"\"},\"shadowSize\":4,\"smoothLines\":false,\"comparisonEnabled\":false,\"xaxisSecond\":{\"axisPosition\":\"top\",\"title\":null,\"showLabels\":true},\"showLegend\":true,\"legendConfig\":{\"direction\":\"column\",\"position\":\"bottom\",\"sortDataKeys\":false,\"showMin\":false,\"showMax\":false,\"showAvg\":true,\"showTotal\":false,\"showLatest\":false},\"customLegendEnabled\":false,\"showSubtitle\":true,\"subtitle\":\"${entityName}\",\"subtitleFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"subtitleColor\":\"rgba(0, 0, 0, 0.38)\",\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"dateColor\":\"rgba(0, 0, 0, 0.38)\",\"showChart\":true,\"chartColor\":\"rgba(0, 0, 0, 0.87)\",\"background\":{\"type\":\"color\",\"color\":\"#fff\",\"overlay\":{\"enabled\":false,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Temperature\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"device_thermostat\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"24px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":false,\"displayTimewindow\":true,\"decimals\":0,\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"24px\",\"icon\":null,\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":false},\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null}" + }, + "externalId": null, + "tags": [ + "temperature", + "environment", + "indoor" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/indoor_temperature_chart_card_with_background.json b/application/src/main/data/json/system/widget_types/indoor_temperature_chart_card_with_background.json new file mode 100644 index 0000000000..21ef0a232b --- /dev/null +++ b/application/src/main/data/json/system/widget_types/indoor_temperature_chart_card_with_background.json @@ -0,0 +1,31 @@ +{ + "fqn": "indoor_temperature_chart_card_with_background", + "name": "Indoor temperature chart card with background", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays a indoor temperature data as a combination of the latest and aggregated values with background. Optionally may display the corresponding historical values as a simplified chart.", + "descriptor": { + "type": "timeseries", + "sizeX": 4.5, + "sizeY": 3.5, + "resources": [], + "templateHtml": "\n\n", + "templateCss": ".legend {\n font-size: 13px;\n line-height: 10px;\n}\n\n.legend table { \n border-spacing: 0px;\n border-collapse: separate;\n}\n\n.mouse-events .flot-overlay {\n cursor: crosshair; \n}\n\n", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onDataUpdated();\n};\n\nself.onLatestDataUpdated = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onLatestDataUpdated();\n}\n\nself.onResize = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onResize();\n}\n\nself.onEditModeChanged = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onEditModeChanged();\n}\n\nself.onDestroy = function() {\n self.ctx.$scope.aggregatedValueCardWidget.onDestroy();\n}\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '400px',\n previewHeight: '300px',\n embedTitlePanel: true,\n hasAdditionalLatestDataKeys: true,\n defaultDataKeysFunction: function() {\n return [\n { name: 'temperature', label: 'Temperature', type: 'timeseries', color: 'rgba(0, 0, 0, 0.87)', units: '°C', decimals: 0 }\n ];\n },\n defaultLatestDataKeysFunction: function(configComponent, configData) {\n return configComponent.createDefaultAggregatedValueLatestDataKeys(configData, 'temperature', '°C', 0);\n }\n };\n}\n", + "settingsSchema": "{}", + "dataKeySettingsSchema": "{}", + "latestDataKeySettingsSchema": "{}", + "settingsDirective": "tb-aggregated-value-card-widget-settings", + "dataKeySettingsDirective": "", + "latestDataKeySettingsDirective": "tb-aggregated-value-card-key-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-aggregated-value-card-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"Main building\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Temperature\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"settings\":{\"showLines\":true,\"fillLines\":true,\"showPoints\":false},\"_hash\":0.8587686344902596,\"funcBody\":\"var value = prevValue + Math.random() * 20 - 10;\\nif (value < 15) {\\n\\tvalue = 15;\\n} else if (value > 30) {\\n\\tvalue = 30;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"°C\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]},\"latestDataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Latest\",\"color\":\"#4caf50\",\"settings\":{\"position\":\"center\",\"font\":{\"size\":52,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"1\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":18,\"color\":\"#224AC2\"},{\"from\":18,\"to\":24,\"color\":\"#3B911C\"},{\"from\":24,\"to\":null,\"color\":\"#DE2343\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.9408410830697858,\"funcBody\":\"var value = prevValue + Math.random() * 20 - 10;\\nif (value < 15) {\\n\\tvalue = 15;\\n} else if (value > 30) {\\n\\tvalue = 30;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"°C\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta percent\",\"color\":\"#f44336\",\"settings\":{\"position\":\"rightTop\",\"font\":{\"size\":14,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"20px\"},\"color\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[{\"from\":null,\"to\":0,\"color\":\"#198038\"},{\"from\":0,\"to\":0,\"color\":\"rgba(0, 0, 0, 0.87)\"},{\"from\":0,\"to\":null,\"color\":\"#D12730\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":true},\"_hash\":0.06392321853157967,\"funcBody\":\"var value = prevValue + Math.random() * 6 - 3;\\nvar multiplier = Math.pow(10, 2 || 0);\\nvar value = Math.round(value * multiplier) / multiplier;\\nif (value < -25) {\\n\\tvalue = -25;\\n} else if (value > 25) {\\n\\tvalue = 25;\\n} \\nreturn value;\",\"aggregationType\":null,\"units\":\"%\",\"decimals\":0,\"usePostProcessing\":null,\"postFuncBody\":null},{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Delta absolute\",\"color\":\"#607d8b\",\"settings\":{\"position\":\"rightBottom\",\"font\":{\"size\":11,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":{\"type\":\"constant\",\"color\":\"rgba(0, 0, 0, 0.38)\",\"rangeList\":[],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"showArrow\":false},\"_hash\":0.44695098620509865,\"funcBody\":\"var value = prevValue + Math.random() * 4 - 2;\\nif (value < -6) {\\n\\tvalue = -6;\\n} else if (value > 6) {\\n\\tvalue = 6;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":\"°C\",\"decimals\":1,\"usePostProcessing\":null,\"postFuncBody\":null}]}],\"timewindow\":{\"hideInterval\":false,\"hideLastInterval\":false,\"hideQuickInterval\":false,\"hideAggregation\":false,\"hideAggInterval\":false,\"hideTimezone\":false,\"selectedTab\":1,\"history\":{\"historyType\":2,\"timewindowMs\":60000,\"interval\":43200000,\"fixedTimewindow\":{\"startTimeMs\":1691927717318,\"endTimeMs\":1692014117318},\"quickInterval\":\"CURRENT_MONTH_SO_FAR\"},\"aggregation\":{\"type\":\"AVG\",\"limit\":25000}},\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":null,\"padding\":\"0\",\"settings\":{\"stack\":false,\"fontSize\":10,\"fontColor\":\"#545454\",\"showTooltip\":true,\"tooltipIndividual\":false,\"tooltipCumulative\":false,\"hideZeros\":false,\"grid\":{\"verticalLines\":true,\"horizontalLines\":true,\"outlineWidth\":1,\"color\":\"#545454\",\"backgroundColor\":null,\"tickColor\":\"#DDDDDD\"},\"xaxis\":{\"title\":null,\"showLabels\":true,\"color\":\"#545454\"},\"yaxis\":{\"min\":null,\"max\":null,\"title\":null,\"showLabels\":true,\"color\":\"#545454\",\"tickSize\":null,\"tickDecimals\":0,\"ticksFormatter\":\"\"},\"shadowSize\":4,\"smoothLines\":false,\"comparisonEnabled\":false,\"xaxisSecond\":{\"axisPosition\":\"top\",\"title\":null,\"showLabels\":true},\"showLegend\":true,\"legendConfig\":{\"direction\":\"column\",\"position\":\"bottom\",\"sortDataKeys\":false,\"showMin\":false,\"showMax\":false,\"showAvg\":true,\"showTotal\":false,\"showLatest\":false},\"customLegendEnabled\":false,\"showSubtitle\":true,\"subtitle\":\"${entityName}\",\"subtitleFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"subtitleColor\":\"rgba(0, 0, 0, 0.38)\",\"showDate\":true,\"dateFormat\":{\"format\":null,\"lastUpdateAgo\":true,\"custom\":false},\"dateFont\":{\"family\":\"Roboto\",\"size\":12,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"dateColor\":\"rgba(0, 0, 0, 0.38)\",\"showChart\":true,\"chartColor\":\"rgba(0, 0, 0, 0.87)\",\"background\":{\"type\":\"image\",\"imageBase64\":\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAU8AAAELCAMAAABu2vS6AAADAFBMVEUHCgkJDAwLDw+vnZUNEhGtm5IQExKvn5imkIOplYuql46xoZusmY+mk4mokoWxrLEQFhXz8vSkkYj19falk4ynlY6zp6WrmZK1tL2ypKKwqa21qamplIijj4SbioGxoJekjYC1sLUUGRnv7/MaHBmfjYWgjIHAusCUg3mYhn2sl4uciHoUFhS4t8Gxsbq4sri1pZ2fin6rp629t76xrrWPfG/GvcG/tLRuY1zv7e6Rf3To6e23ra5xZmCgkIjQ0966tLqKd2qMem6Db2NnXFO7u8Tl5uuGc2jEury5rKnKwcStoqLq7fKrqrF9a2BqYFiUgHCqpal1amW/vsfe3+U1NjO9sa+XgXXWzs6vpqmYjYrKztpjXlytrba3qaPAtrpjWE+UiITb4+7Tyst5aFuahHji4+jX1ttdWVZ4Xk68rqw5OzhXVFFuaWggIBzCwsyJh4minJ/Z0tPFyNQmJiEXHh/V3uq7sLPTx8XMzNOfj32ehWo9Pz3R0decl5nOxMeQjI58cGwkKyubkZCjjXd6bWcdJSTb2+FUST5wYFReVEuloaaqnp5BQkDJxsyIfHlybm1kUUN1ZFji6fCNgHylmJZoY2KhlZF+Y1JMTk+EeHVHRkOBdG9PRDnPwb1YT0YrMTJMS0jFwMXU1+Gpm5mPhIDP2egtKyRCR0zCubfLvLXCsafHt6+MdGKVkZVIQTaXhnSafGSCbFqUdl7H0+Onim2klYWspJxwWEgxMCqfo614dHR+e32rjnymm49NUlhfSTqtkHBUWV2iqLKooJezloKYnqeFgYKFi5S9zN+7qZwwOT2Fd2GVmJ+NkJapsr/ErZ2lrrm1vcyMbVa8pJS7w9NDOi9+gIZ9hI48Mid1fIXPtaHIpoezlniwuMaTeGhYX2fcwKthZWmynY66nohscnlma3F1d3vAnnyMlZ+xxN3t493SsZGjudPhzb2RpL7n2dEtRE0XLj6UWz1AWmt3SzZadowMIC0QQWFwjqxjdE1OYDc+Z4wmU3awbkCid1hEfFJ/AACbRElEQVR42nycWWgsRRSGJ5NxsjlhDJEoGA1jlGwP5kGIylVigr6IEVECbkQxoigi6PiiL0YdvYKIG+4YcX1zBxXcFxRRUXHfd8VdBF/9z3/+qtM9Mf7dVd2Tm3vBz//UOVVdPZWd1HXS6VlHU0tHL0FHSoumw6kDDzzwYD+kqampaTunp9n2xmmHaT+cBR166H6H7rff+KGHjhxqbXQka3R01Nru1Og1a1dBa8vLa2f3VCo4TT09PVVrVX2C9Geh8kf9WrVWNfUk4VaXqu7t92pQvV5r1uvNmv8z1WazDlk3hw7yz37P38aBX4fwg8rKzp0rOxdAdOd1C9ctnH4dSAbNy482mEtkaefi4cBJgSRQOs0pwMQJgSXkNCkj6V3QhLwfBU0cI7hCAEuYA7uP7j62++6Dg7vfsJyAXlwrsKn0AE2NQLs5slcL/vhtHKTnCNnY45o5p981Tuz8H6g1m3P1Jo45EcQPgLNZc7bk6TK68OcCcbpHwZMwpSOBc0k4aU/xBEjRTEBBFCxlTsGUCJQaF0gJMKlwp/FsmDeN5+DYtICuLd9WT6B6EqHMLLxrB2/UC6cR403CKZJoDrYE1C1Xr9ZbMmi9OQeURtQl4MGdJK3D363sXI54P504YVCa05qJ/iTObNADDzd3SoSJFgHPUCdIobTuUDcnOutHPNrdnIjyRgPd7sZT8T5oQPfeQaCw6F2tkuWoyv9IUU1bbkHpjDUEJLJGjzw9fqs98icNagNAZsquFoDdmt5z/FyBPcGUMIUUKuEMe4pniaZwugQ0K0IdJ2kSKIRrGj0HRhoYPMmSNIlzcOzQY9eAEzyXrzo3wphkuoDmYVRgNCwSrAJc5AwmafoHv3e/K+AJqafpP6lU54hTNNXjlDXtkKdrxpMCUMR65CMNn0uI+JyMANRh4mS4ozlIeZN5yK0ZJCUOmvIojYmG3mUg5UyZEwd57rL7JWsguryCQfSCiPAE6L9siRYJJiRwhBfGZIMFSTiPtmAlnvxRrW5EcciQAkqeVXKEBLeU3+FNKef2I61BjPXDM1CQNJ4BVIFegmlHyHCOj4wLJ2B6Egrt7r1pV+CEwHOXsVvXIBLdDKCJ2daUpFg2YxWJip6TQ2MXMhTp1wEHuKo9SvCGGwGfIeJOLC2pV9PgKYdWfPgU0sjuBAqiJXMuiiZRRiYiyVDGuX/g1Lg5Qp5yZboBRI6dI14mqYEo/Dk2tsvY1Irl+OWVlZWLyUjciG1rctdQmfNTlxI/nkLpvTKcIh6f6vzMn9WR4aHw5RzpadTkyRbxTqg54Mv5qHv0PJjxLqBUeBO90yRQQ2mdqqRxO8YPDZIcNOlL68hTV8b7mDl0bJdDd9ChIPogTUS5EfPHbYpQQeSpIVUwSZE39pGqVujQ5NYYTZjjgXMOBzDiA+44KLAkZcQrwxtPWRQ4PScpxS8Z0uBZBBowyzhJM4CGP0eM6DgFj8qgDSMa9TskkOzRjbl2Gb18zR26cGc9yIVFt1XZoNWi6jkZGUkcqCjpa46vyZthUHOoVaBmU0PbajXrLbtXMqLB8bcIszyGRsBLKegV76w+FevCyURURKkKfpxJ3d0plOgIkkqDph0Kc4owreHs7cUgumxD6MryCtI8GKkYVZ1TUtDWjaNk46/XZNKaiiYV9D5mZoNWyqoBI5jSjqzm7b7VzIEe/1+DpoASp9LR5VEvCSl4QoXBc9oOKuHcP1XwIdCkOzkfEkj4s2GORFMXqR1xzlP+RFq6YWUZFgXQtXP/MymxC6Txs67R08+IdnKl0c1lpPKfPOtG0wKd+cjuAJUsNedNCnNKUS4RZrFgWjp9LdeeU9mfwRMcw6J55LSGEzTBs9EolkgR7DzE03oVoJln36kLa4z4leX7hUoGRRc8t5g1Sy5NHKUYS8lTBetWnlUgFEQAVW6in7tjQzhFVINnAD26NHourhVn7cGT5kyZiCylccIcpyk92g3oqHCWJkS4ACM69NbGWIGiYOodA8/e3tFjWTVBx9NFdqY6qIgyaDtOdH5Rhc+CycSCXpnIZDVPnqNWukDZlMndqQEUv1KEGTxZKwklu1K9tJRyOwfPxeWYFmWYkmgWgn1/RDh8CaIe5SE35ghNOWhIB8OmoMlQx6FwN/X19e5+ieWkBYyiD1Zjpk6D1ra6MhPFWVKKd2KMqkkOJdDgGZkPDJnjk4v/c8DGWQr0QrCzN56LTESS81S0a8YOY8bYGTAZ7YhxKtecsSqnhI4LYEo0Jjp4UzQV7vBnb98ut9KfAHpXLQ2SmpCXzdKjQ1RdMZP3ql5yeyriFcJbeNbaPczijruLtf+sqjCgObMxszUN6OnLV955Ongenkqlg8UzAh0dFUiBERJUy+l+ujh6joppFEjuTcLEmTRWRNprQPuQlbyyv7MlY3C0i7l8SPZMl3BnsmgADYfSfNneofrZBL2lFGMnVbz3WJfAMPnSiJ7+/v0rxSVk+TO8WQr28Ci8uT8qd/BE73koGZTpiCudjUIGItMA6VR3AU6JDu2DTthhPBH1V01GAvcU/R8w4z848hEOudHNGVCBcjuetQc2eoQwR3ZwVFehSFN5SGIZT115/wKHTdJEXj98p6chnBo7Y9pOkjiY2KkR4GS8Gz4rO3FzaMN82Wg0BsBTQEc9pdvpvlQbDHfiJM+hQy9fRlaC1i6oSJGUSmIYyp9bi6ZQLTsUVJBn5LOSejaPr+VBuagYQdPd6TElOl1zzJhorl18bPjTVkB2erRH3Tmv1K7BM08xuSRnzgREqsEGkKOJ58DAAO3JUGc6h+zOSQ4SJU5vPoT27vPM5XAoB9Ene4pEa1sDMjutbKYiS5lTVVNem9pad9ULJg9VtsphgmBU8TjTU44V5nYTqyTwzFXnevfACe3tNEdsXQ4889jJx0QNamR38cz5x07B5A1w5roTvaj2ppDvvYZJCWLdVJp6bkGaLwEDLdblw59kS5rbTmGLKCvbSaGOYykNnDEpWlzwGZE1c+bh1x2ch8519yfaOnECJjqldRZJ5k+cdCdTEe3p8T4wMtAwekKpMXQs0STQMKlyPGD2oQNQ47mwfHERKHFstajUPYgKpkDKo9tj2ibQt/enlCbsqey8brH4MHNqcWeiSZh5AWR+HsEOknTnuLJQKMPUuvHAQIPnqObrOdQh1ErGEQfDnDJ7orKHR8lz6FQUoXToXfXSalOMoZHYyxkpnh6JqGHsRrk12oOnFg+250mYCWj25uKSL3leZziJkmkd/ozBk86c17Bphfw4ranemGrtw0yZor2BcB+g8lzdaZJhZCN60sQsL39CffswK+0AT9VNEfE1tG0W7LvSPPAp0jXsduk/f9aplmhuw/TopBTo8Xj4cPCEN31BSTyLC3Q0JoRQB1M4k6eTpJJHhXLUchH6gVGzp6xpNDNaEiVE4gVDI+k8keOVkgB092MR7gb0zMkYJQ3Qf5dNwTSG0K3Dg3BtQ6r6QDOFOs6MNSZi7Io89XTDRJo4r0OVBJHn6sEHL5Knxs1ZHOIJ7YfGaKdgS7pTWT0RBVDkJbfnKBlaly3KAZTRztMomjh/V4Jn2bTPPvvscvuKjaI47pedDFQsiIaLeFtUmWP3CCH+W/+s9sLrheE4mdibOJNn0EQHlXaCnC6YdoLokddlb5Ln/vsbTWkc1qRwjTQUsiTEipNjp5tTRKmwJ+PdZD1NSvVi/LQeDh3apy+n+SdjfLOhUIYpQinYs3ss0Ml7stavbh0Bqg982Sr+myJYlngGSmlRRfzpsdy5CsGf00mzs25OidbE6UQb404SVJ0k8jngsni3fDQ4QJAkKYuqhs8YNWwKKK+ekhzo0NDeC75mv+NqIWTEQ9kz2w+HHtkhOcwv+ie6gW5+fXYXz4L3q+orquGFk7nI3Kk50emo4S3SD1ylDr/OSM7j3Ht+dn52FvYUTEOp+TrEngHOrA5DGtIBm2OabPRMykX84K5cn0NTPZ+JgiJP0RxCQ8gPISuBpgG9rZqCz8vycN82c/rgEG4s8P3v5N665YWWStz4m12qVgrbFpSHijN2xDu9SXdOrR5+OiaYcOb6tOGczwYlScpv4E4Fe66VWCI15E7N2CFcQ4ZROCWDyC6bE41Fkzl09x2sQxd2pLpJI6iGMmuhYJyIFHO1NjHFultZZLX59cVatSohTH+XRWylHOyiaUCZiU53nNTU+vqR4Amtz8Kas2Q5j4OCQfdn/c7GaSbtKYEmmsmDflCdErxw2uHWlOROwcxA97GkBKC9ty4DJxx6Tqs49SS1rVyEK2j4PWEE/m4/OzLr689+zRQfSkWsNRP2kJUreJnTcHIB5OgCTfKcBU7QDG+KpmJ+BOr3XCRvJpyJ6CBSkThG9QmE0q67IuIdJ61pRCPUoT47idOADh0Mg4LnjuXJ0tRTy5GcgxZBlpZ/y24OlX6p1mzddTwXsDaqm9+fXc0oxTJQNm0Fv1LEGUPn4oFU4jk1tbq6Dh159LrBRLe3slFGmtc6+/vRCyiZSvQmDmj3AYpZSe6Mkn5XRXsvvclGh/YRKUWkNoQecMABp8Ke4LljZaMnHFoFVfGUMUsGjEI0yMU4kMumZnsDardanbY9Vn6h1Xz263bKPzUeJFlr6oGnPX9nyVl6yG5ymgeD56pk9pxeWqI7AXLvabpTPMe53OmRjmbJHT15AqHs6eE+6hGOO+u5/IHtNQMp2C0paZqZUroZlFGeI76POPvo0AMOPZYRv2PhyZ7wnRkLFzIK5TjXuSVNxef265uvv765CZ6tdntj0+ZeD1xd3fj+gYyzyo0h0JxQVr1eipETpynRxOk8p3CsU0cfOU2Bp4e7NQ2fyuy57vSUhCZ3eryPJmuyRblEmKC5KxOSaMqaNjEiTaHE+NmrAXSfA4YOeObyBTr02ItjnNT0J9y2Zd1XN4GxXKt3rgbMzkanjT0LOI3WxtcdGLRl/4gHuUU4n8jjYzY8I52zdYeZcVJHuzfBlCt0py/CnKA5vT/TkWByHZ4o7ZBgz0RzFGwpj/jgqTD3cbO4fswGkhKXkyHNN8Fzn316hziEWsj33Y6yyYheXU1I3C0K8KCpvmTLuBFvqrp5y2an3aw12+1//mkDaK3aevZZjKAPsMTFaAlxyw1lOdD9SXsGTizNBc9jVsFzyo51hvv6dYevW9m5NR1pbkSL0pYs5RXpqpZwcY7qPf/kMimdKcmnoRM9UeKUiHOfoV4EPHDi3OfWhZUdBvQuAlU85mgPowprqa4Uyu4SqLmBvtbq/PXnn3/9w93xzY3vO/UXvu9UmybfUYfeBK6aW1W0lTuJML2Gt3b01DEgCpYEOrvzQJuyJ5p5AB0vzTV96CTVbEw2HAllhjmALoW5DZ+7IMFHsAOhd+LIYGc5b0hpUCDFceoOZqVjz5wrLNiTmRReLf4QKnszHjLVNprV2sbfH7741u+vfvlXq9Zut9rPvkCDypRwJ3yZ/Sme8XwdSR1pnYudx2DCvkqeoKnBE1Xn9M6DgbM0cE4AJVkir2sETcE+0CBPYkTH3qRroYrH6W1XahfQ9Sw0hrPXueZEBI6e3lHSG9chA2pZCUCjblJqL6EjuWzabfeP9Bgk8Ku1v3znjEMOOuigfa///O9mqzPZ2vxuo4YUT5jimFrdPG3/+qKer/vISXsec+AxxxyDYAdR8DSaswQ6Pb0T03fEe/gzNC41FPC4KCul/C6qkGiyiyV5Fu/mVciAGlI5VANnFEtCO2Q8D0BWOoBZaQe00K5I286NYs64tZgEKVWTndffvvD6owznURc+9t737Va92Xrg6/rGD7ek3+Gvi2uH/nSeKQ8p1gFzFTxZKR0NmjhncWI5ae+dBxtLNHYe61qsc4fGyqdARiJSHlKPYEcTUGh3HzQJclevktT3WuXpT48SVPqTFRNOVk0A+tLtCwz5hfu34amYRxNDXmITU50ccc6BHEbIk0987cT7LjzuwvtOfO299z5k/un8cHz9pB/a3BAultLxdY3Xi5SzDKCcZWLWfjR8+RBg+jm/DJ6zdsY8M5VLKSHFsic1rMLTqYopu6wB+DH2fu2Ko6QYP1HT8+r1EsA60z4B7btGDj2+O4XHnFvzJqlKaXJDlqzMW63JyXar9vGJjz122GF33/3YY4+d+EanRaC3fFc7/oNbyJ0JKYJe8yzyVKBnmk7UUvvS+upDQDltOIERPA0ng508J3BQKcHjUICHhHKvkYG9wBInjkjvgLmrtIv3OOTMXl7sqhA3e8qi9CiyEvxJntC9O5zo1d1AnWVQjL3ewoIGjgB5bufcc89tMX93bvnuqXfOP+Lud376csOq0DrU+f7i2tfndWp1CSCdZy4byJMiTDtMvp60vrTK1O5zdvBcBdRCQrI2YSgFkzRVKKEfJkrv9nJzRumpqCdVE3pgJFDISDLIt0g4PegxgFpLQE9AHQqkx96VC9FQrF/E20LOBfTMkue22+dOtpqOGF2rg5Teeb0DkNyGzN984Ifm5nkvVEEyn9orLlkqWkzWTLlIPNfXl6aZjWZxiqcknHTmxMSEkPaPQMPDnokM5F64EVOYkyJGXYInJZZ0Jy/yZsbaF0B3sXykgGfJxEr0JjjUPHrOZCTxyNwUWZjmcGLabaaEJifnaDSVQigpW602QCMP+WY8/2vt7x6off9hWwZtEnyJpxnT4/0Lxjqz0aokfxpT1vFr69arkjeOwIm+HzdAypWQ8eH+4f5+ADWWGkWVjfaCBJQXKMzpIkXL7/kZh3KRUIopWHpHpvBndujYJVwRXVjOQA2m3jr0/3iypODJzuSkebJqh3DiLg2lLUCFM3scKI+LP25vvvoCPE7msmg1eOa9XrKnaB4zZTgxfsqfbPNXoVHgOL//xPyED6GQKlDIcBbTOyJ9BCAJdGBGJlUmYjVPmoOOEzfuTi9AXV41KbcLqrY2gKjzZFlvGkpAz81rncJhEkmGNzw5x82csecmySBZ+mljtQ60/cGUB3fruxdqX37Qrqa3kTg2FPb3lVP7asmd8GeyJ0Se856NwBIgeY6j7zeT+hgKmMP9Vs4LKEiSYcO8OeMwcUoAaikJncZPSE4dC5So6hn4TtJueef5HdIAKt0Amph9Lj8pnhwwuU07kURpPmf1jaQ9oegzU2OFnNRqWelE5jYYMAO9/mqn893FxpOfyZPb8lwW6ovWwZyS2VNLdEeSJmskQ3kVmmp5yKxJnhMIerMnGvp+ODQ92wRMuJIX2lPeZAPIpJzXecXZu6usqcxkUtBr5sm+N+cj8MxIT+UgirqJES8QZHnuJEmW6/lqvCOb4zr5mTzrPmCoSGp9/2X1gQeaAEqJaPgT3sQRyahgT/hzltEuzd9ZnrtPuOjPfgv5YcBkGx4ZRmtAGDWBlAUTkRKowFozZ7JoCoui4wUHsxEkoGk5RFeOnvhoKgI9FLN508U2fM61a8zfLZitWskKmmp0YGQk5Z8m/jIN2kPKRnTjzY36xR3uqKdJiTN4EiglnE50HWK8k6dEniqXwNGa1G8Hx9AJQzq81179w6yajCZwmk8N5kyeIpmiCFXIj9nwaVwNo90yynGfCXI1BBDRrDOUTPIuAR07doE629Yq+TKGT4O636OpqL7Pg2gKa2sppA0oftO27bpxv/++p70Bu0pEH/kIQI3nFzToatGf4pmAzsOfmmhCyZrzACig4MloxwF37jVsWYj9MFzq0d5AA0XjOiiRo4QJJ0SHltaXZEhBxaGfuDmtQ81UJDp0+8KKHApq4gcgXc+PwqSi6a1pkCLfICVVuYgs1puvbvS0AJfS+7HF8VP+pDUpsHSg5AmJ5/pVwonE7uY0rBbsaKRJoIQ53A+OEEAmMchVhgqknbIpF+1KMBXqwVGhTn40K260RYzz+D4cIjp0wwLT/G1zFYk8YoGeoIs40SnefTopmpqMeuHlg2vzhe9xiyd1BtsVLywh2mO6CaI4Itxnj3SctOUsear4LIY6O7EcH6b6jabxRO8ix5CnJOQkXNETbRKjnJIbdwE1dMLJ1sdNNwx+S/Nm1JyXcDDN06HntAIo1L1/WQJNJXFKnHQhOD5EYZDbskingr9gnPkzKHgq3nN+N5h+gOWSrOmz9vU1pSOLc42eivXQsBpQ4oBZQZZFk8w5Y6dGTs44DSiJBs8oOnHugz6sqXDXreomQu2FRbW+TF1qaR4unSwArcUzTEk3VTsojqGKeKAkVAKlQT3Ab7naH8oxwTnPnuxPJiSlIzSitM7GzSMj2gF0ddlQzgMmIYol4z2Qsp4HRpzMSgQLoIr0GV6IEmesiHin/O4GVUoH0F0EEKJLU5d+gNknUpOvMOfS6ZRDj2XIr/ibC0opsRFnK1PS5ACaanqvXFE3iWcVMHF0LuZIDJyW0owxeVrLsU6YDHcS9RW6RTemddAxy+ZNnCb24kqOE90OxYST2WjAHGrFqIiikWXRmPgAX+Jey3UkiQ7cgBZWJFKiY+S7a9WgPk9LCnmVTn2XOND7s0HrVQHMST65NXYn0IRpws74JrCq/MmEv9H0v25AqyV/ptIzSiXak57E+ClziudOwkQTzCBKmiGY05oHexpFB4qambFAlz8L63RsYU+lozCrroZX8n31LOwR832FLH/K0DX24NPfXMCpDSP12L0ZinhPq5sQh05+xMVDnMugc+0OgPZU5+yFT68EEk8fPeXNyEUqO48kSgnxPiF7BsUEUiYtMc2CNxHxPGhSthks0Q/QnBJZsvUW4110CVdMeRdPkK3jaRGfiVL3LtChZ0cOwrvsPVtel41FqMjwLvdnzQxKnlre23iBAd/EDz1HxfgJxURTOGlO6OhjmIvE9Jg7D2TAO0gDqlbGqSLUTpVNWLxT5dRAlxw6oGl7rNiV/NnFNSV8BbzAKiHRpIBpXaw2neJLoisAqkfzIAIe/jqtOHYXTpHixdOzvYAy3LHM17oFADGc4p+1n1hmEs8vNHbKnRw6c1K/8mjl8/nZA0+/6v0LnrxqaaqY19nJpWphTvYYOCkGvOOMkFcNCo6CaTxBTne4l12TSDOGAqV6lfacNPGRUiHkT8Hk015Lvq0ebwrXlI8EMrJ9vJAUTK3RoTJoDTN6LJV2KuDZrvVEfnfTF6eZBDqbeUJPrli/fuTag/dfcC705J133nmdSKqTWUMT4VDmJCPKiCfKhhlTVdMMiM7MyJgR8qGuj2NaH7Fc5GwpATW2MCeX7yAAdd1zuX/1yFzeMKckL5h2loBqmiRbxpqHdi4h2rF/r2k8N+0v+hcIpqkXUAqoKa/OCehHa4s773zw/nMvgIzn8eC5Vqo7/cbUzZX1vDkz0WTAswolTpCcGUCb4aJnsZwPlsQsa8ZeO4W9GgtRL+r7OJvHZ2OaLYolUXtv/pxJ5fh66Y1ZKi+MBM8Ie/VV8URs9zC+JWawqD+LNFdTJppnel9au58g2dgZz+WJboUrhxXpnHH61H0vJSOTqiZW9SjqwZKJ3lJ9YjlYzPThV9wIZ+wGjdUmnMDoK/csQy0zsbRnyB9wq0X8jpMcaJ29KBYSvXhKJZoUvFjTc2ZmNMnrpcw3ZSIijacbizuvPN5ghgj0+Kuucn/OR7SroidJBTpkROVQ5qFcMc147w3hDoGpcxwkUWJE8zM2fbOXItr5YD5k+QhovX6KJ5/2VvIOvAqSlSkWtiHrjG9viGfy5FlFOjeqzRLPWmmBiQ/fcDyU4/3Ao9cefJL47r/fOjsS2uPxHafL4Usx7SqRtBDiV5pS/kwxbzBjCdRHUq2PlGbyuOEWZVLlXdT6QpkoenLS/iZOlfqUmejQU/a2kF8oPpqP8VNApVi3A0paVFSNZ40FApiXvlqkOIHXRjrfB3LMkct3PMnYJk7Tk2iS+3NtOWCW493jHAqkum3E4ImGa2kpFFeWogBogkWTjKVcqmjXWok6MQXEkkN9fz2OGEVPeQZv1wBoPJpXvEtR1rtUz7PpBPK5mi2nciU1FgXkX302nObPA49E4okIN5JPPmntI5wQLvj8vn0Hb3kVmRGuThVn/17DOBX1IdwPzDSwBEqzIu493cejePTF9VDbioMePLlxROkJjcVSNip6WjOmS4YUAs9eXxdVmgdR1U1S7BAjSrWaqiZ0FN1KhNWeegtIizxbwpl+wm10S4rwoOk8QfGj999//0ETrh89+SC+p2slr9ARaHnkDCkjoRPMrAG3q7Hs2q1s3a6kqn304Fkum7qqUXKNWSiphmH38WU9IPU1Zn49zp0qRHmU38eML22JyolkuYOuYgE/WSfxcHm7o++o1ezryOUr30c9FDEulIDpKO+48sorn7vWdOUd7+O7dzF+Gsf9nWRg7JcnWcTb1WmKJO60sKzpfMPnSvHaB5h6E1nTWCpKxwIm2arop0Xtc371QyOoeuNZqO7tFcUF/+qRre9vlV+gYR/m9Gq+2sJO+fg6bKr5uhKW7I6yMlCWWD54xx0k+cQTZ938yLuPPvrwRRc9//gSvlSqP9JRIO12ppPUla7kZwEFSDyuI9PYzMgWMBuj+8WqqFxJeryVuEHUxDwvsGFaPlKOrHQvp0p8NN/95lZMPJXpkzOVmdBrpPT3CrM223VKb4iUc4+PlRbgdySU7z768OOf/fjLb3/8fBD0xydL4Lll4aMIVNg4ksYPuWMEP2GFjxZ7l+1g9GtruGy6++DIVGkjTjhTt6HiZCncmd/1RMhr8nnTDr5D+2SxZgq2olksQtl4SpzH055Sc8PnT/oYNMmSEU6W5kpD+eknX/3280H7Urvt9vNvn8zGalKMm2BofViToc8mx6aVZeHNoj01E91v5XBfF2UvnoE0oPJD/hxP7sS1j1emJiZ6ZiVP88eytPe6KQK96w3ZzBMS07rfgicjPgxau6BVK4yf3SifI8qz3n334Yue//GXr8yVu+2LY7fdDvrjt0++ffllA5MKJLQYP3kGUlKV+EvoYxAYSdY0cfMIPyzf6vtyBslzGuHuUybmdfbBFbFPipIWm1k/Aahv0MEdS3vgdJ6YfAIo0nyRp4DGVludgqqvCKX4FAThHmq/fnHdmVcMaoHllWTJCCdKd6VQfvXLp99++80MYIQzeeIIngERl7hGNcV78+m4NoLHxhwcjam9fS2KBt1vGp2X9ZJ4ZsU2EnbuTQX6kFf4riEXJ583sLK/qw54EfQB14mGoryPiC8CreKVL/55k18RnJJ4Rvn4859+8htcuS9owpcH/UyUppdnOCyWxk1KoHgES31USdq/l5A3KCYjbMrhmBnaf9zXnJ3n3uhmBhNGXulOnsz0RCqgdGTsftAiCZrrgJyWTuUrn+fUhVASVSnvwYnh0++r3QbF9LPNt+WwWI8sT1si8Xje+dTGSspIIsBJ8ptvvpmZeRk4ZbAixglNixK56NPv8hIjLL9lwIgi5nGM8DMvvOsHaFskAdG99xu0WZMX9WkAVev1a4yZxJg+etWEnhvDw6BeiiIrGdCFya04ofJ7M6rtXfoAgxa/WKBTafEPbJ26Wcko4co/DiFJNKD8ylC+7Joxa4JIjJ2h4QkCo3jNeT1I09bWrMM7IJ7BYNph2/IU7yHjYoWV5qLTI6icZE4NoxTB8j0vHJT2MqvCj2LU76h9+HKi6qa+Swj0AuILyZ9SfH11xD3VUy9thNqs61vYsY2kVnn30YtSgDPG3ZVCSRB2RvwSpngK44Q86BHPa6g/8n3OXQ6dGsetAR3J28K5hsfF+4NZfuKUiLI8XOZbulNXk2jyETKUXwNRWtrzmpUVbLR/MmiSYCBVYgqBbrwTgu1Q/gbyBcff1ulgcwNVx/S+8okKS5C0oRIoCfLlYTufFhChkzd1hvRbcq8QFok2YkBlVSCJPut6uBInpvWQRfnM4MDBu/rwSU86y1gYTUW70xRkw6iTLy/kcCfSQlbCILrDXvm8OICm9BRSivcu42SrdY4/+/iLz968oHNbq76RXg9vzfVUDCUDnCgpUIy8nf+704TIdzCMB02xDgMrzcvUwuuWFHH9Jpq/U5NWnLhe7yfwHa70I4yyKAGKolpEeM7x5Il+iHfOk0BZirK05xuft9WIMpT9ySsx0Zxl1b6+pc0BFhBbc82Kftqqgacl8G8No2n46f6n5T71Wkeynl23JtLVADVIi4oqylqMBkAbS3naJyacg1h6moE10SDwhHqjaOdVQ6XEJ0laAPX63S7eCzKa4wyHOtA+vlF3UksUu4E60S6/qkc2x6XZsVLp9ValmeatzWbll28/A0rKJ+W4+MpRl9yYmhrlvISrxORCZHK1PJsdrjQl2b6RYX/6AVfSnMZxoFAXHR7JHFQV3ngaF3N0RDQhBtFYGNVUHiTzt2BpGD0glfa3LoDoimbz5RU8Nfbsyg7dqFU3vtvjitMee+eVDZSgLTTWsZMVwRTNwKhN3bjGNuT9kT60ZTbcGULq1o0uTjFKKC0t2WUGVqQxLZE3AFMaYFx7m+JF+YaNF9HUxqXYMxKpiYfsKphctNfLdDhF9N4F0/1lg5ZAVnTN0teBtj9+77XzX3vn17e+q9uaiJWhNGjFUF6Gc2LisnmICCUiBUWc7LCjm+/HWFJGmwimiV+QjY5AxXEGHQWe1sTRYlxyf3oe31tVZRK3McVHQY4bPQIlzgh3w+m3dKdKUa2PXGqD6MrZDq7oTxyyaLov6+q333nvvbc/frbDP7AH0PpG4Msum71sNsTdXxBZ8tAL7uj6rbNPuHObovEuFHDtMOlCiOSIThRx8MFRugfJgVjo6J0WpZI7C4tJsaIcpuXRlxkrFcGWurFTOJnmbzwWS8x8CiJiciGb8P73N4yh3JRhXRdUebGNNeuraKagKqChcV3Y+D02E5B8iuYMdXqXi89w5VaJIzpyHESfkE2Xt3orvPXHOkVSfKmMXu4sSTxZiu55CrTn7StYY76zVl5VllX/Vz3VAB1aBUa0wl6GdTMpNQt4gVXunF2c93e3iAxWFVJcDGEEuHWiqbgui+6M6Q9D/BvEewY6RSiSblOpGQDlxHAqWszihVDqyvEHkCi/E+ucuRzrUBhTjINzKOEvZ7P0bUBT6zjAk19YlV7Knt+b3+5ZNOjE9IOI/LQdZFggQVilEfqyKX2Q3KuEEfqGo6boRVnZ4J23KfkT304ZUAUsYY0MJOkjUaoDwQJW8mSHQnRPlvYGdHlSVdJ2btz6qVrNPOOnq1OmVRzGc3rdaNrbxGDJL/GVORXp0PzRdtGomRL6iP0gRks9vcQlsk5ZhtLaDN0ZBfoIUfjng63XJ3Xp07ZvyNupqtNDHmIXREETRw56K+1tD97KBW7DDIfddt87ooWT9jnv3x9z+RrawVNZgDk1TREov7KbRRMuGjatTftFNPWdNnZgIk6Y2qSEw3yZ9oIUMngkdTqUQFXuNISLPEvRK6ZUiWmfezUyEmFSQikJZsbJC4P+X7rONCaPIozjHgTjSdVCLShaAlqURMWjVSmplUTxjVaaUNtKFOMRFEqKAW0iaSxYVKBpNSJaaoEEg1KrUeNBtF7xin6wauOFdz2jMX7xu7/n2H26b+J/Z56Zlxe1/vqfmd3ZndmpVQ0A7QtkXsnuNxRfBPbZ6Rqiq4K8OOQ0y0kus6ex9Ao8DR8wpZGnb5PwOWE9MTKY3sYhCdDElP4T6i5g6mFj+gkBCp5uvUCYEE61gOT3N8K8emfO3KlI3yGrOQ0hJUodyuyIjErsd9vslMKX2fsgWst2rt3ThcFzAINmaIYcpyqGefcnONWWsrMFpe0NBMpknjhZfuDePIrClVbsfh3sZcmhy3hCxe0KT/NuLIL3MnVpkBakhtCvOclTqUOnlCUhVcyOLFyIQ0u2rUS9iTszo3x6JU89f6vGTqaowp89h2Z4ciQGPYsoQMvTzWeTFl9VrQQ1wFNCumWABB2CqCJDyiQ70Um6PzHvCeXl8m6A6vJTIJoukTklOkJ4UoBU96+ze8N4MRhGDxAn9gt8abyDJJBDUFSyWaRCtHGdbBg+dphfGgW8mAoNmt7iiWNjFcGzAIM6y/Bo/uvLYscV2RBdeBpJm1vXhAIpIuLJWFboMKOpS1E8VX7xCjYNLz9hwdFHc6bEof1nnMJf4K1bYnSjQteit38gEsGmrszwoz4VLCWHPR2lBiSjUqvsaB+zIL4Vni9jCMR5m1+GBiYq4JlVvH+HZFvLs7e8bdNPQvCMt3FQEBSk8IwVxNBEkNRS1sBB0nzqUx/zyy9ruH/V0p31patjNfEJBJIGxneznn/pAOFHpuckpY+D8cHnmZwnfSYha06IOsthrRIc5zkC9GVZr9RWE1NJ7s5gG3KcWcos9DxkRXXYU2vhTYOpOKvcneiEakGJrBCQyc3fRP6AV5D1Rp+O8ASuM6sXr6DBl1ctsPN5hVp1uHNTnsovHmMAmhs2Gr23bCIKel4D6dHxIXyZrXHSdA5EGxmVli5lR3vnaTAdnAdXkJSQ8uSSqXD6/mXCMOwZL3/ElqBUQRNpv7mYts42YHaLQqM5M9mMkmrIoYKXCFDrBDhktcyx9C3FucPtoRqokaoOIkX/mSrZmfooqvq1BfrLODGKikYkLE/VkqQKklGic9ShXCutRJ2pP52rKcszCIdkeUJhAep8diU+VXsGTZR9Fb69xPkU/GmNnKQbdvNBUbJxd+wDZgZNUj5iwPoulSi93wbRU6jJLLK48gKGdmOp2aJXYhs28lQytAu7g1waCL1GyirbiZYwKsnTDs3plFL4M095uzRapZCxSe7f6UqG7mcbtujQHjADpb4b21/lXA1XfVXuCfF2QgJVgkSUoZdu9ks21HjTF2qrN4mJTj8mHptfEd6UqN0lgewO9q5USyre7OtlBbdNzJEluuJUfpicI6teNqbCs6SxcXQpw3x7gXP0Rp3vxryt7/rQ7MTW9QPz9E4Sh789raK5dWfQJDtLMgIjqhd/wpIEPGeZVqmoFB7SUg+rBmYSR8ignuL33STuNGwoKshbflyhQ3FB+U77AfDq8ali8zFHU5R25Z4qB1AMmgPn0dLkG3PyyNgkYLLn9Nn7IP4eP2FHGqugYAKPRxvsl0BZoGvpSJ3t46uqqxRmGNS8KS0enkoTCUgH6lGwelDGsT+Y4yQipetIwUiyA6eenu7LskB4phOZcepEqRiBZ1nj/C3pGF51OCCdYVrxDLnIyCsvnwNMpCeiJZtx6GRBwlBKAkrfzatc43kbthR544c3Pqr4aGCgIH3rBQUJsqKa2Y7N2DLT4CGJoFSeR1MJRqMXUbgEIV0DWeQszacQpV9wZ0JWn0feopv9mgM3xzJ44ReHKMbwUxVaMXczjGP9Agcrn7M0lZ1CBGMQ5SCZSrDoNhzaUWE005fsg5GY3W29kH1e2D3ouztvZUvLP9gz0H87b09Re9d+99iyxfUpTjtE5c7LGfonr3kiqInpGeAXcqoW5S/AcMKSBMb6BjPkMVWLd64aXFkNMr3RgYyfRmia+DGgFNwUv4CozjeemqzFB8ycAhSkZMPLd0qTYEBtVGqIh0TxoCwyTNp8AXsIVfYMoL4+Ut/EHx9/et2n7/060ZP/IjBT2j/AdHZy1TbaOShNMhDdqAa0bK8jpdDPfqSC55GcC2BPTq/ivJ9gv4/mp29/PgaexdWDD6/YvLR1nEdQH3/88fHB6iOS3QOo6IoiCCpIQ0bNh5xi6zylNj9/Tik9iUc5SAo7O0iGM0dOpKMSb0uePvjF0wAtYDVCj4NERBEfe3p6dF+2zEvmtBLiG4fauXXpwyfUeycKz3JyEPMeNCkIrnoJdmZFAct4PYoyN57+jvL6xSu2PNQ6fn+qx8fuF57l4szYs8rR2NgtX4DTwRaLdVXz6/F43m13DkqTo/QJZf1oRFHq0JJlgw0N7VBAskIRoLKocJ7xBOGAMLRNQVHsuZa+njqfpxW+FKd7a8dOeUmh9KDrrC1nkSaRpN8KQ6UoTJ0rPqXxG0ujWbX40i03L20YBGBoPAniT91xgSylYBWM7lJ1p0VIFoPTzvTn10sX7IsTjGgYlWzQFOo5XjeYLztN4dlYtoOVAlvxJC/l5LEPoi5CYmk2StbJFvjoJMaDrHvZeSL7EERdxrSmuW1HPb4Tf0oJM4OoB0obebEjlZIKwSwNT0R5SvWllz3UMO5WDJDj44PjieRjaxUIAApNK8h4kgxcl7uyeAFBr5iKy5PTfp9tSl1qMqJhxoUlDrTEkhIta7z9CYDKqOQLkuGFCUnGEAnDmh6TtnnnmbcYXEuregioFbOTm5/ApVUcjjPOQVFE5FTJXq+vXrFlWcNgcExkBAdNra0SCfxA2zuuUkeKAqOicpzE+Yfb7AgkbxSc0eTzKTq5oEchBO0nZOPZuHq0pbWhrfIwOAoT4JmvpMnKZrZCERGcaUVcAXglQZtv0dhAE1XOjm9+Ap6Y1IgGUwGZVqInraq+ePOypYP0iKbAmAHZIOLt6fqmbxKLnaoUpGMkkJUewQ8kk8mMR5TGsNy+Pri3dFEBl1NM2UVUGdwyiOZYo9g2UFBgPHWLeUOlOcFi++BIR+r9Z9rgs8Z08yZ7shP9qTz5UffYKnyK6YznKNnBoqOUKCPXxZff/EArGJUkMTia3I+MpUrx+cv27Pn+7rtffOvbb/bNzc3MnLOs3B5EkOGdGkF5pk8g680j8+GCaNFVydZrqRvdi2Qtg1s+x1CZAC2TxQt9oJDDEjJUHvNfrgYnN2Xm+ZJQ/qmUbt2mS0QnJldu07ZsNF9XiGTOHbcsWwpHljGBkewkE4rjihGQ6saHbn7++T3PPXf3vW/9vG/uxx/ledTjTzxRnuvdtfvwxI+6sRo1xamyL+x0CYALyN6o65VatOzrjSWHFNeTAymZhp6vMndoXd3DAG2Oa/i8d1gE47Rtz2MFXfSfARZRDZ5aqCqxuIkBrrP3kW0jhlM4rlo5KBhJIjNlsITjgw+qHY3iZeLGu3HjX3NQVIzH/wnHH3+c27d//6nI4J0KTi3EqPZElymem1l4BME1er0wM6jXk50kZbg0ww50VkUStUpiUFq9jj9uuwILSBpUYVwUU06BUYPVk8EqHiW3/qJTu+TYOq9memylnPMA0OWdpMtBtvKk/isP3PYoaxf3PEej/vbnv+Z+VIwnmhv//nFmbt+H+z80krobiHlQlay8JihBEmp0Xd94NOH6susJ8CyBKK78H7k1w4rpQV2pekZ1q4eXtjWMHZZS0xxWS9u6upcLzkKjLcGxU+QLll4CdNJ3yWZf7OnpZlmbaFklICUZSGH5IJY0jnteoFW/9S6t2jFehBndjcg4OkqVv7s0fOgICbff3ni7BCKBfDQRQ/EVPEUGzS3q5jQFzKhCL/xpZEWNNPmSVQzzNdZ0VWnpPEWK8+2JQtYb901UeHvO39Mt6Xj9dUmSADnZOT0rGL1Zh5IxB4zGEUcma2lf/P2bfdY1Hu9tes4oCj0SSu648ZOA6CBVws1FLU8L3ahA7ceoRpTkEGM0snrIvSmJ4FA5THV1dXfV7aCP6lQ4CSgvghgFzyu/8YutoJkY6OP8SX85jBxSlBWsQ55tbgeiJwIIE0UvCUbn+NkLL+79ef+ccxQv/j0DRZbZHZDHlwRevGRzgQ3UkETarMVZypGkUksGydUksvE1nhi0rLG/rMRgkqLPPIjkcEIykIYMbfAE6F03sux/AFLqLJdzVJR2gV8x8eUHh5gUb59MmBQe7M+UZ+EYxA5yIkdgRL5GXtbYscjuM5Yz7fchRsfpp/d9qCs/2fBfXztTfKxe8R/0ps30aTg/0TGS0UMGRUXqNCW4SgwnuWxdWaACp0Y0vMXrJVPxdVjRyqg5zzIFOrJysGFWKYU1HSSRH7MVeIEiQxaQ/HyACb3KinyP1ijNrd7GU5LjDwZFWRW2V/pGOMoih11zjCwH9p4lz0H6gzxIJ/30IrSemSnDWQxOBvIpYJo31UkyqEhOjIksRmU10gjXEjzqWgcRRFBvIgv9CcNhw/i/KgWjJIJktGTt+sFBzpvwZ2zS5lCpCk1jSPAUwz3bOuhLQRyx+FN4mtyS3j2CUdz47n7DSJveOLd/792f/fvm459/NT39+aDcklocN6HhifyadKQYmCNTC6bQESTlafM9isF6wUYlqgzdk0SCyWASS/gp2FFZf0kjLDVllEvGmeGMC7NmFJpla+1TNHk60VWDg7268j2s5szg44wTyAj0eDkuAZKGjlX5psZYWqt2ipzx2BBz0SVK8bnnX3nzzc+/AmO3vA6jssbU/eyyh+uFJHKao3ZVOjIyAkvEg0YA5RhWntHRCc4yoWQ0AeeK2pIlVpZFTzpiLd+H6rBiLsEo7T2athOEoWX3Jz9BpaV8qU1+yRPMKNQYtpAjDMTEeFm3VeJqU/qFnspKZvWx5/3SrBli3j2wz84b/9m4a2733lv2vPIgGJ1ijaswo+mxpTvm16tG5/fT1EdHi+vhOTUylQqayN3pczxQcW8SgucSKJKpkLzayLeIMJWzoSmR1MyWyZXRCNG0NqT8DKjUS/lAKC2DaF2pEF3S39YxXumjebDUlMg/Bs64tCKn50vcTH7w5upTZ6xrvGNm3zH37nnU2zQcFaQzJKb7OJMkEygqe1u2jQJSmIrqR0cU6LA192HDmcvldDh2/zhOcMHLYQZQRFSo+BMp0pEy+IvCgtaTDieTnaML+c/YFF1u4dq1JX4A07GWqoCKoKk4sWiupaOjMnOzOD7EZZMDnm6vdF/mT6KgwvsXf3jmS1W3nHvNbQ/SpL+ahmHSqCGmB6WJD3mbaCJ9V2Vle8fm/tH+fnCOEASoaJg0PDWcGx4Wmt7WhWZdY527sqvfMAZISo602u848WfCMj1fh55g5N9ORqMSQmtzYVJYcsBSnOkJnCR4nl23vaOjO39CI6wZmVgwrb8XD+OFbPKzphJ1dsu2LZ2V+BBUseGwgIstTKzU6J8Ft6u5Y4cA7QenSYgaTLvn4JfPdUKzzgbwu26gAwt8odVJsVkHpsaSo0cevnGhDfDCUA4kHO1vbJhafy4fKEppusqKJBIUJqFo0dlnn72jo2PCpjI0OryQ46JSMWYOzuKM3zRMhcqqppPbet2djg5lfg2EzpYvNCPzryZqA2PbHx4ZMaLQFOVEjjMdViF5FwlikpfcsOSGG8gJzKeEZOPCqdEbH97Rukpmqk2bAakch50kIAkjw65RGgRK/8PJwENGlMArMqauUo0QXb6ho6350P+XQ3PQ8RSUxqAfuEhIQk3nBO/47e4sTN9ZKVcJDthnTF3uT2/1HKiib+v6Hf3CE6JGEwQla4MmcprC84annrpB9NSSuoXDUyP9MNy8aqXN5XtA4yR4AlRFN0KSjEZHHOIm+885xtSSRSQysmgUvYCw6Ozlz7S19R4WNPJxDtRkvSil8yWrYjI6dr63ChQrJto/muCkCkrSz3KPRWHbXSpqJnUmGZ7+fgwuz+TjRNtr4lKzp44FZSaFKTjFhww3wylBkKFAyP0RPZAhHd9pNpzir8rPIdSGXTlv0l1GkuQKnnJIqBWkSrMuYNLkixYtz7W1dNT8rz/bWtomt/bOdhZCL2Q8JWRXiBomIo0YJEBRzYOY3IrGhoYzfBn+TBxKlqNiHkFz8+T6G6XVMcL61A4wS3JTo+tu3LZjJ3PTDU4KaBZV/NQlTx+QH+BZQ8pWeLrWrVvX32UDDABzBGE41BUM+W5DU21TbWltk/40Gvj/iDZfur6l+SCCWZ4dbW1tLS0ksDZ3J9NS8yCGYgbF2OgXBXLX2SDNA6h8Usx8wZ0p6r5bWRarj/4UvhtxT6VVVPMGxtb3LxwexYPbMOFSuDk4ijw1uFZCEOkM/9VXX30Z2oMuu/qhHYn3Nrz6yI5NKbsmR9jVVdq0Fogiinua1tbW8m1Tltv55yeVfKDLl29vjsaex/Oe97c/0tJmaoFqx2OYteDQX9775L0vn2zuKwQNUAtgpth011sELwMXf0sBXpt27AiloxLMzJ41Fdb0u2cxOLOFzFltHZscHwecE5SkCpgG8AEWVz+Ebr5Z6F0Ov++/v+bue/eeeWDf7hm54EX/rNk4M5wMzGv713U1CUJU2zREFq9uGgKj4qSgUlorv288AybB8J2/SD6VSnXR2YsWLSqqHdrUmzfRFOdP2i0P9294dfv6hCpcO8ba25lrghEgFKGwyUxTkUPZH5mXlXgqhcghZ1zNs829vZPjB9FSeKkBLZCASMaH4kDx36XfX3PLWacdd+aBD+dmdm1c8w8IheEda9Zs3DWz5HYmPsuMnjmRVgyrWvlEix5yn26CoIKUZFl6gVp6zWjt4ARdEd3Apmfu2fDaq7+2dDw2xoYhvFbSd2AMK6Xikj2Hmrx/Hurf8Nr2R9pSCdbpyuytpwCaXeGUyoxrSt0Zt5zGYzgOnglVb8bekNWJz3N75Ptr9767f/fMRgAqv/vuUIAXXsG5KWNWHeqvw46GzZs2JYpSiJUW1QpPpdg0xIFDiXy8qmio9Kqrioquumpo0z1f/Lb+p7cfe7K9r0d3VooVM0TPIorsa2eNZ1NubVOuqcmhYvyue8Da0iFGRY9AtXm6s8a5EbOuzE4AMJJxkDTHnwOSCU+IWusOiAHwecR9umvuPfnAh7t3Pz2za82af+64A5Jrbtp45YWM9WXnLLkLnb2cA91FExR1FSFt5i5nixOLsJ8eXbUmae/gHJJC6W3/6acfWn56bOvEQM+8uFnmvBye1sMlhHzfFDB+TBySG8rx74UmPJusG8ftckHQ9cyGV9e3pGp7bKy5r/KwwFkYDk158iH22ElL+s6eSven3XUXkGbAq8FH+v7uew+c+uHup3dt/Ad+u57effuBvddc+tDV20blDFL+uqUjE62F4vLl4CQiamgRfVtm3ChVkrRgCkwooQmedACbNrz/2vafWt6YbJ/orBT7zSOjPimdXVq6vG7osjq0gnfwfv31l1+j33779ZAh2rvZ0wxqsp6YP/gi/gYDq/SschpQcZhtzuwkXQV9mY2LeLhPtmrlZhPa2mH/IP6U3vB5caDwm8F5G9fsevrp1ecct3jF5Te3jrOxMPMD3d0+Q9DZvHX7M6C6Cpr8gU466bzl57nOOIOwnCRAURG/RYOFGhANYxGDxzMbXvvl1586nux9cqJPTz8q+hSN89FzGT50F/I5cUO8w5xq+AIDbn3jbdEbbzz2ZO9HTz7Z3t7LVQ3/g+29Y5MdHS2HNOWGRF0AHUqBKk3R2WID/sj/0XVuP60VURgnaqLRRDTeqiYqXoImUrQ2xxvHO4pAPQLilXqNSoRK6w1NsBYIGq1Ao0dMERVQFNTUF18sRA0ooKY1khgqD4SQwAmP/gf+1lrT7oLx2zOzpz0c2v76rZnZM1NaG4hFj0nT2t3dqUoPt9NfFX355uQkDyfP8wQ27MrmfCB64kYf/1OU7v/8t4anXqAX/ubr48+64a737vjp42/5w8xMUyEhiBiEXcm+gNNKA9yB2Z1MyO/3+3y+GlQvBSxBWcNdtVW1QZo+zBiCZ0uM/mMdC/w42zX5Jt8Ngcxb7ezs4mthv2wfftmx1JCGoxxvum90B6MKP7BUOfn78OyPi3IsboExPfv75MAAd8NveCqd7u6eT3S29k+MT4yPjh4dHR2taFElE8R60rEkeUBBClDzRPUt58USCxEGVRBVv04xCuBDoDb7oXuj2ruQYfRwwrNb/pMUj99xXevbj3/8txpQ4JEFIYk9VmSVfp8rQF2S72ZuX4yGauBXkt/nF9VWhYghYvjHdB8AhYgwcRMNL2EerPNpd+cdh1tbWw+r+kr9icW7VN487eI3oZdO/0gSE279KPBwB/Cg99FUurtzLBIReqMzMzNPoKOj/U0LU4fHRUePzswcnanAkhIfLRRJUHIUpTgRQD1pmFXGEiviVpP0hL+DFQi89smudo6ucpoW752KU/3turnh9u8vFWxGbr8cTLJLL+uN3xc3cuLScDa3ur5wbHcbEw68eRpXWzYneKmMZ3n4YQF43WHH7zpJR65T6Z8O6JJA4qH1UkLexoHJ32eH+/rgp9aDXjrdyZOEX2p+fBRWT3h6mDzzxAzF0dGhd1NTrYJzlB+BcoU60kZeSbLnT5p4E1QdWCthSsNFDiZz0WPbiyqLhYGXT1CekqwwTeJP4UkiO6JKFYdPvuygaSHSTb9yhyf8WdSbvytBYMgc4vMD39N0fcTvPeL5TxheJwUn5EDaXVTu2N7lnegqOU+t16HsgDeq3juIz9X2neHZn0x9lOL/CE5RRdkINulqnoJFoCbrUimQRZ6UIcG6KwGCFvva96P8XhPtp/I0mKWR2Bja3t5eJFIHwKk87QzOfXq5nUKvp6zlkvfliBH0GDorKkVnR2F4zxDiilSuCW694fIbbpiQseBYdGxsfgJ+uE9idRR/kfYjszpJi/3iNjM0D41PpUZnVo7OPKyz5EWe6s+DF7B6qeWIcihRnyjQEiprxhSsbymXX9/d3h42nl37LQrPjhJQZ80xydvw3BXt7G792DcJTBVfG2ySPqEdgN0dYqCU8itBpCAJPY9l6z3GTi/pJ2699YYrbjr5xEfv52JARhLom7tP+XB0fLw/leyMEKeKc4aj2CZK4XiVERyUY5AK5YdIZ8HZW3VT78JUamVm5eHP2YLBBoyKYGXQXFkVTBLjeouTqWhO4aWyk98fpzwo6XjbahYFpmUnrQ1DsORO46k0xyLwjOymdlTHjh3L5ndmuS4p9kZ9rYcj9AFqRE2GzsFsHQKfuo/L+bv4JtHLHz7rxEefa/jkk1efUngMxJ67+6oLz2KXOivWT1wBLHoNOuLx+flY95jgnDlqpjzqwMGNElE4dh/arLd9xrN86w9/VPCx0XSKd2LwFL333ArxoSZ4QtAMSVMZSAbCtfCzuJaKRy4rXavcUYMoyKb6+rZt6Y0kO5Qk5akUzZteqEdU27jzmNBE6/WoJrfLQEc1rOhgJ0T7IccZ//VP9E/cdcMTN/1wimwNu7ah4ZuvvvoEfl81fP313eeew8f7nniCNWoXtS4+nQhqmI4LT+1oRu2fZ8yDpngchIiLCVuHsRVCt7fifoV5t+QTq1fS89HozCCfsmHXJDyFpvD0+wL+sgAOJaJZ/0EHmguVbpiKp02SGXS7r6skcyoyf3oymtIBkHY5YIk24Jnby68WNnbTs7MMWra2I4AcGhKQE7ddftk557LO2dAIuBfEfo33f3XOiR9cdgE0yAh0nsrq5fcmyEAdHW/qTh0VnhGsKHfMfBgvcox5KzCyCmWba0l1HOfrgtbdrFYpz0MrU/CMDjbZMn9FKNYShmcYxwUIZFLSz8nS/0hHLAIVuVDHVL7Qcm610K08PaiO50cCscSSrPZMpSIpCvypQBc2Ntbz+T2Uy+WWRbHEVc9dO9fQ+NUnn7zR+FUDMyBnn/ju5xqF0pqNxju1FynCs1D15MWtRC6FsKSp1PZzZay1nzeqFWmTcjgWi8fQuyRlScHkm4CCFGJ1sK58T8W1ED33UBSeM8Lz7Lo6eDI7EAqFwyF/0B/wq8JkRfo/CvuJdT9Es8t7q+vHdrcWGUcPMJDWUf0kwzh4OqLUjKn505iCUxVBKYYoEuo7QhNFQ3qliJKqWHzwQ17jB3EKpFWT0FmIp1cwR2JwcMaDGHe4wWuN5Tj4Jvr7tQFGrQfUr0gPwxNhS7LMED0kLEsLMHXsrGXtuk45FkX93Omo+vPhpvPrZLNoxbH8ciAUCAnTQDAsooYcO5HVlrK5fGFjB3rDDAAnYVe2IOypHZ6Mhw2np4/KnBmx7HgCdF68ubAuWmUcEQzKVbiHFFH8R/F4ZgWeiWiUEJ5/IrqyIr6bB1xr5DBHJKKdFlJekkxD/f3S/lLqeVw0gVNjScTkUBM45cqbpJttkG1oQNeydO1gkufuPx9/WrzzgyCvkCuFga701s56NL8M1VBoKSRQs7kcDdn6zq4CtOs4txYsi5gDdsNQMljkCqOPJm9xcarP1CUZURjPMaXpSWAiYCrNDceT8S1AuR7HqEDV+ckDSipoIRqNpyNlatVf2RoxaEMumml74Yb6SUMUozMPn8laJ33NufRmrEIzHqArO7tJH8qbGLKNDL2gVLFkXUcxB0ZFajynE9IfJeApQM+vAIkkcPGxutMGfqcbmFV86j5NDiOl+x4w4XnCxfwsQ/htRPO3AXe58BWew8iQWsQrTwiWAY2AE6XmU/PAREKzsF4o5KVJJhyCKIxPMaolEaUTmIEaS8TTY1BUjP1ongMJNR1Y0rLeNPjBz03n917b0PhJAyPQB2Uq+qk3GhuvfXTu4Q+aZE3+IRGTbPI7KQKGs9JoOpzQJAMQ+nMsXM81UJXjbnguRBOJOP5UnsfJ9yXwZ9SZM5iaVHinuY/DGz9kM1UDfbOL2zvMfMk8y+/pRTlLFwxNiGgzlshk4h3D8DQJURVMp4DooSR5sW40o8CMFlbz9drH+T2mUA0SNgROJXyRN7+ZTMR+ZH6Ca+cnHh5kNbju2rlDjY2HGhoaDh1qfOOpp17l1PjGoQZY1J0vzASc6d0PM6GxFZrhWFL5mfNtLak0iSE8zZgu2N2eCpCSrwXstfize154nq046yo6xlKiCBpL65efvjz5skw1i1XFfltA3EBEPgQdvhytFb/FaTAh3YAqZjwdVAeTbDw9ZzqghnOFXyZaja7m2toYgApSgwrVMrJUTHYVkszEFuP3f/XUg2+80dgwN9dbV3me65Td8hGJ6AWR3tQmmcWyZLKJtiITEJ4x1utaApUtZavwJirKkAKeRhLxMA0NnNAc9TnheaycJ69KjDLUn6KL+LHvTa5JBmaxH9aD5eI2ManuS5QpuhLgHiBmMpnBjJGMiWjNO4Y/AiTZAyp5KqItJtkV+rjzSHAqTFWup0eAqksNKmnf4CIcdOI1wzMjFoNcwBmMM4Twmd0wywVIoKKU5pjEHpF4Fp4x7KmGNJUuC0miut7aXnMkBaWAJKnmxJ74M9Ot8U6463jpKGPgeNNzwv+U1JZo8fctGDrPIGdBDlMGoAF+B6/ESJKMZZJnPwZKksEsEhV/Rv4j642EJw+Qz+cTq3l4AlQ8WqMqn+kkawlKfxVTCwDNGc+WgLECoBRWl9IqUtNtH/ojyAZigbGoPO1A5X8ETgHay/IU7lSavQYTmg7pHAnVKU9gsLdFiFYQJee9+wGQDB6n9ck3F7xgxoMwI3viZ2LwjINQMKIWUsDWvyIfmTymfRS0n6kiRS1Mak9zfyavgmeRqGNqPD2rSk3hgjS3vJiJ5WItleASdopMfCb8FKkmh0lvgFuR4k94SrjDrhylN/+jK36Plcl5kwbaZDwXF8AUf8j1R3mUyUgSUa5GJ99ciWZUxpGSukU6WhEtrGfMkSZ9Mfq8x4ymESU7pY2iliWeXrjDM5fL5LkwehGajmeNHGjf5AE1BzjIqqbjqSMAHj9kgWsTPEIYaVMopT1BYluAOn8m4em2LFRVaqvs8XTzk7VGUktO0tcpUFPddFR4RjNNdPDKcy+/lytTPr/++wD+VYBR5ScEOXvhr0zjSW2hTNLrBlFtbYRxAhO0jieFaUppwtBB9XDCU0cGAEXLL74o/kRrEIWpQXVY/ZTIIa0KxpLwXE7aRCNIA4CFjw0B1KSezIRGWXjGQmNRAiypOKsEKKKua3vFad597kQUBhOqGvR3T8fhWTZeMopcKuck5R3BkgQeSVrL2EN1vXOH3njqQQZwLzScT6ulo0N9+jo/xbvqq01NAVRUNKnm4W4IWjLNO57eSMuu2LMvIogqUA+pyE3F6CFnWtLl5Bb/S5tAQIaMqNsp41yqCpbdDBhQeEbgyf8FnxJFZdYUXeOCXBMZiirPoMR7vFN4ZuB5vvDUF5HNSqYWXffwxWJN51fd0nCo8akXXnj2hWeffZBRcHUtbzMrd75ELAZOIkSjBOk0KU8jNeWpDGu3YXRAdahUHu36eLy67NJrwvNFZ1EzqVF1olJyqD+Z3c4tJ7OhoK0UU/AGO56e9FmWr83rxYDypHtnf5c0lmJKWCK1pq5Emy2L2XiSimKDylzvdLxjQfxA+ymqyO5T7PxqGQjLZcQLbzROV9eep1sCQkrNLld4yi3CMxkSVxZlk863XOObn0qzjkphPqV0PKFXZBop740cTxm54PgwPA1ozxpMRc6m+91qVFsC2zmedcieG1CNHocHVUhJncLuw50QpWOPJNSf0ESwpKAEZ63AJFcbT8Xo3CnZTo2U4s9cx4rG+0O4E55L+xUMBWJT32cIZlWI5BTW0pqppC8fwxXIT6Kzta5CNJ/uTqtgSQaoHp3zxrPf4+kZNJHRUWSAB/G95gFFStUEyzYOZVrEGgjt5pLwDIr0zRaVgqZ4S+oa1IrzPIQlAsFIooXRp7aVtUC9hhJB0qm6oaG6WmgedGYjVQf0WnhavJtBHc8/JZmyy7Nv5nOYRVCSlKUoKEk92gLPZDYMTBsSOslLvGYBlN0gpTSeECV1jqN+BWkXRo6m8yc8ky20H7761wHqVGKqXb6VBtapJuDfkYbKhvh2TQo8J61ZsINSkqw+uK4/QHMFT14lPFXF7hyQuFPXcKXZLDWWAGwkSXZUIQzP5Q4MITzt+mjpz5JgSs5m4bmchaYnm8OjCHLCwsZTfAlNzbZ8hBa6UVpNSkVjX7h2jjKZBkqkc0twLXbuJXsGa331PfB8jYzKobaZtLq5+ccfm5uba2sUvmNZ5QkunpvApAkViKAzn1YJTSWKhKftkceZwVSiJUDzCT7haIVwrKagJJklxZt6KE44GlLJc9dOJ8eId4/nn/skLl2efRmeocASHBVmmYxoKAvPQNBXJrd6pDw9pUuh3zG6sjJu1oSnEi0Gu+Ck8QwEb6luG3nt2c+e/Uz0FrrvvmeeeebOO29Ezc18G+gZRVG75AxuvxLeyGYDGu/whGTIGAo9G6ZTIZNElKUuKRkKpzIyPLUAhynJqtWix6qrhaUUihOaYBSgb0ipRv3k0KHHPJ76yUXl+ccf/j/Cf4Qd0qzwXFKSdoj8CJh+sQE8a/JZVps86TARtR3gaQVEO/vH51M2OS+U8a12/X3b7uI/SdxV94y89swZHrTTyRyS9KTiRLrk9OZL3r/kku9CBXAG4CnvNDS1LzKglWSR86a7ZWMm/Mli7jw8Q0ENcJPirPYEzXK5cC9XAzwjxlNnSol3BYr+/IOKMHU8haPh9JM8yVMP1OSyIb9boFMZTbSge2rKmerRyfT4kW5B2O72o3V1ybXodhKP8FhB/Omv6Rl5C3aelJ9B1Royus3N77//fnPzzeHCEjzDfoAqUg15C2wpNJmsIrwRQJsqg/Nx7Bm8hfh2okY2iTWnYejC24P5hiSVzg2OJCNR86eN52dnZ//Zw6AcIvFnWnmGyyUcjab6NKs8DaQDqr0vWmHXghzlMp6tHcqzRBOc8GwRd2H8UFi7traekWcJ9DtvvP4Ss6TicwWHVS+BJ0fzd8KTQVb5PJ5b8CaR5bCKdThm0aoqDIo/42xYroWnHMhYujAHpsrAcToosDK3OjfS4ni68SfeXF1VlBDlAGj65b1lcP6JMTWJfK7kbP4MwNPkYh2gxtNUIvqplp1DrZGxbmL8AM/d0I+zHVuRXdauSu2G9DsvjrwOOENoZakFQES78Lzku/CqtPFBeZ+lCAtQ4JHKVevJgKKWqlp4VhLuwHQsyWZM0/S0MgXmQY6WEf4MEO+ZxKCMlzgq/jCePs5Fg/748l425DnT5GiSeOqhGpaafFA8EOyQiHaUgHIUmaY7WMmBJ0DbSzxlYm+3cnbgoq732qN+f2zrwade38j69Le29cDTYeTkCs1qUHhKvPsLIcRb4Rzqgl3AqRvl5AbpiNIa0arzjKd+4E05epoueVN42WE1F+mU6k3RJw2vhVLwzOj8EktIxpNiE6bqUY+nXw6VTZGZJOjxJy+iOLBWufEM/rQdNWZRsqmTVbHruj/9VHl2KU69tN+tmp385dtb+9ZrfE3bzz57385qTc19N954p2/1Ztdceh716F7i/HmzX/0pK9hBbY1A5znSziYdYLq7UV0d4/iFuDS210DO4hyUCJZkaJIcPyrOlWBUWYX7Gl4LpqIZxxNV4MjC6p+eGIAKT0VpyfkSKVcO/MlwQ0GaNYs0SSsdIqB6YS+5g0Wyw53KEwlO3Sc4vFs7O3nq8L3D6zU1ye0Xnn0LnvW0nne2FT5zXY+j6UjqCX9a+/lZkaeqKogAWgptTXB0W1cZXjqcvfC85ZaFGFXifXpacbYdapsmxlUQVE0LMwdQDw+nlvAMz+/jyei4oO1nkeby3iI8ywPdTTt6qgrWJMP+GiVJplCa0z0Innd0qDykwlR4Pv4pQLs8nkR/6hZ4fvT0cLS+pmXr2Rfe2oDnW3c+43h6/buTi3nXH11S4ulzE/eeOYlzDXpzppZWIdrFnw8ZT3DCUCw67cnrb0ioDOJTnKy0ew697nc89QOnwnOTeHeCKkAXX87Tezu54aWVRtXveApNz55izpGekegRFoUdUCTmlDP+7IcnAqdrPOE5tQvPkz66uq/QVtMi/txQfz7zTA884Yi0dLYsaz9vvASeX/hWZUxn/WWQcA+C0GHUs00YIb1HT8wjsYrheNaqPSHq5GqN5LJ2coTDwbUCmT0/aSzyPE9x9lZw1ba3tymiCVWgy1uMl8SfPo+nyPNoVWV9kv1LQHTmRGJOgI4kxjqOdJCxqRnUqHawl6D1Dvnzs13aGckU80cM6ndr4Dn1gPAMjDEvuLFavwbPO3sKNwtAT1Z3UOnfb2w2niF4+kTwrCLaRUV6wDN7SqhLqqJEvRLvj90yGuOf4XlQIyMKE16UB/WUFZzQq28Iz4T2R8rzWo+nEiX/kRWeS8YTKU5J3nxubbA+GYRnmcycKHF4bOy6MYByYNE7Oh83f7I/o/WOd/bxFO3Wzw50fnR732pbTW5xP09zpZNSLPX3+LNZ492Xx59cCGg/WVsbtIYToiJOytYTdf65twojnV99y0pSJjpx4oiHsnFE5NC5E/T+T682vh5ORY0nQGk/19bWhOfaZv2mlOD9c5fx51LIjZCQMCwXSzf1LX5fvcdymkMkPG3DNUw7IHoHLlWbjgnPI+8AlPbT9UbgTO+0pSfZftweNZ4vGM877xwp3GzkPJ7uZDxPN57+vPnTesta6d8PSrkiq1WRzZ/X1K4k8Wc1dhwhU4BVYRpSaO1D+SCzwoiydBcGPsR4SWfIYqz7s2xd0bO2try3xtqCZbS5Q3+EP5Fv8yBNA1pVH8CetJgqgCLz52uJyGHbgj12ZEwcClKx5xE+ojN0Bx/a7MafupAMTq7jd+rT7Mjrbi/01OR+FJ75+h6ZBenZgKdBdCbFkyR0ffOdTJS88soXr9zHeGkJhWXCDp/aDC2yaTmSKkAtwJnM3gbZDCJ/uKHyvNGMfOJL2wBks08oyI+yiQklm+TDWcXNaHEkM2GDCRV791iWXLkmLp8CsQV2VAGI5T3lwSQuYqKs8HIOnuFSv+6WGTzdUlXfIjyROpM8Ioco0cpWSmFK3KtFEUCvYxvb0BH5FDE81Z3SesKzRnh+OlnAn+k2X3Yrv/bXH0uhP5c3XrxZlz6QNtNkDgZocoUGQ6bpkslwuMAeiMJqFK2rFlQrruQF2g1q4wvjbFwkc6CJwQ8m+rk1OroCGESNHxtd4OCf5ycm5vudUv0TpZrtjoqIDsvri1TGrT3rsM0vFTznpZxxfP31Z599C+XFn960EoWW3oRdKOBnMp379T484bYSoFCUCyGAQlSa0bEjRyzsrxsXnncoT8+e8PTNDrBbTHjmf2eH3u97a38VZPv3+ouvv/biiNA0liYdYbjHxD+hgCA8hmwtJVIub2cPb3FRQ5bZeDfz4VE2PolmyKZRySQRqAW+VeWnSuLNY1euvQ3RyjgwPQnPP5eN5s0367TjZ6un7RQKhXVU8BQtRD3RACdYrC9XXBVLrgwZ0FZtRo+IxKSHeVZD8lHsd/rawan27Ea7Wy/zNf/DA8rzdz5Rtbf5V0E27K3/9Yj50xPtijoUf+pAeTm7FBBjmhuPLcyLUuT+efPSPFnF4IKCU1G0Pg9/ftPnvfEYm8s98ZLJooJkrF+gQPmMLqXnRPLCKfIFtJc7L87L9D7qVAFJ/7LixJ43f8bxSOGEXfmwLLLH8LTieGbiTefxoUmWa7Dm0hLLTFn2jaJQONEPUJHGvBF1PPuvuwOH9nXhTsEpPIff1G8W+B5/+mKHj86M/pjfXAvQWK2uP9J8/fXN1zONzJkTZwo9Nd/4DO3nk6+88uSLoTyf9jfxoQBkNrNiFLlbzoeXF0+Xzxz94PhTv7n+ySdf4dd88SRnsj6A6XR7LH3wG8klcfMRPd353a+/fvH+X5XvHh4SOddXvG48HwEn/uSA52nrGfgnRJzNfpo5qMiOoXcfvPOZ+9565hl6Bp1Df+bG5hvve4WXGpA9q0Mpfjsw0RETPEf/ZeuMQtuqwjheVBD0ocbo7FSUeoWq2FbsWA13mjzY66wp4hqlmlUxhVTdtGpstNBW1zLzMJoJVWe3btbGxkykTxeUOejYZG0oHajUzj7M4ahioIiC7/7/3/eltxv733vPTabLth//73znnpzvdN8jNOjgHs3tgpOLcQm0H/no3MR7PT0rCxd+ymE8n19NSh4KZCN5aTj6HE+Nx/3aWUkTWOMNvbBZUpHFIg+cKPQIfnwbfwoRmru+vfHOr0P4FLK0ixqv3oqgnC0Ws07adbGNacQxmhE3Iy/SqWI5G8/UP7ULqWHS3L+vZmhooHFt4ZzUAJwVLV286YMl5jP+VW2tl5wmWfTzbZfrucDngSYu8vSiBXfcexifzRXBVvunpWrk+fHhyUeFp+KUEreRa6SCEptjjnWCZ0/P2+cXLlwwnvZkFPDEZYJ/5HkzWTt7QKsIUJQxjEXzOHjyxehjo4+JbsF5i+zq+Bg3dpTXaLbc+MA34Xg8hYnpLC6CzCpWmnY8Bfdly+uVihP13GgSSkQihXLZi7hl4eqNZyvF8Uz98/sQetRB3sFTnBntRS5S9S7cM3tA9RYb2xaCp+nA8/VPdbluhJEHkWkCPJMF1/M6DrOvov0hHThJ1R+ib1LMuonnhBWxnvrv8Qnk91ew7mQl4ClutIOv5bx8vi65bVgWfnP3L7SfmA7JdcjEd9hq9NZbb/vkVjS4bsB1y5MPXfo6pDz1MmPqXXn66+VKqOC60XKyXE6HQkXfd8HTCcGv4LlejGditZPas2jdInkSqNJMUMjvSwckY29atEvZMA7jt9r6rcLTUX8m0MKqyazreh0HFSh7FJawPaJd9S70Y/seBU7xp/Weg9dd99VX99z7638/P7SQaTywq6sLPBsv9Nr404bxeld/8oDk+yP6c9tsdeMKrjmmZL9G3lkQGOyIGei2L2+7lpviPvfipa/Dm3jyqCqrPFN+pWI8y8vLiZADnvGI60dCDgyqPFtqJ7XiTgcANdHzi3V9i6vEmTD91Y+SD+phyFYEXbafBOYOyVMyA5XAiZfJlPGUdCppngWCEvKPkide0Z9HIA336x48+ss7b/x66rub38q0VXk2qj+HbDB/JcsreGJlAldsc5j+lIloha6AhXdtS0DsV2k/L+56nK1PXsFTSdrNeK4rz4LypD/hId9xAp4NzYdntOROCmdrelfvaerrX+tVnIJmqf9shy64oGStF6Tzs/o9bCy2ZcDiPaEiz3Ka8S69iQC1kAdF9efkLhT9Po70LukIw+CpB9/g5penjh6ZXwLP/V1vg2dbYy5tPEkxeGq3i0KSFwp+/SzXdunibmFqWNEq1q08WONmjbTguvX6409eOha26CZBDfYg3pGKkHF838m5brqAPO05TkHi3Wf2Z7xXhOdBlpPN/KA/HrFmaLW/KUOegGk623+iWxat46RAMVh0piunWraCZxwSnjnj6YFn7cHNQJnmIYt3IbtnUHCS55433ngHQE999tnz5zJtz+xTnpj/ZLwnJRtJw9MOnMTpxgGA/ecSI+h2WY0IoHJCd+DAzoIkqRsnX7aXshLd+Rp4hkL8nhQsJSc5oc050KnKdUKiCERjRtmSZxn5aFp5vnw9aT70Yk1v02Lb0NpqjjwTxvNDVm7i1FoAWtMmuEXN5El/Ynhm/kyTZ2J5HPm9dkZ5KlDipMjzY+GJeGe0g+fpuVLpC9gTPH/+bYX+7Ona4JlfS4YMJS8qmP2MMydnzZ/cO6leJBt1ytY8fMGNe1WAKQq2AAbdrTufu3QM8/zkmYKEZzADw5tjivDXReAY8IR7yTOm9bSgCYFn/p+h3j/O5izYPfxbTnx4RqqHY/KtkfrSVvBBusZH4h1+TEg/gcv1ssv8zeCJ5zgFuh+yYvVd9yHemZme3hh+TgwOlj59/Sh4vvrq4yt5+rML80udbTnmI/AkugBocDkuR/MkgP5TuiROE5swFxdUtFmRgL5FQSB+SfZkJtmdz117TCf6HX5YMQWelvuuwjNsDg2Rp+OArJfl+DOZj81L2Sh/WC9Ukzu/lhv4JwoipAmeHnnaXHwzmRrORhwqvGm7gzwdmNLiHfk9uxwXnhw9mEGrPNWf4In+81mbDCmNlVBQ9/tHY7/+993jn69s5KO+tl58ZBt42j9MKAZvHPAkABg0lWya7ZAd+gBUicrspsnI6p3v0ZIr6oJBdHvr3cdCtHo8ZCndeCo64xnHmY7oaE3QgmeBN8crFsspJzkdmxkVf+om5DW5gVyOgyXDKTxHurlWDtKpZPWmfU9NKU+P+QhAqbQX97JlZvv6mRnjWQ15zfN4yFN/Cs/SREmEsrCTY0c/2zsFnmdPY5JxVXj25sDTohza8KaBZYAWiwDqN80+XGtTbrYaFs27QMqDDNkE0i1FIfzTydPRcSx5ij/NhgaVNOM4XZd+dCXWXVxJR+Ld99dT8Uw+hsJ5aKts6A6eKjIBUOF5ZoTfXQZfcYAgYbKlhOcO8aeD1Oelc+gpyDPJfNTMeujNKUl57ifPXfTnFHiWYE5cwHl690dLR/YeGVkZaDs7ke/pEZ5QI3kyztkaUDZ877r0E3AKzw76EzFDj1Iv8QXqhiC22NlWpXfud/vaBk+ZlUYu4ucxt3t8P66jJ3y+5veCl8YvZzmej677AFqJE61XLFey45l888yo8pRd8WtyCdI0nMZT/BksWgdHHp2EaVw7yTMeYn733HTOS2CoVPBd8nwBQD+2nASeBnT/ffSn8RRnlrB6aWLiNFZXLB0ZG1kd6ATPfP7Phb7O3hx4/pE0lwQP7lXDesqzqPHegXWOMVWztqwiaAZUIjQRKy8TeU4/d3e7Ew+LP7PMbrj7BfbMUNEHLd+eN5Wn72H8WfFdJ1J2bD5kvVhcztfPSI34ltdk/3HyFDHcTWdGmhovW1pNmqpO9Sd58vmdAHPsP0kVY10MocATe3FYxBOoFUuTJ+fwdj+7pzQ3gXMM+5Vh46j572dnvwDPfOeJUjt5Zjo511UHnobRLm1IGLHgkqf5U5fIxXhZUQYOnHjDyktUY/HACaCCFQc2WJhuJU/KES/iRbHop3x8cLGItlLlmfQS4Fksk+d62Q1FKshHxjOVyTfNACd4olIZQGsSog2eJHTmX8Q7S9RU9KOqTVoaVPwJem4ih1QWTRQQ6n7UQTdaP7qxBYLxFKL052HEPXiirnaOSEuLY3OlTz+dn53dOziymhGe0+Q5hNnDJvI0VwbWlMZJOx7DEePtpPGMESelozoYFKc0xImW1ZeEyQM38mxvvft9pnfy5PA9BWYpH1xhT7+Iwfo6eP69XokUlKfvhsPwZzwc4vO7ozyzmfw28hwd3QJ7HidP8RckPF0cnvaflDA1Z+Iwoox35CMCdTmZ5SLeXfiz4LhevHkUQGcA9LACNaIS7xyMIh9xQ7g5hPxUCRXL+PZ6affYFHg+vLs93752PtM3gGnk7j+SjnnSuJoINM5wJ0+/7hyfjK9cwvlSIMVqIloFi9TUznhHtBMmWtz8IkBKT+LjeVP8+XeFPNFzgjyylZdCzgplZT7E9f2K8JyXWuA7dNsG+lOBmj9h0B+nqmsVFCtpdnYK0jaNeI138uTKwkhCeJYL8KvwhEO5zcTkpkHo/pn7N3iCJnmOoYJ596fzbw6/dfII/Xnmlelp+BM80Y92059XE4Y4XooxyT4vKjxrmwOa1jS8dBXtlNY6UvjzUjvA0JnoO5mQilmNdX6yl/IZ+UDsAkpYZVGSRrpnPvLL2Wwy3/0meB4a3gJ7Hjeeas+A5yJ4UmxbWtqIkzBF08qT4yV2oJj4BEq0XqKccz3ko+FDAGoRbzxpUVh2UuJ9avAigHK8NDIycfqjkx8MH1ia+lDiHQuy1oTnwMC235MyGrwKT/xRRVU2SZ7d6D9jAU+qgUBbxJq8o1DDYLInVYEnxkvM45zt5LxI3HVMsKPNz0MOiIQ3y0kApwOe8GcKPF+mPVFfjH0eWo8bz1w13pVn90a0C9MGxYmLS1LIs29Hnv8nZwoA0/yZdjEwi2HecVQNSp5PaIq/nOec8BybWpzY+9H87HD3uQ2eLcKz7+2eeuGJo6og2jGSqPLUeAdPYViVDUJiFvgoeTG7AmuV6buvtR9HvMOWPjqOeCgMnmGANNnoU75wwT8trNK/SKQQqvqTPGtnRocxp40tIFAcD3/qE3jA0/wZiEEuMHV1pKjz3Tz+Z4eTdG4knYvgNybK6TR6lQbwBFA16CREnriM56PmT9hzEVtr7sViv+G6hcEp8hxsIc9k30BjQ13HRfAMxOeUgCdICk74c0F5GlC7E6iIQFlFBKDbLeiZmaT/BM9j7IiL5BkOp1IgKMSc4PEIOIVnSP8DbcnnzSpPzM8nBzpmpGZ9R2srC46Vpz1sBv40nibrPfE3nf3+5O1Yi9bSV0+ejPeohz8gzSf5ZbQRd/snYtAg4G1u+eMZGX/Cn2PVeF8sTbxCnt1re8dWM30nFpu3t/xJntPtDbdfTAKhiM+YxtMm6xKSjSD4k0U8ZkqeBMlGb2TJE1Bxh4wptON98MSABED9FJI2kntWAt1CwgJeeXIgk3VDDlghXURJ1sZL4Pky/fnWDnSf+ANqAnsSp+jHf7rr4Mq6RlnQiYaiQVe+uvfB/rFaeLSvOU+ccS8SzeWcBFfIZNfTCXSg7ZgUD3pQ4yn+PLiPz5uvgCdwEujU4JzyPD2x50/4c3Hb9hh55hveb6+9mIkDIqVOCapl8BDB9G75iLUMJGn2rLK0+04egpVVWbwk3pE4/ufqTMCaLuM4TkpEWRxlRWmKDCO5AiwIlwwrjrjSQNHwKNDNKw4HKuiIxmIlNk1EmldzJqAcHUIcOkBOYQ+ohIknCkhCmRniU89Tz9P3975/NuvLxkbPE8KH7+/9vfdvrSZ04kER5qmI51PwJxKRaNydIhNOsRjZlhYf2keQ5SuwfiQSnxfGmxgfgadPcjYtsiHc4c8V5vYTnyTpauhwOkYoUJJcKlWzNy7cn8nudLlN2j5b+HNTEhDa488mgScxbheDZwTexoR9zYBmCymegAr+pPVN8qf2OrrxnCf82ZaV6aFdqPxZHlRrjJw9m/H0Dft9BvkzgoGk0xxmg8KeYMBxsv4SruIKNLeaEKfrSzSZRRlNSOBJwoU/ryeEkj/zKN7jEQGUyyNIeZTsgyNYbm8fQX+J+vPivIp2qQg8K4L9/dsf9KcmMjmT+xPfFTz5UTT6pMCLsJhkGjKpD+NV4wIB6VLwnACg619GvIOnGDyliHcR59kdTFHvi5Ub5tDxjEQrH/iAXQWeiHYS+kvF2qU7205odWk5qfVBQU3GXI/Ak71x5xUK9S8vC/HOfcKPcwlbwSKCzTw9u3xeAU+OkD8EMaCCM31JYMo9ynmuXRwGnnmi+Ao0xIC4EdmlAqNMLvSW0P9En/72SEScmPEcCX6KeGJ8VMGmlsWFnCf8mQJtOsrj3UE4UABepUdLjh3FzUQJGqJqqwBQNQGVR3Md4cWP0pRtHnLiCeuLY+LE4Hk4PhjTA9Jgf2mMHss2phb0DWGSSfAn7txFPsLgqJ5aUGNOcf2eE+txhzIezls9a42tDg47qT+vifZwQD4ynUACVDQtchzTiXkKb8WMZiH63EL7GWiypjnezVhDTUBDuVhgLlJ85AWeT+VRYrN/Cj7F3EcFckw7Xts3toNnIedZIUbvJa/9POcZASvTDwR/svwu98nKZDxB08QziOTX03MWuny25CMvr46O6T1rqQ2AMN2j0EOOF60SwdNOedJFHqgHzwh0XeKQhIKp0yRpJzdJXYgngIInj/cQPobn8U48i8GT3Q6c83n9nn1Ucs45FQsfF5qMnR4ON3vjkpLwM/nw/C4ypXd11xDutbzgIIZDhYDPy4M/I3FIRmBIMP9DFAjp8//EmQo8+VQ/lvMpvsGQeFJHaJznCPMnS0/4hOQiIp54D56F1J9PivyAeG6ndITjhzjPde/u3V7qtfuBJUNamjArdqDHdT54MqLAKYv2fMXh8YaGMQKqLI+WrEB+Z2lPHexPPPOkmNnyR+p1CQ9nQCkjwZ8QeEbBn7i7Gftt5r6jA074E+ldWVy/GjQhZxT1a/TUMp5y7HzcsMEXPM0HDDGPdvo6drB9HLu7FR0m5KN4zhPtJ/zJD6uPQzWLw9Sz0xpmnAzo0U2KMK/N2BXBNttEwKZw50ZpTOFIOzQComy8CX+KJcEP9D9Zf17Yb4ORVDx4wp9Y/Pfjp+QturFRMa4rMNAhsOQyBKbgOc0bpV3fCKUlELVCo3fxTFr2/Ay/42OjY0W4Nyytcza2oCdFx4ml6fAuWgRK8PFSdLXyxJrw/wU8j3eBJ7aK1BTTVeRGCDxrOE73xIWp2lfWdzk4DKH9DPLYsCEU7ae5Mx8cIW/cE9VnQFHpclEEjY8Q7xD3pydYmsIdPHky0rvo0zWMqelIsNmfmLnYEPo241mBvBNvnweQFfgtiCeyONjigT8aghDGEWgKPNX2/iwfsfFmEOe5fdMK1q7QfgaZImsGVAKWQrx7O/YMTH3poAybcfDQuLzi4LP3g4K+0bGGIlzEpnvb65nnjgxfw2682dtR3t9UT8sv1Fe/iXgCaLYQ8CEhdOHhJ5znO/BnjfY6bnan4RF4KhHutEPEqaboUG1jZ7QL4l2uD/198bFG5COTgsXqxrlRUYarBsMmrD9Iqc1jT8x/4iJY8uSDRzD1gYEKmYMU0gvRLhzBNAP189twdC145lE/iSY/CwGRdakhEWTqL+EhNa3FIQSRLUSUj2i9g2a40H7SIj9uKaVvbUEry5IsW86TqyTUzbXH1Waa38samWxDwkf66KCk3OLclHmjDWNjB1In7Mx/b+GhRF0TDoGdTsGWAXZF5njtZirLyAwagAyPBB8S8ibb2gCe2K/IeRJOul3dqM3hRT3cUbx7/3lSd3dc0JLlJWc7Jod6xiCX2kOU09X98HhUZVkseMZzb4KnxDPzFSzEjod6ICwpQwMk6lQgtDajR63nJzHNB4M5UFiJeCbYi/Poe2EuRFSIvpFp4P4gT/iTj4/8BQVL8F4YHzGeKXTH2woh3pOCHFrPJdMNHORNelwuPertOjDx4WenUMfK1jchgbJ/uo/LtLEGRLyzZdrNcmfcc3fzzrkzQ20FtBGL5pSEq6+/RvtpakB3I95hUKAAT+z/pHjXUV+Jnrg9X6ukMpPE0znxte5u8JTLJc+2tLQMDvYM7J8+cfmigzJ4Bj1cTBLIFJrFvh8tthfhfXwM8jvFe2drJ3YCJmdqFDI1zR+wqQr0O2TSzb9jvKZhp2FcwsziTBnPRQkYFmGaDnMhojzOEwwp2QgOBU02BowB18MSjIzizlegT/jA/PxGxpP2T4An8+c5z2WdCy7QKgyxhMDTb07IZ9OenRQ+RWNL26mToh0wWTHkkb973ugaKhKZZqS79+tPn2kaShZKkrKcjvf52NwC++OrABbwpvy+Ywfn+VYNm/5shEXRYVpoyYvK2jk1zGc82+WSiQbwJA1YT53aszxBDKBMYjwgCrvxvA8h858+He3PJRYU0z90IsszLlgPnrn19a04tyEcIeI6GBYqA097mvgsxEIc0hJazQeMyT9xfzKeFe3Uk8f8vL/0NhvFSznPIOK5hPOELM4pZIcVF3KxyeIy44mcdLT0m6LUT3fnf71Ev2LKks7hdA3uoUj37LTNTF6fiPCkCnIop6e7dObO9cZ8gghhx9pkEC0AT5bg+STTjvFFpLlYk0dtwrfeeb+mGOP36/XY0YDKLMVUAs3Z2c7KvcGR+xM8VS0kG8NUGxvrgUlhzJ8cJhTMkYpIeOGc0cAKYgtg+OAv1NlLj46WxymgdJzI0DCsxNVXHbo2QRQsYqtx9pgXAR5GkVnU5M/4mAgJ8YxgPM+DJ4xp8idGvMRzAcqorQiF8RnPw8Qzd8EUwOQ8Q0uX7n3n0KEP86e4rDjSVu6Trlnm0WlsLF/Qb2fJCp9RWUjUKjh9Zri/nrEETF7R/en87c/wgDcnpAd4vkU8F+bgIlYtjeCNumI7urAV1WaLGpYAJ3jGSaYbWvAB2TjaOLouD2OLtDSJxXjRdj6pwJSN+wihKEZM+AQJQ2gS34VJT0EyXOuvXny2Z2CgY2BpNu5G0kg2blTHFILnnTuHxRFccC1NPNF4s53Gm/jnKtCTt4c/MT9SOL5ePBIfIYnOLacrGm1Defts4alJj04Cz9yqJ1+0dnV0fGxiT+mx13bs35u9/lBKYCQqEnjK0iM9I7scmvpN1b9YFRG7m2d6+7UFAdBM6EVWjXwyNrGF84TE/RnC/Dl3Loaec8mf25Q5OUqnNBQSooA3shqS7laJ1bnXujlQSQ9orlKBp+Mqa++p4Mks6HLyUlekWiyVpeszLxyNERoAwqiPXODTmVKOi/cuYBP95IBZO3D1ZiMO5eFiMlyOq5ExqALYxT2DJerFAyqSm8rRZmrL9NKzPT1oXOpy0vpxHikuDptn29kgCfOr6ETR+pGI1urE4DmCtSNxoT/Ex0d5kujI8nAfVEOgG1yJJ25EcIi+gI2zzS9MfqLD0XpiR8mxYyHYT4xV0MbMxqHVu5IUSbWRXWnGNDsnwOQ8rahUZP2de0PFkiTPzqwdc16aJVTL/xr+FDpM0z54Cf58U/DnXpyPo/JmSju7RDv8ZXDlMqtOxPLRxTnXBJ7tko5xniqVjbcNeB68tdnf3yMyJVefEIYbi6uaX/eLEYKb5sWMaSYpD3l/VpNac9F4lwlpT5vmgQ4hF/l0Q2nJMXWCq8okG7TVV6+eqqys/Oyt/S+88OLMgGx0eOIkhWyrHTwaAe8Li//UBKCvsVH0AE+NT/YC2gHgy893WixIR4/pQkpzc90LrgM91q4lpSUHDx5BtO8Nn3Ji6U0cQYiWe9aeOTfce+f2HdqezSqaonqkZdrd4btDxntGI1XdXBgVEhs7C0DN8Q6eu+e8gfxOBTUo3gWelqYqaEBJX1glpjbMBE4h4EvAcwuAqlSOiHivMP8bpzZv9pu0tKqKhsiLnmmuWjIDvyOlfCZj8fCdOzhJhqOSQTt+oumAxK3Xznez75ckVy5jZy1k48J7znML0XRUqQyDt4CTPtzcMjIy3NymgSc8Otv3Iw3+T2buGGqQ0cKwaRk0uiwhsSmEuPTns5egtzkbLEkWHxLPtpTJKoONwdAya/ry5SWl24e0S0+uzszajkNHtUnnz98m3e+VxHWtq3HGZdTw5wQ7q5y7w39cz7mHKkJOCOCadd+8CpfO/JrC3RTvc3bs//hNKk/yGnjOpRqQ24inqQ6bpe7z1NTq78dGtwv+PMp48gZ0VayNo7WXr2jxjdLlXo+819y8FhPgi6qam6s2UWNJLSRZTtco0y9rXZYOaVl5KlT3WhdEX2pwxkxZyw4DcTLQgsxMWcLjKrMMLVdPMVWq3DK8vd0yAgAEQI1KCI2TbqYr06Ouro9PnDTJazm2P23yc9GHgbZMna5ZcgQdxYJ8XPuPhT6M36OJZ/MLW7YYKr/r+4QfPbmkXb8neWfyDBxEq/2rXf7XCEa2isbOfkvLRGf3nJockEC83+vNKU67ycsUwWzuK0PmzJpGPMOFfMQ7TDR8R7xjex2OGxJPAGWCPb8K2Vb93a0rV07ZEs/urI8dW+LWEk/6INl0+PpvOLu8Y3pzXXPzFKwgvl1V11z1OiUdoknSaRW1dBqptWknL/VFI1jt6V7o/v1oZWuS+bQaZAueGuJpFuMJg6oyYFDvjJn8lIvSTtDqwcEWLoNJ+DOg+XVz845dNR8laaGy798kWWzdiUZ8f50r2pErg1t2HUGBCxwwqj/RdiKrLbf23M36v1uH/7otxy+QzEq+Ug2nfc7gaWU3dD/NaNdLx114aeJPdwGoyZ/ZbID0Bsbv8Cflo73giSqRSgIpaOuqN8sqb1359fLlG0HgWbu7+uLY2vxY/hObeKo7OrwmokGqexu36D9TVVfX/LpAUwHJdMUKDflPYZsIkORO/DTOmQoNhk5BGuUwrTFoOE8SXhN4PjLrWzwzVBlcARLO04nVY0K7Ni8Kogo28/penR+rUpmhqiq3bPkO6qNnX9/x48ctdFvXf1BQUGcA/h7Dlh+r5x9Idc/J0u6hM7Ntnk1dl/4Z7r1f241fYJhfo+6OQnVbncDT8vq9NN2Ev/AWQKkxPPB+1Bsv5YeHT+I8+QAJ6T3qkyie37ct3HrgK4p3oVZv6vxX+yqv3roCoDd+C7vW/fzoxZ8ujh1wt8Lws2bhN59+BT/vL0+P6fAiexYUTNm06G0vcK1jPEGGTYPrPldoZBTd+5zdnZis8Eev8UBfE/9R2RXUDaJyBpQL/nT8D04D4bR2zHCEPYknj/dUhHtNDX6xT1bFzp/f9+q8Moydo1bu2mWqmrxy5a7P8FV1dfWaXbu+/P57VE+2QAm61QXNdYTzrGHNFz8doAqbuMN2T3ZbStaMZY3GP1vv3710Rq1udQJNMqj7BEvnfZaI8PpiJ91D93N4YWI8lOve2j+noKoKPHl/nqq4EM+VK+e+RjzfX7fv029QyNcOOEnvxm4xXAXPX4nnb/rustGGorGyNcU5SNVUmo/V4UsrlnZMmg6IAQG0Q7aq7ocAxlMGmiCmSddtlTGe+hp38CSkNOJy6tcQUA9dr8O1oGjBoBIzT2szTmvi6Wjt6Mh5TgZNzrOopqgGhQ62rooFUCDtA1SoDKIgR+XVlbvWrKkmoNVfQA0Nn1qgAN261S+1VKpULYOGL79vOPTQhMSHTvSXb/8w90RW12nlH/803b/XdEZyuNFSKJsNJ1olHqIZzLuouHlPOYHsScpRotRfAZ9f4uNNgSftA8Nmkde2bVu47asaK+W+famEs4h6RVdvkT9vEFCHsdHRsdHq08NU6gKiK+8xtdcv9Zo+sa5u8syARa9Pea558sxpAc8znOBFJ5t16zjPoD3u7lZA6oyApyb0pAYUz+kuOFzDzQemiJcQz4cNJp5uPM3jmQGB57QfWHqXr0stImFA6ASczKF9pHllABpShgaT6UtojaDqNWssrHJ02mJt36mrg1fODpZ9+dlXicerH8Jtsvl7krMCy4dyjP803bsvPydvtRNSMhn0377OBSiqKozjSIiWVkxjlJmizJoiVvbwESHGoyFyQtKWDIpgXEOCFg12ipfmittigi4TAtIKmsyaRsAysOBjXRSMERR1cRMT8UGJjUYgAj7Q/t85h72a1X/vvbuQk/Dz/53vO497j+P0ImT+c70ummE96MuLXStV6oIF3+XON6E3T+NLiPeplI/gT+K5GjwLCw2lNUqUnbEFmmGOhUvT02sZzzPnr5w/f3749Wt37j5yAXfqHaL0InTw6Cej3EabscOWD3COMlclTxgzm9pO4Ny2CCss5PK0JIr9rDVKRlI2nUmW+C4gxxddwo0AMCgFPGT358SysnShifyVLGQGTvCUI94NakMifjEFmVPABE2OE8mHcCrwygbLDPaqdpjuTF2VzLnt53895pmHPzGxPU+buT92L57eFxd3QNV9m/F8cz+v5WljfFniMCcNdvhQ92LvTVUPJXcGWqUpiFzrM2o7CenInt8VaHPmsP1yFqyrqamRF9XIUHTnuwd6plfW1jJ/Es7zbdevWT84ee7QEQAF0d3sQcQHj19+bdRw86PE09XV9NDDz72UbAZP8Nu2jU1xyIui4+HPrPhxrUjtaHwR7MRTlrgxPmlRI/F8fsifdMtvdPSqaSMB0M4zeR+7pt/PsygRBsWB7TlLBc6SkvYSZk+Gk9vTSP7EMeTPbIOTChO3mxa2HHN7LlARMBe/+IefTRhT/GFBLDZ61PTePtjdl9D1pmaYEIjKnB2ny92dVd2N4NmPFkbsCKqJ1QZEUbRzf6L+RD5C50iRPQc849xt2ozAqT7Y3qXO9JnT2mVLl1aiiu4cCvjzHderHz9x8gBG4I6gADqIg+nIa27DH67ymewxeaxpBOyZDJ7MnsBJ67zl6mgscURNNMtCFOFQHBDqetved2N/e/rpZoznZCVI/lx1kaK9TAr45ImgieMliedJ8GTCHsfT2wVPEOUwjfQasieUTe6ESasddpnkTu5FBRsjtmxQYhYnsajxwKUVaaysgNKW994+1N13susQvAnRFZWmDIVokYtK060a5t7Pe/Uumhp5jaG1dTMbu6NyaQLaT9Tz6LzDn3NxF9nmqDpXk8lUh4J8rKlw4Xfvp1dCZzo7a9uuUEraZylG0XQAreflQ4wnY3r5hdfNZsLp4WN+0vzw+OTk8XWzo9OI5ytv0HMTY9XwZxolpGqa20MA0RtzKJAmZu5peMEe8PPS5hFPxLsIePLlRFyEXgLRp8Kp+TwxxFOJ3y6S0RQ8vZr8IaLpD3dymtkxohF10GpL3adrMrGuINcUim1oprBSjo0g0P38DQ03Dl3oO3jjKOfJtyKfLkOlp0QGVg0b5q7i29G4uNM+oxrNHo4T9iSeG/xQ4o+pG/spTU4H4fYq4mky4Uartev83k8RPO8i4BHx9a2nmk8cRPvZcBmRDjGepxZ9Ap7jJ2CE4LnkZOCcbJqdBX6wJ+6Swd0dsZroeOBEwHvLaHpvmDMzqPPQ1JRMZvjwec5T+BPxDp4ep07/DJ6jQsc+NHraw1VVI0eOB9Hx47dTtCecUCcK4dez8WhnPK1Nm2FO4okzj7efHGYGAt4BHR4I4+OJVPIVBqyMz6In1uDni6al4JcPHUpavPj5Q5cIpoNg6pxosbTaXBrd3cEz1Zn6jw7guUDR2K/Zk8Nx+owZ7eY2IyiUQM4Sz2p3BU9mT5Or69qAwJBy4Kw901mbcoXxbMu73Hz28m+Xj8KfJE710u6kqqrxyR5Tyzw9yyZgCMv0NrhwnpO8cUdcrIpVogmojmKdBUeWlYirYLpcNKCc6NujRyL/fDswMLAhfeLstI+DZmDzTGjUiKfGwfKgCZ6xiTSLDSxIvzJ7sFutJU3L9wKol68vy0cQcAKo8KcT8jYfnsCBUMagjzqeJjYh8Gw4dGTb4sWvHmlAtSSEgur6tbvW65ZGlaOLg0t3I/QhnlmyduGcuK2xe8wjZmAMgPa9hD79gaNke9sEjWX2xAu7Bs4N8G9vR++i7UxnSu0VBrRyXcPxs6dPo1Kie/GFdl/a+G7VSKD0KvOckOs9PyfX9e0kjvOVSd60v1usKo1V9gD2O9ghygkiwwlxvmqWkdjaFxbvI/d5jgTPXs/05B/AM2IG19gRU8KZO0+ePKtyJprL5MsKACejRJLx5s3gPcVNoloiogh3Esvv9+6vT8LGwepFFO6E8/vvf9t99MXFS95pOKJ2vBfntbuV+mtWJ3XjMKfuxu4dO/bgfuWoNWtyTNhAjHYARMfwUwZ0NsPJgQaBJvcnjDon0ojuWYq18wzCneL9zPm8reBJOPnjDVZiMBVP+P9t60K34cng6Zls8naty5V4vug9jtrjWHc0UTjC39x9yWBTcl8yowqRRT+kEjSNRDyHv/9YcOCe3t4+tCDwZwTnOQpAtxHOk+DZjN3K5MtWLvnq7Rcpww+xBMZbt27dvFV96xZo0otCXqpBUS85iMEJRpM6O+o38ZfCm1hr8wliPhrjyadPNTgPE+xbgRN1t+3OHUNj4zDH7h35m/aOeQo/TARzpNhL8Qfi+Sn8CZBCEXaeY11NCwqNJdaKygrwrCSeneev6JYh3s/RVtf7sa6+svZOZUfoF4cORM6ZHQSeZR6T58+v8/HJHTcLTqTs7j1/sglKdUEkJyQlLHo6fj8sBYAcqcTT3QXVPRw6NCqS9MNnEYat2KPt9FfE8y3viIhRM3AbNwKeBk/YPOtx94KVS1ZhxcfbS1IR8Gg7/bK/Lbl5qzXg5q2mWzeNrRrDrZtNFXmMJTs4z9VzCgvkBqWzk7AnxjmI5/cJWBZBt8HQRAx8Gr5Izd3p3IpJ4+s2/fXW1usxyzfOmRtlfspMjNAoEk7Yk3DCjUxDPGfjcCWYxBP5yBRQmGe1WlMwuFRL9VLnlfNnrDHFx8/uYDHirLx27c6dyvrDORvzM+M+jUC8e5Z5YKXuZB+zK7yelLU+bM3aQBM1IAVOWMgWn4ABqt+RBQCSA5V40vb8MsOkj95c9PTzSTwjvfN0zYEG7NV4KmtbUlrWLCwPcx074inz9u2LxKz1iYNqeozvN5MmTdm2cvkBR0VO2M8rs/yabhk0twC0yXhTbohpKskTPCV/svuYTXW5YRtWB8SVttYoUeC/GR3edfVqV3P4e/MSjp9t3n351OkLBwpQfCjRRsvwsybatAtWT6WnmmCSY0yu+SnOc5wACpwST3wURCk4iSfO+aYMbZ41z1pR0Ql7AmjnlSuV2TuOen/qkRGQnR1puQae1+7etcbF1hTFjTPBnp6eeDrNVDxMJddsCnp8U2F2ZFhEKFo+01bHHTuoX9rbW2OQsYZTZmeJgVrqgiLHu89BRA8f+/GsVasWow5sKEht7rq84xAe9cEAz0tLePMdVL7NQNmMx8af3c1HzdiO3yqNSiPP/OntrO8Q56iygTNg762m5Cbjgzyx6y5G1E3QfNN8noDDVqwsXpYpL1JOFx0fSlgs1GU1+siFGzCxwffwxqNjgBSp/EkzbxU5Q4ZzdtCc3Ag7z9n0YtmICe++WmseHFre2YYe0hXg7Ky9GITJgWPHOmvv3LlzDbpb3u63GZ3+ua51nmXvl3lMXa0ILqPE1FSwLFNZjPYDN0mPfmgrG+mHDOjPiPwuot2J3t1R2wGo0pctzjrTcXEa+F1SKruu3tjRnIQM9T1wzkuK/wjbi54+derQ8csNpxt271bFqjEso8nP//2Xovx8Z3dN3BveXtmFcTeVmlaFATQR7hwnWEo86d5l1yEBKCFlg20ANcHvu+xIfQ1gJqKUmrM5yscnTEg8jYcJFjWbQXQG9p5mOIlnaMTcgrpxEbMZSxzIUJynaEP9LNaYGOJZ2cl4nqmo2NeCiTGCyXmWv1/eHhi4LiBjoau5bKZfoL//gnUBTb4hfuvkC+KcnYojHntpZsgjRp/cvbjn5t1JU2bZlDy1A6gTrryuF10ldEELX+q4eLEFGrk4Ou3dVsPlP3obmxPSon/9FTjDkxZ9s/nD/ILU1HMNiMZfdh8BTJp0VBedO6BJ3Y8NCosm/ZxZo5LJ1Yh4+a2bN28aQZHzlOTwqTcRDXIlqvyYD540NhQFUFUPo3+X4ThsM6aGANNnAjhH0auYaSrtAR5F/wlAkWYAFDghxrO00ASekNiclrUIeIPgT521OsaaV9mZAp6I93IKfgzL3gXK69fhzWqDsiR95EitPHPj2DETJkwNzA4ojIxUlOptmK93VBbKqzO83EZf9K9CHvxi1svLV26l/hDRc8S6X5m9AJXRKB7DGnOlYx9UHzIpftt8nb7vRnfjwfikJXfufB49D2tOP4haGAeemQewvurckQYEuQs6K6nyU7+pXYrULhrZ79iJPtZFrSq91Y2pv5tQkx0nyHKeJmis9DwIsmed2WcyeY5UVfVcWZnecfOE5CrSw2ZcMD8MV3pM9fp2KsmDOzQXzoNDAYzjc11o00e6zhYwoXHe/GMQlo7V1RVWW3XVeXm1bZWdtdTlrNZVx1ADcO06VF1//nyLzZC9ILheK4/bY3rK7DNVEaDTZejRnVRitt6GXuCCwxeneSi0XlXT3B7d8PDOnYk1iYSTNZ7wJ8yKj4STYFLoG8orW+9WWmpLNu4tzrNo9/c0NjaciA++o0M3NOkgrerHGqBG9vDc/KOnndXkTyzdyExVF7nsd0+sccw/oMZMGVavHYgF31sB1cbiJpHb7f3NYtpENSzXLHJ03fDhZqExPpOTUZ95ls0MHOaXPL6KA2Uymx+uehRdtPHjk+0hP8Y8wsTKTwKKcilirU1eupAAgib0qav4pxsHudYZ8vJ0ury8tru1bdRFqrZYdNXXq6vxfg0w/8Rw00V99gL/X7WJNcV15twwv4x1GRkGtJTu7omwKFrzmhkRppwZF/fpAhQzsUjoSQweKJF+QFFG9GSt2dnrCrVaLQZ6MQ+YkaEI9q9sr8XwNUL+2K/4O/b29JxrPlEKnmnhDT397qp+oZ6ext5z2CTXRaWi5diZjanuv6tqljnt19AoL9JTY2rsgZuGUoR8ego3qL393EzjaGu/2+DxBAJ2xgwQNZvRWwQjT6EyvxDlBPDkMgOpucr88MOPjIaAHV8+UvUoGgbzcDea/AvlRD+dsRrjU6WrBU4oos4uk2lEjdVqAc/Ou2216CLpWi1c1SlXzttVErjvirYmdu5TYyZ7+GcU1oiiTqZsjayZXhrs5lWGSS9a0wLt1BqoNsHcq0yUTIVXoDNMnUId9R121ddHNRYd2P145R19+Nnenp6FfsHBcwKWbS1qxALjnv7eXhXldmR4FQi6N6L9dMRQr7Ojyn3HpUsNqd8c3VOtu9lktN5jzmr0j/wwYlE1PAIQkOmRKAAT0eyB7rKHRxnDWebrZ0tGuHM9SycOYH2WOdVM51N4Qfg8fPhDwIoex6jvbBjstBWTQ5nGcpY5dTk5+DdrteZZdDHWNuLZWW6wWPS6mOrqisratvr6NprhbFe0p7TUt7UFOC/Emg8/xToZjVoTUkNGxro5hQbn9wHSrsOtlMQR1xTcLMfb2HBLyn+oPD35w8zGC+98de2ara+7p3s/nhHnvzp4rc+GBREvfnT8Ro+KeKow26jRgCviu8hJXYOh3lhn9YVbRy/8drQ4JuYmYN4r8Az9cTYFY1AEOXMM+XIqqYzOsrKljKevPpn5Eydd/iFQJKSjQXU4aOKg02x+ZNqjnjP9g0egJiUFmUYIoGZEQK7NGkM8a+9W3u2stJXqMoKjwvzyKghBbW19idYmj83UrtEu27tyW+h4j5n+Nr6TsswdPCOr20MQ8JFLGVBm5Ra9ksY+nR1lMCmgg2dpSHpTU0lJBYkNDeFKom8a82zf5h7Ykbp/+wTw7OlJDcjMpz1C9+zZ0bg+6O2Xu/v7NTTBqQFPDtZdGevuXuMiGzZ9mAaPLL2luangeUjyZjX5E71C9F5HcJYwJjiiwvPy8qI3Lv9AvacnDZUh1+OKk/BOlNiiLX3EDMGco0cTUze7ZghFQG6j3FouogZsoRYF5ZJeV229W3H3Lluf0YYlny0ITUQvWk98q6IiDz9fxuo9X5knlrWXJCJn1yTGJgKqTF+orUGRPsfXd2LHxRCvpZ5L/cbXyNhQiJOMiFOh5GzJNWHEwlqCbhhRrMDBXwBrNdq+Nf+OdX5fjLNe0/drZCSknNiiC5M+/3xbbw8Mq+I8wdLZXaV211wqUl0oiC3SDHNxilWW5jflVecJCaIkB/RZEX2IcQ+InAmWM72gEDpDgDPEP1iP7l7yg5o4HhlJNAPPYgkFTDp89JBHJZ6HUUXtIv3Irr8emzHD7ZE8+NOC+Mb0O1o5u66c6egQnuOtX+cZLPJOaa+wIcdQr8IJSmwt1Wt1GSHpSx9tadm18/yWnTvdGE6EOqKehiEQ8JY6N5iTFWF00ltKuVBKiT6s7qcNG1a8FTptn76/58NIrd5mUG6V5X+Vs/3lj3p6eg/+gthG/QlhmhUeLTp3uih/Q9ikKeYmdGu3TvvB9195Cl9Sg0ksSTNn+s1kCmGaaVTo0d0TQPGBlMy+HIlXVfJQw4r2FFAfGU3nQxBwoi11w703Ebt2BQEn0067ftx1+HALJYYOVoIKlVfEoJBqr6T1GJVYDdNSn5Jebqy2Odt3oXfG7wPVZPjHlMp1AXOz0ztafDH3TqWSIw7apR4pyWIyl5SnMNGbkPi6wuJTh87Yj1u27Op4v7GnR60uwkSvx/ip3y712nOu/9Q77x5wcaJ6CQJPxLtL44HTRZnYGzIq6rOA1Qtz/HRWBDhEBRMHqittdWC2hDE9vKYylqDp6wcxnoyon0KhReyz3IQXruzCqDKhaho/kpAKp7KlPhT4Fy8Oh0PB83AQ4bwX6JadW0hfcm3Z+eMxoCXVVpZXWGN0Wr3eElPSXoFlN22V5SV5OttQn5yoOittugxddvDSpSUxecZ99b/+OHW6kvIQRmmnszUC+EIXVGWFMQmfdBmiW2KZPGILfpYvv9z5I36wT8duX7N8z6Z8PNy5oPDDxu7HV8Q6qjVwJqwOh6rIqOrG/b+p83+Oop72mtztGXkxOrssrZDBYLM5wJU4cNqtSTR92TEzBEx9fRWKUi8EPjjeKxAV4rE/cuRIKVfBqo9MY0h5zMOhpFAG9AduTwmoeLw705Ivt8C3Pl5RUX4LI7WllpLaDmNMjLGyUt9qoHgmafPgBZuujbWwuo7zkL+S3ElTL844HalflBGaDHKY8YNq6bALSCssY8Z+iZ9h8ZItCBQKFnAVP9QPz3yw/jMXRzAET6oo4E6Nu+azoqL8C+q4KHajQE7O2rlzMrDAjeNMRHqkjpnSASyHjAkRSl/fJl8hEMVVkV1KTi2TFCJOEicKoBP51Q6Vgn/0RUQ9syjDSQ6VYl7y55IvwZMD/VyIPv319eItWw6HhR0+1rGvEmRqUyqMMAWV6Ba9Pqa+RGdtR/FPOlaayHki1mNllJEM2T+0V8CJ/1IzlSMELBPMD02b9hAS5bFdPxJF/hPhZ5nl/cEH3st3nLuwQ40xJsQ6BKKqzB0qdX6+ZlNUGMY3cnzWofe7YA5XgLZGidlMTF05MJZcEkxcm/g7FpiUKBT6mX4s9kGRhKtdHKhgKpyKJMUyFQt7OBTpnXiykA+1O1QK+SU4hUMZx8V43a/or//6nHx7MT2lIqWWtbZtKYjzP5nQm/p1H83zoE5S2vSlSkeAbdWZSygZSW2m9BG1gyXQA+u7QsoxMUSaGbL0uSdGu0WEznrrC+8Xt2078jTts/LN0eV7N21cvumzglSVak9cqmMR1lTvCaPnCUexdUs6LizUwForLdY3OdhhIsCBEcKFiZEtwfeIJwJf4ijBFK4VNCWNp1aV4h4OBVCekjhSLgaU81zFLSr8SUwfFDEW/y3U02pFuwjf1e5D9wjFAGi2TPTPQ/pqN7KkoHRE0Nt0frAnxToXPrEv2uhzilHx3WoaP0k01MhtNiw902VkG/2x7mPydu+3sO3EoiR6VvvztCMSu8FuVZHLprhGJ+eiTI26GGtbc6O/TntFh04yqboacCHkJgeQJAlvcgXSyYHiE/ypnennK7J9ile5V3sK3umzwMmqqXS8/iEKem7Qw9AuQhqK476Il2JeOJTE+D0gci+9TcYvgKyK2rKCi/X5jCn7SmKqLVoaVKacVVr60sVjHe0lMCPqdyN+42xjSUjQ7IhkvyZjUGHU+uWyBwS88sLQj7dhG9B5fIovTWi5s8tGjVrl5FIk1xTQaGXa61+/izEcJp1d6G8CFaGUaEpMfSFcjEbwJIMSPpzCm3QySQZF2odQdfn54Vuw6KPI9QDacpgBFTlJMuiDDhXiIS8xlQBH4/TMY2KWgCeAlhZglmQUypXIRRjrpIZUj7WPrc7yhT58wACD5UHeoWKqIKJqddiG7+4lqWJXNJSySAx//dZwZPcLNG1O01STvpkyZXsmJXl1bKJSVaTWbAodNQorc4vRjHNxk7LxEF+uQNAMRpFSymSTJJfX1BgSa7jkdBTRBjGZeMViorgIYsuiNSoIg1lCTgWMJyKeGZRwSkgFUBLjKTlU8iiz478reme78GUFQh99HSVWWGB0ScZnEtzZ4LxjaZMfyq51Ci8M1DxUh+EyGg8b+jcPKdGZo4ZMKZMEngHeX3yQ+TN2WdjM9q6mLViLwz7e4eyc+suKj1RyDI+o5KvXhn2w3nuljgElk1I1z75yYEEdGAg7+ke69PQMDJz7va+Ptlk4cgjLM7q6sCCL7RaMk/ab6mI6gSmrq1fx4Qb0Qt/tG8cHBw9eHhh8vrfn9As9/e/+0u+ylfWoxvMWtKWFwcRhT0rQPQ6FHrQoToFUylHR7JXOuz1CFYnwI0vtoIlSCT1OSF9lNjY1tZffX8cLpZdbTLl2nngpOU0IPOfvoT0LsG59LLszLWd+zrZF7+BBUUcuuKN4Sl0zwXXWej/XrJUs3AVUuuosOgcR26R1/QNdtwc/jLvR9crJruZZx7Gu90TzKwknTkxJOHmC5vzO/hvPhqwbty8nDA4+fXCgN6uv+1RST/+Uy/1O4OlJPAGUMtJ9/ryvsBfiPHmavwcqjgejP3paxT1AU8CTV0pO6I0qW2NiwNfRSetWhQXD+FOAGCIhxUe6uaPdMnbNg/6keM/2/mIFtiResxJF0fb53vTouxWPH83UKN3xt+B/vPWbbZ8vXpIzYVbWGi3HCCHcmRhPQdS/sH/wxsBAd3df15snrp6Nbz6x6CS2mcJ0dFIC10kmwEwI50ogpYWHp82jMy18Hlrx3/v7z3X3uxSyBpTzhEElnkwMp2hDCemqB7KSJI4T71ILOo1lIjtPA+dJ0Y4H2mMKRYkvdW7JlIvYn7CrjLxJBWmFxZxbMwRUgoo+a/YXk7766cXHP6CbKp4aQwMbUWsW7QdMmkqfjpl8VWND9KowH+Kp1QqQwMrBOjT5Nw0d+v4BLEHp64Ppuq4eP372BLY0Pnv8ePzJ8HBMAyaB1jyc/yuATejuPXeux4l4vsSBgqebBJThlIBKMU80hxpRHA9KAjqNaEpEOU8naJizQabXG2zoqlTPDBHdTKqa0ivTa3GprU2niglELSPqYu1pXfIo+XPFK2zpfRKLDfTY3kZWmvXxiuUb41SaWLq170Jajk/utqxcHYSOhV4LCZc6NBnpRg/i2WTr6e0d7L1NQLu6mimo4T5YsetGGoHEJxxp3+N2kgf1NV4QIe/ux/C207qyMvBEx/6xZ0cTzxY7Twmo4MmTkt2horSn64NAuaqEPyWeLNYBdboBAyXTMWyS6O8WAo7oU5EqIQ4VSqcuky5y7mG/VAFTwgmemCt9Y0rW4rTPP8dBioY+p9X6e+R7sf/Ku0nRk3xywXONVs9h6rUswessWq0DVuQQTCMOeX/v4MDADaQX4DzLcCKiQfEqAIMlghq8QPO/BaAnunu2/NbvFPl+2VICOlI0oAIoZic4UMmgjOeDeZ5fJab0iRzDeQIoJPKR4IkqfpisNRHZXR7raFiwsV1gTGHCO4fKL9WFy+Yu37tVyXMRDqHpwV8pSGs3F6/Jme+N5Ta0dJOElSVUjtJNXGF1ZsYTDSiTRZAFT76OkXAaDf1dXQMDu7tux6cxbnhxJVy9ehIoCSgA3x/zS1gb0Bwe/n04RN/p7on4vd8l4H27QacBaIubZND7U5LkUFhU8qjAycD+w6vEUwLKeToLfyr1BvBcMDfbFpnZzlBK4l/yTlJ6TMGcrRNStEpJIt4VcaXoO66LDJiTHewfiNJ887dRuTkr1n8waUpWEl8n90GOa07u21lrdGRNrYDJq1DwtCuxp+/2wGDzjduAx17hHCiRgk0R8Cz+oSR8zSR4EmhcIMYT+chpAZstoTFSDOCBJ8TseXjXsX/mJMmg9ixvByqu0qfFaSA6UfCEBE+kI7a6JlHfit6RPHBmtTa1vJZ0f3eTXm31kLVVvyD9z/eJo8Ap5G8rjcygkaNI1ivHIxAwXxm4mW8fUxy1Jufdx3Ndx9XBn2F6JmFSzIBBjKdCYcRrnTvaz4HBvtt9JwlgPE57DieUQkQ2iVzKvgXIBDIJ3+R/mHj2oP2cO9QPnYiAn3ZvwAuakkNJAqgkwGNcBVshYdRk4BQGrRA8aaoOVbyhkDrvNdkhIYWJ5byzLomRbGur78CcS0WpbYLHo4FE8v787t9amoE7KBTZdOOWUADwQnj8ydrV320Omz8uaAT5UytAWrRgyWThPCMLbUqM4A1At8GTmMXHE514IknnUDALV0L3vdHle/F5YADzhU5z+cjTSy9NRMBfZCX9EFHJnlJKut+ggqIdqrQVJmgCKXgCKKdJPNkNUFTROCYWyvDJ5vfcTG1syv0499Xua8PcCVHtuFhfrsvcyjHiem8+KrHpjSVoAvntWn7+wZBCkcHpZuvlAYVRWFFjgj/XK9ArIp50CpM6ZAPl0FLZgcHBwduX+/rmkc+EgOnqScaL4p0zHALJUr2UoUSDi7L+1ICTIqQMLSjxnMh4wp9ujCZ0b80kJPEURMUhPCo2awXPLJzgCQl7Cn+iOKReZmKpksAi+OWGFHKkUD0dtB6spb7jV/y9x1KqP4p7sKDHJJQv8eTyV+iC/bymsp14/KlTHuhfOj0jMmd2UJAJ/lyPOwwx5Ie751JC2o15DK3DPcu4nW5fvTF4egvxhCR0XSeGaksR1YRSSCJJYiXAwOCh2wMuihDgBFAaD2UJCWI84c9jdp477zeohFRQFVoliZnUU2o/gZP86Yy6kKbOCuYoaRAYw/SlW1Pa7hNsifVmbfVYHYJYSdfFFdwHU9yaLAsknuKmLf9gukuTbob1Vfhy+QcqXLELyHr4c7tCQdkcKvHHhHQI3UTnUOTE70ZXORa5DN6+Pdh3pO/GvLQslsYFo2aYlXghPQl4/xCHiTd2Dt7uA89gDD/xlDTxMSQkKSNJLeiD/pRoSiQFT7bZNa6EdBV48oAn8fzurm4EUI3NotRgdEbm4Fy4KV1wRDLSL8S7aD2Z9lVaVKmyB2TnCaAg6m9UIMYVhBR3FwsFY/NjivdtOXkAyohK+hvIOqJczVp0NwAAAABJRU5ErkJggg==\",\"imageUrl\":null,\"color\":\"#fff\",\"overlay\":{\"enabled\":true,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"autoScale\":true},\"title\":\"Temperature\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"mobileHeight\":null,\"configMode\":\"basic\",\"actions\":{},\"showTitleIcon\":true,\"titleIcon\":\"device_thermostat\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"iconSize\":\"24px\",\"titleTooltip\":\"\",\"widgetStyle\":{},\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"useDashboardTimewindow\":false,\"displayTimewindow\":true,\"decimals\":0,\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"24px\",\"icon\":null,\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"400\",\"style\":\"normal\",\"lineHeight\":\"16px\"},\"color\":\"rgba(0, 0, 0, 0.38)\",\"displayTypePrefix\":false},\"titleColor\":\"rgba(0, 0, 0, 0.87)\",\"borderRadius\":null}" + }, + "externalId": null, + "tags": [ + "temperature", + "environment", + "indoor" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/indoor_temperature_progress_bar.json b/application/src/main/data/json/system/widget_types/indoor_temperature_progress_bar.json new file mode 100644 index 0000000000..0adf101ae9 --- /dev/null +++ b/application/src/main/data/json/system/widget_types/indoor_temperature_progress_bar.json @@ -0,0 +1,29 @@ +{ + "fqn": "indoor_temperature_progress_bar", + "name": "Indoor temperature progress bar", + "deprecated": false, + "image": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAMgAAACgCAMAAAB+IdObAAAAqFBMVEXg4ODf39/g4OAAAADg4ODf39/////g4OD19fUjTMchISHj4+OsrKw9PT10dHSQkJDHx8fj6Pjx8fEvLy9YWFienp7v7++BgYG6urry9Ps/Ys51j9w+Ys6GhobV1dWXl5esvOpaedU8PDxLbdEwV8upqanI0vG5ubn39/fLy8vk6fiRpeODm+BKSkrj6fja3/Fng9jU1NTDw8O6x+6fsOdXdtKrq6tmZmbNeyDTAAAABnRSTlPvIL8Ar7DvmsykAAAEFElEQVR42uzPwREAQAQDwDiGv4f+S702wmQ7WLg91HZhDsPkeg1DdB4wD5Un4EqkFCGjCBtF2CjCRhE2irBRhI0in/1y13EchqFod4tLvSBZUCoVbly5nfn/P1tSNoJdON5iCjuDmQOEERmG4EmAxH43zkWS2xF8B85FAnccvoiLGadcJ5JFEr2IfHmbiYLLMJFThH5zqqEJgFglBgdpGsYHbpmRWrPDEiVWy0IV5OjZHlbTSuz2qG2blWBcLyKenqwAS9FDsBCBib6QE4DAUhjGs+aRZaUX8aRvWkvQkkO0Icgri81SrhcJjJBSMsgEIatlKmLlVUuOnxmfeghcU8+cM9pmKvhbZF76NmvWWbhBhEVDY8dIPUfY93RseujAg3EsbWRZGI4idX/jSIHLRYQb7pVIYtBkEHaRx0rlKDK25+AukdkZci5SnZJs6dGekE5FyjbrDhEUiiV4JRL4gTBW7PvSDzb8I7IA7SkyWQsyBleLVPrqJn8U8S6yCHop0QX2TSRpd/UM5hAeqKPrKbKMWeWebwRxJstyFAlaTgC6vV6xiSBq0jhZWWMO5ByeIviw3qt+fo+IvPzjzoKNLFnjIZE80v/Puv3qd+I7XU7+igA94Y34ATdW34xfkT/sz6EKwDAQwFB3cHKyTA3Gqf3/941SUdfaUPJEfGgcoXGExhEaR2gcoXGExhEaR2gcoXGExhEaR2gcoXGExhEaR2gcoXGEZj/SRq8piDYjrZ6M7s6pAmg5Ut+becDIz34drEYIQ1EY3h08S5dpskhIkEHFEWbm/V+tkJFSLUy5ljDXmm+j25/rDSYxW39aiQ4avQohw/BB4jtPemj0KmRogW1IVDqQ35Z9G9KRA1QShsxki6flaQxUkIX0pMXTGJ0B+kA6FTOShdivgZiA0QPOGtyShvUXhfRkwCIOroV3eTgB7ycKseQNi8l3wDzn1yveTxLSOzqsBAstJCGe9P8i5MdAYHOI0fA/LAjxpMXaPRkA9mDL7sgWa8aNBt3Bjt88kK0pMqU7FMghe6lZkHPd2Q+ihmhTQ7SpIdrUEG1qiDY1RJsThPSBe8VrU4w8JHK/R1PMRRzCv2jKEYcE7hebYuQTmSL3epTbkcuJT62DqSHa1JDP9u4lhUEgCMLwmEcpGCIELN00vRrQpd7/cBGyD0xW5aR/mAN8NEwvW62AqPUFsg8+Q6XdAbo7yyE0wlXGRTMg71i9HLKNwKwykrwaYEQ3lUPWrANZMw144ninhtBZByQPeZweMAJTOYRTh3GDQgvZfr6ezcshmG1wqEQDenPrf4BgWSAW/3uzn6uAqBUQtQKiVkDUCohaAVErIGoFRK2AqBUQtSqCJFRRmy4VnJ4GXvfUpAqOT/NgXJtbe/bSpbm+AQFDJgMgD9a7AAAAAElFTkSuQmCC", + "description": "Displays indoor temperature reading as a horizontal progress bar. Allows to configure value range, bar colors, and other settings.", + "descriptor": { + "type": "latest", + "sizeX": 3, + "sizeY": 2, + "resources": [], + "templateHtml": "\n", + "templateCss": "", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.progressBarWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.progressBarWidget.onDataUpdated();\n};\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '280px',\n previewHeight: '180px',\n embedTitlePanel: true,\n defaultDataKeysFunction: function() {\n return [{ name: 'temperature', label: 'Temperature', type: 'timeseries' }];\n }\n };\n};\n\n\nself.onDestroy = function() {\n};\n", + "settingsSchema": "", + "dataKeySettingsSchema": "", + "settingsDirective": "tb-progress-bar-widget-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-progress-bar-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"function\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Temperature\",\"color\":\"#2196f3\",\"settings\":{},\"_hash\":0.2392660816082064,\"funcBody\":\"var value = prevValue + Math.random() * 20 - 10;\\nif (value < 15) {\\n\\tvalue = 15;\\n} else if (value > 30) {\\n\\tvalue = 30;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]}}],\"timewindow\":{\"realtime\":{\"timewindowMs\":60000}},\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"padding\":\"0px\",\"settings\":{\"layout\":\"default\",\"autoScale\":true,\"showValue\":true,\"valueFont\":{\"family\":\"Roboto\",\"size\":24,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\",\"lineHeight\":\"32px\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":18,\"color\":\"#234CC7\"},{\"from\":18,\"to\":24,\"color\":\"#3FA71A\"},{\"from\":24,\"to\":null,\"color\":\"#D81838\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"tickMin\":0,\"tickMax\":40,\"showTicks\":true,\"ticksFont\":{\"family\":\"Roboto\",\"size\":11,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"ticksColor\":\"rgba(0,0,0,0.54)\",\"background\":{\"type\":\"color\",\"color\":\"#fff\",\"overlay\":{\"enabled\":false,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"barColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\",\"rangeList\":[{\"from\":null,\"to\":18,\"color\":\"#234CC7\"},{\"from\":18,\"to\":24,\"color\":\"#3FA71A\"},{\"from\":24,\"to\":null,\"color\":\"#D81838\"}]},\"barBackground\":\"rgba(0, 0, 0, 0.04)\"},\"title\":\"Temperature\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"units\":\"°C\",\"decimals\":0,\"useDashboardTimewindow\":true,\"showLegend\":false,\"widgetStyle\":{},\"actions\":{},\"configMode\":\"basic\",\"displayTimewindow\":true,\"margin\":\"0px\",\"borderRadius\":\"0px\",\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"showTitleIcon\":false,\"titleTooltip\":\"\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"titleIcon\":\"device_thermostat\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"iconSize\":\"18px\",\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"14px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1\"},\"color\":null},\"titleColor\":\"rgba(0, 0, 0, 0.87)\"}" + }, + "externalId": null, + "tags": [ + "progress", + "environment", + "indoor", + "temperature" + ] +} \ No newline at end of file diff --git a/application/src/main/data/json/system/widget_types/indoor_temperature_progress_bar_with_background.json b/application/src/main/data/json/system/widget_types/indoor_temperature_progress_bar_with_background.json new file mode 100644 index 0000000000..2fc35d9e0b --- /dev/null +++ b/application/src/main/data/json/system/widget_types/indoor_temperature_progress_bar_with_background.json @@ -0,0 +1,29 @@ +{ + "fqn": "indoor_temperature_progress_bar_with_background", + "name": "Indoor temperature progress bar with background", + "deprecated": false, + "image": "data:image/png;base64,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", + "description": "Displays indoor temperature reading as a horizontal progress bar with background. Allows to configure value range, bar colors, and other settings.", + "descriptor": { + "type": "latest", + "sizeX": 3, + "sizeY": 2, + "resources": [], + "templateHtml": "\n", + "templateCss": "", + "controllerScript": "self.onInit = function() {\n self.ctx.$scope.progressBarWidget.onInit();\n};\n\nself.onDataUpdated = function() {\n self.ctx.$scope.progressBarWidget.onDataUpdated();\n};\n\nself.typeParameters = function() {\n return {\n maxDatasources: 1,\n maxDataKeys: 1,\n singleEntity: true,\n previewWidth: '280px',\n previewHeight: '180px',\n embedTitlePanel: true,\n defaultDataKeysFunction: function() {\n return [{ name: 'temperature', label: 'Temperature', type: 'timeseries' }];\n }\n };\n};\n\n\nself.onDestroy = function() {\n};\n", + "settingsSchema": "", + "dataKeySettingsSchema": "", + "settingsDirective": "tb-progress-bar-widget-settings", + "hasBasicMode": true, + "basicModeDirective": "tb-progress-bar-basic-config", + "defaultConfig": "{\"datasources\":[{\"type\":\"function\",\"name\":\"function\",\"dataKeys\":[{\"name\":\"f(x)\",\"type\":\"function\",\"label\":\"Temperature\",\"color\":\"#2196f3\",\"settings\":{},\"_hash\":0.2392660816082064,\"funcBody\":\"var value = prevValue + Math.random() * 20 - 10;\\nif (value < 15) {\\n\\tvalue = 15;\\n} else if (value > 30) {\\n\\tvalue = 30;\\n}\\nreturn value;\",\"aggregationType\":null,\"units\":null,\"decimals\":null,\"usePostProcessing\":null,\"postFuncBody\":null}],\"alarmFilterConfig\":{\"statusList\":[\"ACTIVE\"]}}],\"timewindow\":{\"realtime\":{\"timewindowMs\":60000}},\"showTitle\":true,\"backgroundColor\":\"rgba(0, 0, 0, 0)\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"padding\":\"0px\",\"settings\":{\"layout\":\"default\",\"autoScale\":true,\"showValue\":true,\"valueFont\":{\"family\":\"Roboto\",\"size\":24,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"500\",\"lineHeight\":\"32px\"},\"valueColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"rangeList\":[{\"from\":null,\"to\":18,\"color\":\"#224AC2\"},{\"from\":18,\"to\":24,\"color\":\"#3B911C\"},{\"from\":24,\"to\":null,\"color\":\"#DE2343\"}],\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\"},\"tickMin\":0,\"tickMax\":40,\"showTicks\":true,\"ticksFont\":{\"family\":\"Roboto\",\"size\":11,\"sizeUnit\":\"px\",\"style\":\"normal\",\"weight\":\"400\",\"lineHeight\":\"16px\"},\"ticksColor\":\"rgba(0,0,0,0.54)\",\"background\":{\"type\":\"image\",\"imageBase64\":\"data:image/png;base64,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\",\"imageUrl\":null,\"color\":\"#fff\",\"overlay\":{\"enabled\":true,\"color\":\"rgba(255,255,255,0.72)\",\"blur\":3}},\"barColor\":{\"type\":\"range\",\"color\":\"rgba(0, 0, 0, 0.87)\",\"colorFunction\":\"var temperature = value;\\nif (typeof temperature !== undefined) {\\n var percent = (temperature + 60)/120 * 100;\\n return tinycolor.mix('blue', 'red', percent).toHexString();\\n}\\nreturn 'blue';\",\"rangeList\":[{\"from\":null,\"to\":18,\"color\":\"#224AC2\"},{\"from\":18,\"to\":24,\"color\":\"#3B911C\"},{\"from\":24,\"to\":null,\"color\":\"#DE2343\"}]},\"barBackground\":\"rgba(0, 0, 0, 0.04)\"},\"title\":\"Temperature\",\"dropShadow\":true,\"enableFullscreen\":false,\"titleStyle\":{\"fontSize\":\"16px\",\"fontWeight\":400},\"units\":\"°C\",\"decimals\":0,\"useDashboardTimewindow\":true,\"showLegend\":false,\"widgetStyle\":{},\"actions\":{},\"configMode\":\"basic\",\"displayTimewindow\":true,\"margin\":\"0px\",\"borderRadius\":\"0px\",\"widgetCss\":\"\",\"pageSize\":1024,\"noDataDisplayMessage\":\"\",\"showTitleIcon\":false,\"titleTooltip\":\"\",\"titleFont\":{\"size\":16,\"sizeUnit\":\"px\",\"family\":\"Roboto\",\"weight\":\"500\",\"style\":\"normal\",\"lineHeight\":\"24px\"},\"titleIcon\":\"device_thermostat\",\"iconColor\":\"rgba(0, 0, 0, 0.87)\",\"iconSize\":\"18px\",\"timewindowStyle\":{\"showIcon\":true,\"iconSize\":\"14px\",\"icon\":\"query_builder\",\"iconPosition\":\"left\",\"font\":{\"size\":12,\"sizeUnit\":\"px\",\"family\":null,\"weight\":null,\"style\":null,\"lineHeight\":\"1\"},\"color\":null},\"titleColor\":\"rgba(0, 0, 0, 0.87)\"}" + }, + "externalId": null, + "tags": [ + "progress", + "environment", + "indoor", + "temperature" + ] +} \ No newline at end of file diff --git a/application/src/main/java/org/thingsboard/server/service/install/DefaultSystemDataLoaderService.java b/application/src/main/java/org/thingsboard/server/service/install/DefaultSystemDataLoaderService.java index 892eb996bf..87e1b097e4 100644 --- a/application/src/main/java/org/thingsboard/server/service/install/DefaultSystemDataLoaderService.java +++ b/application/src/main/java/org/thingsboard/server/service/install/DefaultSystemDataLoaderService.java @@ -534,6 +534,7 @@ public class DefaultSystemDataLoaderService implements SystemDataLoaderService { this.deleteSystemWidgetBundle("count_widgets"); this.deleteSystemWidgetBundle("status_indicators"); this.deleteSystemWidgetBundle("outdoor_environment"); + this.deleteSystemWidgetBundle("indoor_environment"); installScripts.loadSystemWidgets(); }