Merge branch 'master' of github.com:thingsboard/thingsboard

@@ -197,7 +197,7 @@ public class DefaultSystemDataLoaderService implements SystemDataLoaderService {
         generalSettings.setKey("general");
         ObjectNode node = objectMapper.createObjectNode();
         node.put("baseUrl", "http://localhost:8080");
-        node.put("prohibitDifferentUrl", true);
+        node.put("prohibitDifferentUrl", false);
         generalSettings.setJsonValue(node);
         adminSettingsService.saveAdminSettings(TenantId.SYS_TENANT_ID, generalSettings);
 

@@ -59,6 +59,7 @@ import org.thingsboard.server.queue.discovery.PartitionService;
 import org.thingsboard.server.queue.util.TbCoreComponent;
 import org.thingsboard.server.service.queue.TbClusterService;
 import org.thingsboard.server.service.telemetry.TelemetrySubscriptionService;
+import org.thingsboard.server.utils.EventDeduplicationExecutor;
 
 import javax.annotation.Nullable;
 import javax.annotation.PostConstruct;
@@ -126,13 +127,13 @@ public class DefaultDeviceStateService implements DeviceStateService {
     @Getter
     private int initFetchPackSize;
 
-    private volatile boolean clusterUpdatePending = false;
-
     private ListeningScheduledExecutorService queueExecutor;
     private final ConcurrentMap<TopicPartitionInfo, Set<DeviceId>> partitionedDevices = new ConcurrentHashMap<>();
     private final ConcurrentMap<DeviceId, DeviceStateData> deviceStates = new ConcurrentHashMap<>();
     private final ConcurrentMap<DeviceId, Long> deviceLastReportedActivity = new ConcurrentHashMap<>();
     private final ConcurrentMap<DeviceId, Long> deviceLastSavedActivity = new ConcurrentHashMap<>();
+    private volatile EventDeduplicationExecutor<Set<TopicPartitionInfo>> deduplicationExecutor;
+
 
     public DefaultDeviceStateService(TenantService tenantService, DeviceService deviceService,
                                      AttributesService attributesService, TimeseriesService tsService,
@@ -155,6 +156,7 @@ public class DefaultDeviceStateService implements DeviceStateService {
         // Should be always single threaded due to absence of locks.
         queueExecutor = MoreExecutors.listeningDecorator(Executors.newSingleThreadScheduledExecutor(ThingsBoardThreadFactory.forName("device-state")));
         queueExecutor.scheduleAtFixedRate(this::updateState, new Random().nextInt(defaultStateCheckIntervalInSec), defaultStateCheckIntervalInSec, TimeUnit.SECONDS);
+        deduplicationExecutor = new EventDeduplicationExecutor<>(DefaultDeviceStateService.class.getSimpleName(), queueExecutor, this::initStateFromDB);
     }
 
     @PreDestroy
@@ -292,25 +294,14 @@ public class DefaultDeviceStateService implements DeviceStateService {
         }
     }
 
-    volatile Set<TopicPartitionInfo> pendingPartitions;
-
     @Override
     public void onApplicationEvent(PartitionChangeEvent partitionChangeEvent) {
         if (ServiceType.TB_CORE.equals(partitionChangeEvent.getServiceType())) {
-            synchronized (this) {
-                pendingPartitions = partitionChangeEvent.getPartitions();
-                if (!clusterUpdatePending) {
-                    clusterUpdatePending = true;
-                    queueExecutor.submit(() -> {
-                        clusterUpdatePending = false;
-                        initStateFromDB();
-                    });
-                }
-            }
+            deduplicationExecutor.submit(partitionChangeEvent.getPartitions());
         }
     }
 
-    private void initStateFromDB() {
+    private void initStateFromDB(Set<TopicPartitionInfo> pendingPartitions) {
         try {
             log.info("CURRENT PARTITIONS: {}", partitionedDevices.keySet());
             log.info("NEW PARTITIONS: {}", pendingPartitions);

+/**
+ * Copyright © 2016-2021 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.utils;
+
+import lombok.extern.slf4j.Slf4j;
+
+import java.util.concurrent.Executor;
+import java.util.concurrent.ExecutorService;
+import java.util.function.Consumer;
+
+/**
+ * This class deduplicate executions of the specified function.
+ * Useful in cluster mode, when you get event about partition change multiple times.
+ * Assuming that the function execution is expensive, we should execute it immediately when first time event occurs and
+ * later, once the processing of first event is done, process last pending task.
+ *
+ * @param <P> parameters of the function
+ */
+@Slf4j
+public class EventDeduplicationExecutor<P> {
+    private final String name;
+    private final ExecutorService executor;
+    private final Consumer<P> function;
+    private P pendingTask;
+    private boolean busy;
+
+    public EventDeduplicationExecutor(String name, ExecutorService executor, Consumer<P> function) {
+        this.name = name;
+        this.executor = executor;
+        this.function = function;
+    }
+
+    public void submit(P params) {
+        log.info("[{}] Going to submit: {}", name, params);
+        synchronized (EventDeduplicationExecutor.this) {
+            if (!busy) {
+                busy = true;
+                pendingTask = null;
+                try {
+                    log.info("[{}] Submitting task: {}", name, params);
+                    executor.submit(() -> {
+                        try {
+                            log.info("[{}] Executing task: {}", name, params);
+                            function.accept(params);
+                        } catch (Throwable e) {
+                            log.warn("[{}] Failed to process task with parameters: {}", name, params, e);
+                            throw e;
+                        } finally {
+                            unlockAndProcessIfAny();
+                        }
+                    });
+                } catch (Throwable e) {
+                    log.warn("[{}] Failed to submit task with parameters: {}", name, params, e);
+                    unlockAndProcessIfAny();
+                    throw e;
+                }
+            } else {
+                log.info("[{}] Task is already in progress. {} pending task: {}", name, pendingTask == null ? "adding" : "updating", params);
+                pendingTask = params;
+            }
+        }
+    }
+
+    private void unlockAndProcessIfAny() {
+        synchronized (EventDeduplicationExecutor.this) {
+            busy = false;
+            if (pendingTask != null) {
+                submit(pendingTask);
+            }
+        }
+    }
+}

+/**
+ * Copyright © 2016-2021 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.util;
+
+import com.google.common.util.concurrent.MoreExecutors;
+import lombok.extern.slf4j.Slf4j;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mockito;
+import org.mockito.runners.MockitoJUnitRunner;
+import org.thingsboard.server.utils.EventDeduplicationExecutor;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.function.Consumer;
+
+@Slf4j
+@RunWith(MockitoJUnitRunner.class)
+public class EventDeduplicationExecutorTest {
+
+    @Test
+    public void testSimpleFlowSameThread() throws InterruptedException {
+        simpleFlow(MoreExecutors.newDirectExecutorService());
+    }
+
+    @Test
+    public void testPeriodicFlowSameThread() throws InterruptedException {
+        periodicFlow(MoreExecutors.newDirectExecutorService());
+    }
+
+    @Test
+    public void testExceptionFlowSameThread() throws InterruptedException {
+        exceptionFlow(MoreExecutors.newDirectExecutorService());
+    }
+
+    @Test
+    public void testSimpleFlowSingleThread() throws InterruptedException {
+        simpleFlow(Executors.newSingleThreadExecutor());
+    }
+
+    @Test
+    public void testPeriodicFlowSingleThread() throws InterruptedException {
+        periodicFlow(Executors.newSingleThreadExecutor());
+    }
+
+    @Test
+    public void testExceptionFlowSingleThread() throws InterruptedException {
+        exceptionFlow(Executors.newSingleThreadExecutor());
+    }
+
+    @Test
+    public void testSimpleFlowMultiThread() throws InterruptedException {
+        simpleFlow(Executors.newFixedThreadPool(3));
+    }
+
+    @Test
+    public void testPeriodicFlowMultiThread() throws InterruptedException {
+        periodicFlow(Executors.newFixedThreadPool(3));
+    }
+
+    @Test
+    public void testExceptionFlowMultiThread() throws InterruptedException {
+        exceptionFlow(Executors.newFixedThreadPool(3));
+    }
+
+    private void simpleFlow(ExecutorService executorService) throws InterruptedException {
+        try {
+            Consumer<String> function = Mockito.spy(StringConsumer.class);
+            EventDeduplicationExecutor<String> executor = new EventDeduplicationExecutor<>(EventDeduplicationExecutorTest.class.getSimpleName(), executorService, function);
+
+            String params1 = "params1";
+            String params2 = "params2";
+            String params3 = "params3";
+
+            executor.submit(params1);
+            executor.submit(params2);
+            executor.submit(params3);
+            Thread.sleep(500);
+            Mockito.verify(function).accept(params1);
+            Mockito.verify(function).accept(params3);
+        } finally {
+            executorService.shutdownNow();
+        }
+    }
+
+    private void periodicFlow(ExecutorService executorService) throws InterruptedException {
+        try {
+            Consumer<String> function = Mockito.spy(StringConsumer.class);
+            EventDeduplicationExecutor<String> executor = new EventDeduplicationExecutor<>(EventDeduplicationExecutorTest.class.getSimpleName(), executorService, function);
+
+            String params1 = "params1";
+            String params2 = "params2";
+            String params3 = "params3";
+
+            executor.submit(params1);
+            Thread.sleep(500);
+            executor.submit(params2);
+            Thread.sleep(500);
+            executor.submit(params3);
+            Thread.sleep(500);
+            Mockito.verify(function).accept(params1);
+            Mockito.verify(function).accept(params2);
+            Mockito.verify(function).accept(params3);
+        } finally {
+            executorService.shutdownNow();
+        }
+    }
+
+    private void exceptionFlow(ExecutorService executorService) throws InterruptedException {
+        try {
+            Consumer<String> function = Mockito.spy(StringConsumer.class);
+            EventDeduplicationExecutor<String> executor = new EventDeduplicationExecutor<>(EventDeduplicationExecutorTest.class.getSimpleName(), executorService, function);
+
+            String params1 = "params1";
+            String params2 = "params2";
+            String params3 = "params3";
+
+            Mockito.doThrow(new RuntimeException()).when(function).accept("params1");
+            executor.submit(params1);
+            executor.submit(params2);
+            Thread.sleep(500);
+            executor.submit(params3);
+            Thread.sleep(500);
+            Mockito.verify(function).accept(params2);
+            Mockito.verify(function).accept(params3);
+        } finally {
+            executorService.shutdownNow();
+        }
+    }
+
+    public static class StringConsumer implements Consumer<String> {
+        @Override
+        public void accept(String s) {
+            try {
+                Thread.sleep(100);
+            } catch (InterruptedException e) {
+                throw new RuntimeException(e);
+            }
+        }
+    }
+
+}

@@ -19,16 +19,18 @@ import com.google.common.util.concurrent.ListenableFuture;
 import org.thingsboard.server.common.data.alarm.Alarm;
 import org.thingsboard.server.common.data.alarm.AlarmInfo;
 import org.thingsboard.server.common.data.alarm.AlarmQuery;
+import org.thingsboard.server.common.data.alarm.AlarmSeverity;
+import org.thingsboard.server.common.data.alarm.AlarmStatus;
 import org.thingsboard.server.common.data.id.CustomerId;
 import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.page.PageData;
 import org.thingsboard.server.common.data.query.AlarmData;
-import org.thingsboard.server.common.data.query.AlarmDataPageLink;
 import org.thingsboard.server.common.data.query.AlarmDataQuery;
 import org.thingsboard.server.dao.Dao;
 
 import java.util.Collection;
+import java.util.Set;
 import java.util.UUID;
 
 /**
@@ -48,4 +50,6 @@ public interface AlarmDao extends Dao<Alarm> {
 
     PageData<AlarmData> findAlarmDataByQueryForEntities(TenantId tenantId, CustomerId customerId,
                                                         AlarmDataQuery query, Collection<EntityId> orderedEntityIds);
+
+    Set<AlarmSeverity> findAlarmSeverities(TenantId tenantId, EntityId entityId, Set<AlarmStatus> status);
 }

@@ -39,10 +39,10 @@ import org.thingsboard.server.common.data.id.CustomerId;
 import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.page.PageData;
-import org.thingsboard.server.common.data.page.TimePageLink;
 import org.thingsboard.server.common.data.query.AlarmData;
 import org.thingsboard.server.common.data.query.AlarmDataPageLink;
 import org.thingsboard.server.common.data.query.AlarmDataQuery;
+import org.thingsboard.server.common.data.query.DeviceTypeFilter;
 import org.thingsboard.server.common.data.relation.EntityRelation;
 import org.thingsboard.server.common.data.relation.EntityRelationsQuery;
 import org.thingsboard.server.common.data.relation.EntitySearchDirection;
@@ -60,7 +60,6 @@ import javax.annotation.PreDestroy;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
-import java.util.Comparator;
 import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Set;
@@ -316,37 +315,16 @@ public class BaseAlarmService extends AbstractEntityService implements AlarmServ
     @Override
     public AlarmSeverity findHighestAlarmSeverity(TenantId tenantId, EntityId entityId, AlarmSearchStatus alarmSearchStatus,
                                                   AlarmStatus alarmStatus) {
-        TimePageLink nextPageLink = new TimePageLink(100);
-        boolean hasNext = true;
-        AlarmSeverity highestSeverity = null;
-        AlarmQuery query;
-        while (hasNext && AlarmSeverity.CRITICAL != highestSeverity) {
-            query = new AlarmQuery(entityId, nextPageLink, alarmSearchStatus, alarmStatus, false, null);
-            PageData<AlarmInfo> alarms = alarmDao.findAlarms(tenantId, query);
-            if (alarms.hasNext()) {
-                nextPageLink = nextPageLink.nextPageLink();
-            }
-            AlarmSeverity severity = detectHighestSeverity(alarms.getData());
-            if (severity == null) {
-                continue;
-            }
-            if (severity == AlarmSeverity.CRITICAL || highestSeverity == null) {
-                highestSeverity = severity;
-            } else {
-                highestSeverity = highestSeverity.compareTo(severity) < 0 ? highestSeverity : severity;
-            }
+        Set<AlarmStatus> statusList = null;
+        if (alarmSearchStatus != null) {
+            statusList = alarmSearchStatus.getStatuses();
+        } else if (alarmStatus != null) {
+            statusList = Collections.singleton(alarmStatus);
         }
-        return highestSeverity;
-    }
 
-    private AlarmSeverity detectHighestSeverity(List<AlarmInfo> alarms) {
-        if (!alarms.isEmpty()) {
-            List<AlarmInfo> sorted = new ArrayList(alarms);
-            sorted.sort(Comparator.comparing(Alarm::getSeverity));
-            return sorted.get(0).getSeverity();
-        } else {
-            return null;
-        }
+        Set<AlarmSeverity> alarmSeverities = alarmDao.findAlarmSeverities(tenantId, entityId, statusList);
+
+        return alarmSeverities.stream().min(AlarmSeverity::compareTo).orElse(null);
     }
 
     private void deleteRelation(TenantId tenantId, EntityRelation alarmRelation) {

@@ -20,6 +20,7 @@ import org.springframework.data.domain.Pageable;
 import org.springframework.data.jpa.repository.Query;
 import org.springframework.data.repository.CrudRepository;
 import org.springframework.data.repository.query.Param;
+import org.thingsboard.server.common.data.alarm.AlarmSeverity;
 import org.thingsboard.server.common.data.alarm.AlarmStatus;
 import org.thingsboard.server.dao.model.sql.AlarmEntity;
 import org.thingsboard.server.dao.model.sql.AlarmInfoEntity;
@@ -75,4 +76,12 @@ public interface AlarmRepository extends CrudRepository<AlarmEntity, UUID> {
                                      @Param("searchText") String searchText,
                                      Pageable pageable);
 
+    @Query("SELECT alarm.severity FROM AlarmEntity alarm" +
+            " WHERE alarm.tenantId = :tenantId" +
+            " AND alarm.originatorId = :entityId" +
+            " AND ((:status) IS NULL OR alarm.status in (:status))")
+    Set<AlarmSeverity> findAlarmSeverities(@Param("tenantId") UUID tenantId,
+                                           @Param("entityId") UUID entityId,
+                                           @Param("status") Set<AlarmStatus> status);
+
 }

@@ -24,6 +24,7 @@ import org.springframework.stereotype.Component;
 import org.thingsboard.server.common.data.alarm.Alarm;
 import org.thingsboard.server.common.data.alarm.AlarmInfo;
 import org.thingsboard.server.common.data.alarm.AlarmQuery;
+import org.thingsboard.server.common.data.alarm.AlarmSeverity;
 import org.thingsboard.server.common.data.alarm.AlarmStatus;
 import org.thingsboard.server.common.data.id.CustomerId;
 import org.thingsboard.server.common.data.id.EntityId;
@@ -120,4 +121,9 @@ public class JpaAlarmDao extends JpaAbstractDao<AlarmEntity, Alarm> implements A
     public PageData<AlarmData> findAlarmDataByQueryForEntities(TenantId tenantId, CustomerId customerId, AlarmDataQuery query, Collection<EntityId> orderedEntityIds) {
         return alarmQueryRepository.findAlarmDataByQueryForEntities(tenantId, customerId, query, orderedEntityIds);
     }
+
+    @Override
+    public Set<AlarmSeverity> findAlarmSeverities(TenantId tenantId, EntityId entityId, Set<AlarmStatus> status) {
+        return alarmRepository.findAlarmSeverities(tenantId.getId(), entityId.getId(), status);
+    }
 }

@@ -116,16 +116,16 @@ public class CassandraBaseTimeseriesDao extends AbstractCassandraBaseTimeseriesD
         super.startExecutor();
         if (!isInstall()) {
             getFetchStmt(Aggregation.NONE, DESC_ORDER);
-            Optional<NoSqlTsPartitionDate> partition = NoSqlTsPartitionDate.parse(partitioning);
-            if (partition.isPresent()) {
-                tsFormat = partition.get();
-                if (!isFixedPartitioning() && partitionsCacheSize > 0) {
-                    cassandraTsPartitionsCache = new CassandraTsPartitionsCache(partitionsCacheSize);
-                }
-            } else {
-                log.warn("Incorrect configuration of partitioning {}", partitioning);
-                throw new RuntimeException("Failed to parse partitioning property: " + partitioning + "!");
+        }
+        Optional<NoSqlTsPartitionDate> partition = NoSqlTsPartitionDate.parse(partitioning);
+        if (partition.isPresent()) {
+            tsFormat = partition.get();
+            if (!isFixedPartitioning() && partitionsCacheSize > 0) {
+                cassandraTsPartitionsCache = new CassandraTsPartitionsCache(partitionsCacheSize);
             }
+        } else {
+            log.warn("Incorrect configuration of partitioning {}", partitioning);
+            throw new RuntimeException("Failed to parse partitioning property: " + partitioning + "!");
         }
     }
 

@@ -355,6 +355,62 @@ public abstract class BaseAlarmServiceTest extends AbstractServiceTest {
     }
 
     @Test
+    public void testFindHighestAlarmSeverity() throws ExecutionException, InterruptedException {
+        Customer customer = new Customer();
+        customer.setTitle("TestCustomer");
+        customer.setTenantId(tenantId);
+        customer = customerService.saveCustomer(customer);
+
+        Device customerDevice = new Device();
+        customerDevice.setName("TestCustomerDevice");
+        customerDevice.setType("default");
+        customerDevice.setTenantId(tenantId);
+        customerDevice.setCustomerId(customer.getId());
+        customerDevice = deviceService.saveDevice(customerDevice);
+
+        // no one alarms was created
+        Assert.assertNull(alarmService.findHighestAlarmSeverity(tenantId, customerDevice.getId(), null, null));
+
+        Alarm alarm1 = Alarm.builder()
+                .tenantId(tenantId)
+                .originator(customerDevice.getId())
+                .type(TEST_ALARM)
+                .severity(AlarmSeverity.MAJOR)
+                .status(AlarmStatus.ACTIVE_UNACK)
+                .startTs(System.currentTimeMillis())
+                .build();
+        alarm1 = alarmService.createOrUpdateAlarm(alarm1).getAlarm();
+        alarmService.clearAlarm(tenantId, alarm1.getId(), null, System.currentTimeMillis()).get();
+
+        Alarm alarm2 = Alarm.builder()
+                .tenantId(tenantId)
+                .originator(customerDevice.getId())
+                .type(TEST_ALARM)
+                .severity(AlarmSeverity.MINOR)
+                .status(AlarmStatus.ACTIVE_ACK)
+                .startTs(System.currentTimeMillis())
+                .build();
+        alarm2 = alarmService.createOrUpdateAlarm(alarm2).getAlarm();
+        alarmService.clearAlarm(tenantId, alarm2.getId(), null, System.currentTimeMillis()).get();
+
+        Alarm alarm3 = Alarm.builder()
+                .tenantId(tenantId)
+                .originator(customerDevice.getId())
+                .type(TEST_ALARM)
+                .severity(AlarmSeverity.CRITICAL)
+                .status(AlarmStatus.ACTIVE_ACK)
+                .startTs(System.currentTimeMillis())
+                .build();
+        alarm3 = alarmService.createOrUpdateAlarm(alarm3).getAlarm();
+
+        Assert.assertEquals(AlarmSeverity.MAJOR, alarmService.findHighestAlarmSeverity(tenantId, customerDevice.getId(), AlarmSearchStatus.UNACK, null));
+        Assert.assertEquals(AlarmSeverity.CRITICAL, alarmService.findHighestAlarmSeverity(tenantId, customerDevice.getId(), null, null));
+        Assert.assertEquals(AlarmSeverity.MAJOR, alarmService.findHighestAlarmSeverity(tenantId, customerDevice.getId(), null, AlarmStatus.CLEARED_UNACK));
+        Assert.assertEquals(AlarmSeverity.CRITICAL, alarmService.findHighestAlarmSeverity(tenantId, customerDevice.getId(), AlarmSearchStatus.ACTIVE, null));
+        Assert.assertEquals(AlarmSeverity.MINOR, alarmService.findHighestAlarmSeverity(tenantId, customerDevice.getId(), null, AlarmStatus.CLEARED_ACK));
+    }
+
+    @Test
     public void testFindAlarmUsingAlarmDataQuery() throws ExecutionException, InterruptedException {
         AssetId parentId = new AssetId(Uuids.timeBased());
         AssetId parentId2 = new AssetId(Uuids.timeBased());

@@ -1170,7 +1170,7 @@ public class RestClient implements ClientHttpRequestInterceptor, Closeable {
 
     public List<EntitySubtype> getDeviceTypes() {
         return restTemplate.exchange(
-                baseURL + "/api/devices",
+                baseURL + "/api/device/types",
                 HttpMethod.GET,
                 HttpEntity.EMPTY,
                 new ParameterizedTypeReference<List<EntitySubtype>>() {

@@ -54,7 +54,10 @@
         "share-via": "Sdílet přes {{provider}}",
         "continue": "Pokračovat",
         "discard-changes": "Zahodit změny",
-        "download": "Stáhnout"
+        "download": "Stáhnout",
+        "next-with-label": "Další: {{label}}",
+        "read-more": "Zobrazit více",
+        "hide": "Skrýt"
     },
     "aggregation": {
         "aggregation": "Agregace",
@@ -77,6 +80,8 @@
         "test-mail-sent": "Testovací zpráva byla úspěšně odeslána!",
         "base-url": "Základní URL",
         "base-url-required": "Hodnota Základní URL je povinná.",
+        "prohibit-different-url": "Zakázat použití názvu hosta z hlaviček požadavku klienta",
+        "prohibit-different-url-hint": "Toto nastavení by mělo být povoleno v produkčních prostředích. Pokud je zakázáno, může způsobit bezpečnostní problémy",
         "mail-from": "Email od",
         "mail-from-required": "Hodnota Email od je povinná.",
         "smtp-protocol": "SMTP protokol",
@@ -99,6 +104,33 @@
         "proxy-user": "Uživatel proxy",
         "proxy-password": "Heslo proxy",
         "send-test-mail": "Odeslat testovací zprávu",
+        "sms-provider": "Poskytovatel SMS",
+        "sms-provider-settings": "Nastavení poskytovatele SMS",
+        "sms-provider-type": "Typ poskytovatele SMS",
+        "sms-provider-type-required": "Typ poskytovatele SMS je povinný.",
+        "sms-provider-type-aws-sns": "Amazon SNS",
+        "sms-provider-type-twilio": "Twilio",
+        "aws-access-key-id": "AWS Access Key ID",
+        "aws-access-key-id-required": "AWS Access Key ID je povinný",
+        "aws-secret-access-key": "AWS Secret Access Key",
+        "aws-secret-access-key-required": "AWS Secret Access Key je povinný",
+        "aws-region": "AWS Region",
+        "aws-region-required": "AWS Region je povinný",
+        "number-from": "Telefonní číslo odesílatele",
+        "number-from-required": "Telefonní číslo Odesílatele je povinné.",
+        "number-to": "Telefonní číslo příjemce",
+        "number-to-required": "Telefonní číslo příjemce je povinné.",
+        "phone-number-hint": "Telefonní číslo ve formátu E.164, např. +19995550123",
+        "phone-number-pattern": "Neplatné telefonní číslo. Mělo by odpovídat formátu E.164, např. +19995550123.",
+        "sms-message": "SMS zpráva",
+        "sms-message-required": "SMS zpráva je povinná.",
+        "sms-message-max-length": "SMS zpráva nemůže být delší než 1600 znaků",
+        "twilio-account-sid": "Twilio Account SID",
+        "twilio-account-sid-required": "Twilio Account SID je povinné",
+        "twilio-account-token": "Twilio Account Token",
+        "twilio-account-token-required": "Twilio Account Token je povinný",
+        "send-test-sms": "Odeslat testovací SMS",
+        "test-sms-sent": "Testovací SMS úspěšně odeslána!",
         "security-settings": "Bezpečnostní nastavení",
         "password-policy": "Politika hesel",
         "minimum-password-length": "Minimální délka hesla",
@@ -119,8 +151,74 @@
         "general-policy": "Obecná politika",
         "max-failed-login-attempts": "Maximální počet neúspěšných pokusů o přihlášení před zablokováním účtu",
         "minimum-max-failed-login-attempts-range": "Maximální počet neúspěšných pokusů o přihlášení před zablokováním účtu nemůže být záporný",
-        "user-lockout-notification-email": "V případě zablokování uživatelského účtu odeslat upozornění na email"
-    },
+        "user-lockout-notification-email": "V případě zablokování uživatelského účtu odeslat upozornění na email",
+        "domain-name": "Doménové jméno",
+        "domain-name-unique": "Doménové jméno a protokol musí být unikátní.",
+        "error-verification-url": "Doménové jméno by nemělo obsahovat symbol '/' ani ':'. Příklad: thingsboard.io",
+        "oauth2": {
+          "access-token-uri": "URI přístupového tokenu",
+          "access-token-uri-required": "URI přístupového tokenu je povinné.",
+          "activate-user": "Aktivovat uživatele",
+          "add-domain": "Přidat doménu",
+          "delete-domain": "Smazat doménu",
+          "add-provider": "Přidat poskytovatele",
+          "delete-provider": "Smazat poskytovatele",
+          "allow-user-creation": "Povolit vytvoření uživatele",
+          "always-fullscreen": "Vždy v režimu celé obrazovky",
+          "authorization-uri": "Autorizační URI",
+          "authorization-uri-required": "Autorizační URI je povinné.",
+          "client-authentication-method": "Metoda autentizace klienta",
+          "client-id": "ID klienta",
+          "client-id-required": "ID klienta je povinné.",
+          "client-secret": "Heslo klienta",
+          "client-secret-required": "Heslo klienta je povinné.",
+          "custom-setting": "Vlastní nastavení",
+          "customer-name-pattern": "Vzor názvu zákazníka",
+          "default-dashboard-name": "Název defaultního dashboardu",
+          "delete-domain-text": "Budťe opatrní, protože po potvrzení nebudou doména ani žádná data poskytovatele dostupné.",
+          "delete-domain-title": "Jste si jisti, že chcete smazat nastavení domény '{{domainName}}'?",
+          "delete-registration-text": "Buďte opatrní, protože po potvrzení nebudou data poskytovatele dostupná.",
+          "delete-registration-title": "Jste si jisti, že chcete smazat poskytovatele '{{name}}'?",
+          "email-attribute-key": "Atribut klíče email",
+          "email-attribute-key-required": "Atribut klíče email je povinný.",
+          "first-name-attribute-key": "Atribut klíče jméno",
+          "general": "Obecné",
+          "jwk-set-uri": "JSON Web Key URI",
+          "last-name-attribute-key": "Atribut klíče příjmení",
+          "login-button-icon": "Ikona tlačítka přihlášení",
+          "login-button-label": "Označení poskytovatele",
+          "login-button-label-placeholder": "Přihlásit se přes $(Provider label)",
+          "login-button-label-required": "Označení je povinné.",
+          "login-provider": "Poskytovatel přihlášení",
+          "mapper": "Mapper",
+          "new-domain": "Nová doména",
+          "oauth2": "OAuth2",
+          "redirect-uri-template": "Šablona URI přesměrování",
+          "copy-redirect-uri": "Zkopírovat URI přesměrování",
+          "registration-id": "ID registrace",
+          "registration-id-required": "ID registrace je povinné.",
+          "registration-id-unique": "Id registrace musí být v systému unikátní.",
+          "scope": "Rozsah",
+          "scope-required": "Rozsah je povinný.",
+          "tenant-name-pattern": "Vzor názvu tenanta",
+          "tenant-name-pattern-required": "Vzor názvu tenanta je povinný.",
+          "tenant-name-strategy": "Strategie názvu tenanta",
+          "type": "Typ mapperu",
+          "uri-pattern-error": "Neplatný formát URI.",
+          "url": "URL",
+          "url-pattern": "Neplatný formát URL.",
+          "url-required": "URL je povinná.",
+          "user-info-uri": "User info URI",
+          "user-info-uri-required": "User info URI je povinné.",
+          "user-name-attribute-name": "Atribut klíče název uživatele",
+          "user-name-attribute-name-required": "Atribut klíče název uživatele je povinný",
+          "protocol": "Protokol",
+          "domain-schema-http": "HTTP",
+          "domain-schema-https": "HTTPS",
+          "domain-schema-mixed": "HTTP+HTTPS",
+          "enable": "Povolit nastavení OAuth2"
+        }
+      },
     "alarm": {
         "alarm": "Alarm",
         "alarms": "Alarmy",
@@ -128,6 +226,8 @@
         "no-alarms-matching": "Žádné alarmy odpovídající '{{entity}}' nebyly nalezeny.",
         "alarm-required": "Alarm je povinný",
         "alarm-status": "Stav alarmu",
+        "alarm-status-list": "Seznam stavů alarmu",
+        "any-status": "Všechny stavy",
         "search-status": {
             "ANY": "Všechny",
             "ACTIVE": "Aktivní",
@@ -154,6 +254,8 @@
         "end-time": "Datum ukončení",
         "ack-time": "Datum přijetí",
         "clear-time": "Datum vyřešení",
+        "alarm-severity-list": "Seznam závažností alarmu",
+        "any-severity": "Všechny závažnosti",
         "severity-critical": "Kritická",
         "severity-major": "Vysoká",
         "severity-minor": "Nízká",
@@ -176,12 +278,16 @@
         "clear-alarm-title": "Odstranit alarm",
         "clear-alarm-text": "Jste si jisti, že chcete alarm odstranit?",
         "alarm-status-filter": "Filtr stavu alarmu",
+        "alarm-filter": "Filtr alarmu",
         "max-count-load": "Maximální počet nahraných alarmů (0 - neomezeně)",
         "max-count-load-required": "Maximální počet nahraných alarmů je povinný.",
         "max-count-load-error-min": "Minimální hodnota je 0.",
         "fetch-size": "Velikost dávky",
         "fetch-size-required": "Velikost dávky je povinná.",
-        "fetch-size-error-min": "Minimální hodnota je 10."
+        "fetch-size-error-min": "Minimální hodnota je 10.",
+        "alarm-type-list": "Seznam typů alarmu",
+        "any-type": "Všechny typy",
+        "search-propagated-alarms": "Vyhledat zpropagované alarmy"
     },
     "alias": {
         "add": "Přidat alias",
@@ -211,6 +317,7 @@
         "filter-type-device-search-query-description": "Zařízení typů {{deviceTypes}} se {{relationType}} vztahem {{direction}} {{rootEntity}}",
         "filter-type-entity-view-search-query": "Dotaz na vyhledání zobrazení entity",
         "filter-type-entity-view-search-query-description": "Entitní pohledy typů {{entityViewTypes}} se {{relationType}} vztahem {{direction}} {{rootEntity}}",
+        "filter-type-apiUsageState": "Stav využití Api",
         "entity-filter": "Filtr entity",
         "resolve-multiple": "Použít jako více entit",
         "filter-type": "Typ filtru",
@@ -325,6 +432,59 @@
         "no-attributes-text": "Žádné atributy nebyly nalezeny",
         "no-telemetry-text": "Žádná telemetrie nebyla nalezena"
     },
+    "api-usage": {
+        "api-usage": "Využití Api",
+        "data-points": "Datové body",
+        "data-points-storage-days": "Dny uložení datových bodů",
+        "email": "Email",
+        "email-messages": "Emailové zprávy",
+        "email-messages-daily-activity": "Denní aktivita emailových zpráv",
+        "email-messages-hourly-activity": "Hodinová aktivita emailových zpráv",
+        "email-messages-monthly-activity": "Měsíční aktivita emailových zpráv",
+        "exceptions": "Výjimky",
+        "executions": "Zpracování",
+        "javascript": "JavaScript",
+        "javascript-executions": "JavaScript výjimky",
+        "javascript-functions": "JavaScript funkce",
+        "javascript-functions-daily-activity": "Denní aktivita JavaScript funkcí",
+        "javascript-functions-hourly-activity": "Hodinová aktivita JavaScript funkcí",
+        "javascript-functions-monthly-activity": "Měsíční aktivita JavaScript funkcí",
+        "latest-error": "Poslední chyba",
+        "messages": "Zprávy",
+        "permanent-failures": "${entityName} permanentní chyby",
+        "permanent-timeouts": "${entityName} permanentní timeouty",
+        "processing-failures": "${entityName} chyby zpracování",
+        "processing-failures-and-timeouts": "Chyby a timeouty zpracování",
+        "processing-timeouts": "${entityName} timeouty zpracování",
+        "queue-stats": "Statistiky fronty",
+        "rule-chain": "Řetěz pravidel",
+        "rule-engine": "Engine pro zpracování pravidel",
+        "rule-engine-daily-activity": "Denní aktivita enginu pro zpracování pravidel",
+        "rule-engine-executions": "Zpracování Enginu pro zpracování pravidel",
+        "rule-engine-hourly-activity": "Hodinová aktivita enginu pro zpracování pravidel",
+        "rule-engine-monthly-activity": "Měsíční aktivita enginu pro zpracování pravidel",
+        "rule-engine-statistics": "Statistiky enginu pro zpracování pravidel",
+        "rule-node": "Uzel pravidla",
+        "sms": "SMS",
+        "sms-messages": "SMS zprávy",
+        "sms-messages-daily-activity": "Denní aktivita SMS zpráv",
+        "sms-messages-hourly-activity": "Hodinová aktivita SMS zpráv",
+        "sms-messages-monthly-activity": "Měsíční aktivita SMS zpráv",
+        "successful": "${entityName} úspěšnost",
+        "telemetry": "Telemetrie",
+        "telemetry-persistence": "Uložení telemetrie",
+        "telemetry-persistence-daily-activity": "Denní aktivita uložení telemetrie",
+        "telemetry-persistence-hourly-activity": "Hodinová aktivita uložení telemetrie",
+        "telemetry-persistence-monthly-activity": "Měsíční aktivita uložení telemetrie",
+        "transport": "Přenos",
+        "transport-daily-activity": "Denní aktivita přenosu",
+        "transport-data-points": "Datové body přenosu",
+        "transport-hourly-activity": "Hodinová aktivita přenosu",
+        "transport-messages": "Zprávy přenosu",
+        "transport-monthly-activity": "Měsíční aktivita přenosu",
+        "view-details": "Zobrazit detail",
+        "view-statistics": "Zobrazit statistiky"
+    },
     "audit-log": {
         "audit": "Audit",
         "audit-logs": "Záznamy auditu",
@@ -363,7 +523,13 @@
         "action-data": "Data akce",
         "failure-details": "Detail chyby",
         "search": "Prohledat záznamy auditu",
-        "clear-search": "Vymazat vyhledávání"
+        "clear-search": "Vymazat vyhledávání",
+        "type-assigned-from-tenant": "Odebráno tenantovi",
+        "type-assigned-to-tenant": "Přiřazeno tenantovi",
+        "type-provision-success": "Zřízení zařízení",
+        "type-provision-failure": "Selhání zřízení zařízení",
+        "type-timeseries-updated": "Aktualizace telemetrie",
+        "type-timeseries-deleted": "Smazání telemetrie"
     },
     "confirm-on-exit": {
         "message": "Některé změny nebyly uloženy. Jste si jisti, že chcete tuto stránku opustit?",
@@ -549,6 +715,7 @@
         "title-color": "Barva názvu",
         "display-dashboards-selection": "Zobrazit výběr dashboardů",
         "display-entities-selection": "Zobrazit výběr entit",
+        "display-filters": "Zobrazit filtry",
         "display-dashboard-timewindow": "Zobrazit časové okno",
         "display-dashboard-export": "Zobrazit export",
         "import": "Importovat dashboard",
@@ -615,6 +782,7 @@
         "alarm": "Pole alarmu",
         "timeseries-required": "Časové řady entity jsou povinné.",
         "timeseries-or-attributes-required": "Časové řady / atributy entity jsou povinné.",
+        "alarm-fields-timeseries-or-attributes-required": "Pole alarmu nebo časové řady / atributy jsou povinné.",
         "maximum-timeseries-or-attributes": "Maximálně { count, plural, 1 {1 časová řada/atribut je povolena.} other {# časových řad/atributů je povoleno} }",
         "alarm-fields-required": "Pole alarmu jsou povinná.",
         "function-types": "Typy funkcí",
@@ -706,6 +874,12 @@
         "access-token-invalid": "Délka přístupového tokenu musí být od 1 do 20 znaků.",
         "rsa-key": "RSA veřejný klíč",
         "rsa-key-required": "RSA veřejný klíč je povinný.",
+        "client-id": "ID klienta",
+        "client-id-pattern": "Obsahuje neplatné znaky.",
+        "user-name": "Název uživatele",
+        "user-name-required": "Název uživatele je povinný.",
+        "client-id-or-user-name-necessary": "ID klienta a/nebo název uživatele jsou povinné",
+        "password": "Heslo",
         "secret": "Heslo",
         "secret-required": "Heslo je povinné.",
         "device-type": "Typ zařízení",
@@ -724,19 +898,183 @@
         "details": "Detail",
         "copyId": "Kopírovat Id zařízení",
         "copyAccessToken": "Kopírovat přístupový token",
+        "copy-mqtt-authentication": "Kopírovat přístupové údaje MQTT",
         "idCopiedMessage": "Id zařízení bylo zkopírováno do schránky",
         "accessTokenCopiedMessage": "Přístupový token zařízení byl zkopírován do schránky",
+        "mqtt-authentication-copied-message": "MQTT autentizace zařízení byla zkopírována do schránky",
         "assignedToCustomer": "Přiřazeno zákazníkovi",
         "unable-delete-device-alias-title": "Nebylo možné smazat alias zařízení",
         "unable-delete-device-alias-text": "Alias zařízení '{{deviceAlias}}' nelze smazat, protože je používán následujícími widgety:<br/>{{widgetsList}}",
         "is-gateway": "Je bránou",
+        "overwrite-activity-time": "Přepsat čas aktivity připojeného zařízení",
         "public": "Veřejné",
         "device-public": "Zařízení je veřejné",
         "select-device": "Vybrat zařízení",
         "import": "Importovat zařízení",
         "device-file": "Soubor zařízení",
         "search": "Vyhledat zařízení",
-        "selected-devices": "Vybráno { count, plural, 1 {1 zařízení} other {# zařízení} }"
+        "selected-devices": "Vybráno { count, plural, 1 {1 zařízení} other {# zařízení} }",
+        "device-configuration": "Konfigurace zařízení",
+        "transport-configuration": "Konfigurace přenosu",
+        "wizard": {
+            "device-wizard": "Průvodce zařízením",
+            "device-details": "Detail zařízení",
+            "new-device-profile": "Vytvořit nový profil zařízení",
+            "existing-device-profile": "Vybrat existující profil zařízení",
+            "specific-configuration": "Specifická konfigurace",
+            "customer-to-assign-device": "Přiřadit zařízení zákazníkovi",
+            "add-credential": "Přidat přístupový údaj"
+        }
+    },
+    "device-profile": {
+        "device-profile": "Profil zařízení",
+        "device-profiles": "Profily zařízení",
+        "all-device-profiles": "Všechny",
+        "add": "Přidat profil zařízení",
+        "edit": "Editovat profil zařízení",
+        "device-profile-details": "Detail profilu zařízení",
+        "no-device-profiles-text": "Žádné profily zařízení nebyly nalezeny",
+        "search": "Vyhledat profily zařízení",
+        "selected-device-profiles": "Vybráno { count, plural, 1 {1 profil zařízení} other {# profilů zařízení} }",
+        "no-device-profiles-matching": "Žádný profil zařízení odpovídající '{{entity}}' nebyl nalezen.",
+        "device-profile-required": "Profil zařízení je povinný",
+        "idCopiedMessage": "Id profilu zařízení bylo zkopírováno do schránky",
+        "set-default": "Učinit profil zařízení defaultním",
+        "delete": "Smazat profil zařízení",
+        "copyId": "Kopírovat Id profilu zařízení",
+        "new-device-profile-name": "Název profilu zařízení",
+        "new-device-profile-name-required": "Název profilu zařízení je povinný.",
+        "name": "Název",
+        "name-required": "Název je povinný.",
+        "type": "Typ profilu",
+        "type-required": "Typ profilu je povinný.",
+        "type-default": "Defaultní",
+        "transport-type": "Typ přenosu",
+        "transport-type-required": "Typ přenosu je povinný.",
+        "transport-type-default": "Defaultní",
+        "transport-type-default-hint": "Podporuje základní MQTT, HTTP and CoAP přenos",
+        "transport-type-mqtt": "MQTT",
+        "transport-type-mqtt-hint": "Umožňuje pokročilé nastavení MQTT přenosu",
+        "transport-type-lwm2m": "LWM2M",
+        "transport-type-lwm2m-hint": "Typ transportu LWM2M",
+        "description": "Popis",
+        "default": "Defaultní",
+        "profile-configuration": "Konfigurace profilu",
+        "transport-configuration": "Konfigurace přenosu",
+        "default-rule-chain": "Defaultní řetěz pravidel",
+        "select-queue-hint": "Vyberte z rozbalovacího seznamu nebo přidejte vlastní název.",
+        "delete-device-profile-title": "Jste si jisti, že chcete smazat profil zařízení '{{deviceProfileName}}'?",
+        "delete-device-profile-text": "Buďte opatrní, protože po potvrzení nebude možné profil zařízení ani žádná související data obnovit.",
+        "delete-device-profiles-title": "Jste si jisti, že chcete smazat { count, plural, 1 {1 profil zařízení} other {# profilů zařízení} }?",
+        "delete-device-profiles-text": "Buďte opatrní, protože po potvrzení budou všechny vybrané profily zařízení odstraněny a žádná související data nebude možné obnovit.",
+        "set-default-device-profile-title": "Jste si jisti, že chcete profil zařízení '{{deviceProfileName}}' učinit defaultním?",
+        "set-default-device-profile-text": "Po potvrzení bude profil zařízení označen jako defaultní a bude použit pro nová zařízení bez specifikovaného profilu.",
+        "no-device-profiles-found": "Žádné profily zařízení nebyly nalezeny.",
+        "create-new-device-profile": "Vytvořit nový!",
+        "mqtt-device-topic-filters": "Filtry MQTT fronty zařízení",
+        "mqtt-device-topic-filters-unique": "Filtry MQTT fronty zařízení musí být unikátní.",
+        "mqtt-device-payload-type": "MQTT zpráva zařízení",
+        "mqtt-device-payload-type-json": "JSON",
+        "mqtt-device-payload-type-proto": "Protobuf",
+        "mqtt-payload-type-required": "Typ zprávy je povinný.",
+        "support-level-wildcards": "Jsou podporovány jednoúrovňové <code>[+]</code> a víceúrovňové <code>[#]</code> zástupné znaky.",
+        "telemetry-topic-filter": "Filtr fronty telemetrie",
+        "telemetry-topic-filter-required": "Filtr fronty telemetrie je povinný.",
+        "attributes-topic-filter": "Filtr atributů fronty",
+        "attributes-topic-filter-required": "Filtr atributů fronty je povinný.",
+        "telemetry-proto-schema": "Proto schéma telemetrie",
+        "telemetry-proto-schema-required": "Proto schéma telemetrie je povinné.",
+        "attributes-proto-schema": "Atributy proto schémata",
+        "attributes-proto-schema-required": "Atributy proto schémata jsou povinné.",
+        "rpc-response-topic-filter": "Filtr fronty RPC odpovědi",
+        "rpc-response-topic-filter-required": "Filtr fronty RPC odpovědi je povinný.",
+        "not-valid-pattern-topic-filter": "Neplatný vzor filtru fronty",
+        "not-valid-single-character": "Neplatné použití jednoúrovňového zástupného znaku",
+        "not-valid-multi-character": "Neplatné použití víceúrovňového zástupného znaku",
+        "single-level-wildcards-hint": "<code>[+]</code> je vhodný pro jakoukoli úroveň filtru fronty. Př.: <b>v1/devices/+/telemetry</b> or <b>+/devices/+/attributes</b>.",
+        "multi-level-wildcards-hint": "<code>[#]</code> může nahradit filtr fronty a může se jednat o poslední symbol fronty. Př.: <b>#</b> or <b>v1/devices/me/#</b>.",
+        "alarm-rules": "Pravidla alarmu",
+        "alarm-rules-with-count": "Pravidla alarmu ({{count}})",
+        "no-alarm-rules": "Žádná pravidla alarmu nejsou konfigurována",
+        "add-alarm-rule": "Přidat pravidlo alarmu",
+        "edit-alarm-rule": "Editovat pravidlo alarmu",
+        "alarm-type": "Typ alarmu",
+        "alarm-type-required": "Typ alarmu je povinný.",
+        "alarm-type-unique": "Typ alarmu musí být v rámci pravidel alarmu profilu zařízení unikátní.",
+        "create-alarm-pattern": "Vytvořit <b>{{alarmType}}</b> alarm",
+        "create-alarm-rules": "Vytvořit pravidla alarmu",
+        "no-create-alarm-rules": "Nejsou konfigurovány žádné podmínky vytvoření",
+        "add-create-alarm-rule-prompt": "Přidejte prosím pravidlo vytvoření alarmu",
+        "clear-alarm-rule": "Pravidlo zrušení alarmu",
+        "no-clear-alarm-rule": "Není konfigurována žádná podmínka zrušení",
+        "add-create-alarm-rule": "Přidat podmínku vytvoření",
+        "add-clear-alarm-rule": "Přidat podmínku zrušení",
+        "select-alarm-severity": "Vybrat závažnost alarmu",
+        "alarm-severity-required": "Závažnost alarmu je povinná.",
+        "condition-duration": "Doba trvání podmínky",
+        "condition-duration-value": "Hodnota doby trvání",
+        "condition-duration-time-unit": "Jednotka času",
+        "condition-duration-value-range": "Hodnota doby trvání musí být v rozsahu od 1 do 2147483647.",
+        "condition-duration-value-pattern": "Doba trvání musí být celé číslo.",
+        "condition-duration-value-required": "Doba trvání je povinná.",
+        "condition-duration-time-unit-required": "Jednotka času je povinná.",
+        "advanced-settings": "Pokročilá nastavení",
+        "alarm-rule-details": "Detail",
+        "add-alarm-rule-details": "Přidat detail",
+        "propagate-alarm": "Propagovat alarm",
+        "alarm-rule-relation-types-list": "Typy vztahů ke zpropagování",
+        "alarm-rule-relation-types-list-hint": "Pokud nejsou vybrány žádné typy vztahů, alarmy budou propagovány bez filtru typu vztahu.",
+        "alarm-details": "Detail alarmu",
+        "alarm-rule-condition": "Podmínka pravidla alarmu",
+        "enter-alarm-rule-condition-prompt": "Přidejte prosím podmínku pravidla alarmu",
+        "edit-alarm-rule-condition": "Editovat podmínku pravidla alarmu",
+        "device-provisioning": "Zřízení zařízení",
+        "provision-strategy": "Strategie zřízení",
+        "provision-strategy-required": "Strategie zřízení je povinná.",
+        "provision-strategy-disabled": "Zakázáno",
+        "provision-strategy-created-new": "Povolit vytváření nových zařízení",
+        "provision-strategy-check-pre-provisioned": "Zkontrolovat předvytvořená zařízení",
+        "provision-device-key": "Klíč pro zřízení zařízení",
+        "provision-device-key-required": "Klíč pro zřízení zařízení je povinný.",
+        "copy-provision-key": "Kopírovat klíč pro zřízení",
+        "provision-key-copied-message": "Klíč pro zřízení byl zkopírován do schránky",
+        "provision-device-secret": "Heslo pro zřízení zařízení",
+        "provision-device-secret-required": "Heslo pro zřízení zařízení je povinné.",
+        "copy-provision-secret": "Kopírovat heslo pro zřízení",
+        "provision-secret-copied-message": "Heslo pro zřízení zařízení bylo zkopírováno do schránky",
+        "condition": "Podmínka",
+        "condition-type": "Typ podmínky",
+        "condition-type-simple": "Jednoduchá",
+        "condition-type-duration": "Doba trvání",
+        "condition-during": "V průběhu {{during}}",
+        "condition-type-repeating": "Opakování",
+        "condition-type-required": "Typ podmínky je povinný.",
+        "condition-repeating-value": "Počet událostí",
+        "condition-repeating-value-range": "Počet událostí musí být v rozsahu od 1 do 2147483647.",
+        "condition-repeating-value-pattern": "Počet událostí musí být celé číslo.",
+        "condition-repeating-value-required": "Počet událostí je povinný.",
+        "condition-repeat-times": "Opakování { count, plural, 1 {1 krát} other {# krát} }",
+        "schedule-type": "Typ plánovače",
+        "schedule-type-required": "Typ plánovače je povinný.",
+        "schedule": "Časový plán",
+        "edit-schedule": "Editovat časový plán alarmu",
+        "schedule-any-time": "Aktivní neustále",
+        "schedule-specific-time": "Aktivní v konkrétním čase",
+        "schedule-custom": "Vlastní",
+        "schedule-day": {
+          "monday": "Pondělí",
+          "tuesday": "Úterý",
+          "wednesday": "Středa",
+          "thursday": "Čtvrtek",
+          "friday": "Pátek",
+          "saturday": "Sobota",
+          "sunday": "Neděle"
+        },
+        "schedule-days": "Dny",
+        "schedule-time": "Čas",
+        "schedule-time-from": "Od",
+        "schedule-time-to": "Do",
+        "schedule-days-of-week-required": "Musí být vybrán minimálně jeden den v týdnu."
     },
     "dialog": {
         "close": "Zavřít dialog"
@@ -757,7 +1095,7 @@
         "entity-alias": "Alias entity",
         "unable-delete-entity-alias-title": "Alias entity nebylo možné smazat",
         "unable-delete-entity-alias-text": "Alias entity '{{entityAlias}}' nelze smazat, protože je používán následujícími widgety:<br/>{{widgetsList}}",
-        "duplicate-alias-error": "Nalezen dupliticní alias '{{alias}}'.<br>Aliasy entit musí být v rámci dashboardu unikátní.",
+        "duplicate-alias-error": "Nalezen duplicitní alias '{{alias}}'.<br>Aliasy entit musí být v rámci dashboardu unikátní.",
         "missing-entity-filter-error": "Ve filtru chybí alias '{{alias}}'.",
         "configure-alias": "Konfigurovat '{{alias}}' alias",
         "alias": "Alias",
@@ -794,6 +1132,10 @@
         "type-devices": "Zařízení",
         "list-of-devices": "{ count, plural, 1 {Jedno zařízení} other {Seznam # zařízení} }",
         "device-name-starts-with": "Zařízení, jejichž název začíná '{{prefix}}'",
+        "type-device-profile": "Profil zařízení",
+        "type-device-profiles": "Profily zařízení",
+        "list-of-device-profiles": "{ count, plural, 1 {Jeden profil zařízení} other {Seznam # profilů zařízení} }",
+        "device-profile-name-starts-with": "Profily zařízení, jejichž název začíná '{{prefix}}'",
         "type-asset": "Aktivum",
         "type-assets": "Aktiva",
         "list-of-assets": "{ count, plural, 1 {Jedno aktivum} other {Seznam # aktiv} }",
@@ -814,6 +1156,10 @@
         "type-tenants": "Tenanti",
         "list-of-tenants": "{ count, plural, 1 {Jeden tenant} other {Seznam # tenantů} }",
         "tenant-name-starts-with": "Tenanti, jejichž název začíná '{{prefix}}'",
+        "type-tenant-profile": "Profil tenanta",
+        "type-tenant-profiles": "Profily tenantů",
+        "list-of-tenant-profiles": "{ count, plural, 1 {Jeden profil tenanta} other {Seznam # profilů tenantů} }",
+        "tenant-profile-name-starts-with": "Profily tenantů, jejichž název začíná '{{prefix}}'",
         "type-customer": "Zákazník",
         "type-customers": "Zákazníci",
         "list-of-customers": "{ count, plural, 1 {Jeden zákazník} other {Seznam # zákazníků} }",
@@ -840,6 +1186,8 @@
         "rulenode-name-starts-with": "Uzly pravidel, jejichž název začíná '{{prefix}}'",
         "type-current-customer": "Stávající zákazník",
         "type-current-tenant": "Stávající tenant",
+        "type-current-user": "Stávající uživatel",
+        "type-current-user-owner": "Vlastník stávajícího uživatele",
         "search": "Vyhledat entity",
         "selected-entities": "{ count, plural, 1 {1 entita} other {# entit} } zvoleno",
         "entity-name": "Název entity",
@@ -847,7 +1195,8 @@
         "details": "Detail entity",
         "no-entities-prompt": "Žádné entity nebyly nalezeny",
         "no-data": "Nelze zobrazit žádná data",
-        "columns-to-display": "Zobrazit sloupce"
+        "columns-to-display": "Zobrazit sloupce",
+        "type-api-usage-state": "Stav využití API"
     },
     "entity-field": {
         "created-time": "Datum vytvoření",
@@ -1048,7 +1397,7 @@
         "anonymous": "Anonymní",
         "basic": "Základní",
         "pem": "PEM",
-        "ca-cert": "soubor CA certifikátu *",
+        "ca-cert": "Soubor CA certifikátu *",
         "private-key": "Soubor privátního klíče *",
         "cert": "Soubor certifikátu *",
         "no-file": "Žádný soubor nebyl vybrán.",
@@ -1154,6 +1503,93 @@
         "file": "Soubor rozšíření",
         "invalid-file-error": "Neplatný soubor rozšíření"
     },
+    "filter": {
+        "add": "Přidat filtr",
+        "edit": "Editovat filtr",
+        "name": "Název filtru",
+        "name-required": "Název filtru je povinný.",
+        "duplicate-filter": "Filtr s identickým názvem již existuje.",
+        "filters": "Filtry",
+        "unable-delete-filter-title": "Smazat filtr není možné",
+        "unable-delete-filter-text": "Filtr '{{filter}}' není možné smazat, protože je používán následujícím widgetem(y):<br/>{{widgetsList}}",
+        "duplicate-filter-error": "Nalezen duplicitní filtr '{{filter}}'.<br>Filtry musí být v rámci dashboardu unikátní.",
+        "missing-key-filters-error": "U filtru '{{filter}}' chybí klíčové filtry.",
+        "filter": "Filtr",
+        "editable": "Editovatelné",
+        "no-filters-found": "Žádné filtry nebyly nalezeny.",
+        "no-filter-text": "Není specifikován žádný filtr",
+        "add-filter-prompt": "Přidejte prosím filtr",
+        "no-filter-matching": "'{{filter}}' nebyl nalezen.",
+        "create-new-filter": "Vytvořit nový!",
+        "filter-required": "Filtr je povinný.",
+        "operation": {
+          "operation": "Operace",
+          "equal": "je rovno",
+          "not-equal": "není rovno",
+          "starts-with": "začíná na",
+          "ends-with": "končí na",
+          "contains": "obsahuje",
+          "not-contains": "neobsahuje",
+          "greater": "větší než",
+          "less": "menší než",
+          "greater-or-equal": "větší nebo rovno",
+          "less-or-equal": "menší nebo rovno",
+          "and": "a",
+          "or": "nebo"
+        },
+        "ignore-case": "ignorovat velikost písmen",
+        "value": "Hodnota",
+        "remove-filter": "Odebrat filtr",
+        "preview": "Náhled filtru",
+        "no-filters": "Nejsou konfigurovány žádné filtry",
+        "add-filter": "Přidat filtr",
+        "add-complex-filter": "Přidat komplexní filtr",
+        "add-complex": "Přidat komplex",
+        "complex-filter": "Komplexní filtr",
+        "edit-complex-filter": "Editovat komplexní filtr",
+        "edit-filter-user-params": "Editovat filtr predikátu parametrů uživatele",
+        "filter-user-params": "Filtr predikátu parametrů uživatele",
+        "user-parameters": "Parametry uživatele",
+        "display-label": "Zobrazované označení",
+        "autogenerated-label": "Automaticky vygenerovat označení",
+        "order-priority": "Priority pořadí polí",
+        "key-filter": "Klíčový filtr",
+        "key-filters": "Klíčové filtry",
+        "key-name": "Název klíče",
+        "key-name-required": "Název klíče je povinný.",
+        "key-type": {
+          "key-type": "Typ klíče",
+          "attribute": "Atribut",
+          "timeseries": "Časové řady",
+          "entity-field": "Pole entity"
+        },
+        "value-type": {
+          "value-type": "Typ hodnoty",
+          "string": "Řetězec",
+          "numeric": "Číslo",
+          "boolean": "Pravdivostní hodnota",
+          "date-time": "Datum a čas"
+        },
+        "value-type-required": "Typ hodnoty klíče je povinný.",
+        "key-value-type-change-title": "Jste si jisti, že chcete změnit typ klíče hodnoty?",
+        "key-value-type-change-message": "Pokud potvrdíte nový typ hodnoty, všechny zadané klíčové filtry budou odstraněny.",
+        "no-key-filters": "Nejsou konfigurovány žádné klíčové filtry",
+        "add-key-filter": "Přidat klíčový filtr",
+        "remove-key-filter": "Odebrat klíčový filtr",
+        "edit-key-filter": "Editovat klíčový filtr",
+        "date": "Datum",
+        "time": "Čas",
+        "current-tenant": "Stávající tenant",
+        "current-customer": "Stávající zákazník",
+        "current-user": "Stávající uživatel",
+        "current-device": "Stávající zařízení",
+        "default-value": "Defaultní hodnota",
+        "dynamic-source-type": "Dynamický typ zdroje",
+        "no-dynamic-value": "Žádná dynamická hodnota",
+        "source-attribute": "Atribut zdroje",
+        "switch-to-dynamic-value": "Přepnout na dynamickou hodnotu",
+        "switch-to-default-value": "Přepnout na defaultní hodnotu"
+   },
     "fullscreen": {
         "expand": "Rozšířit do režimu celé obrazovky",
         "exit": "Ukončit režim celé obrazovky",
@@ -1286,6 +1722,7 @@
             "entity-field": "Pole entity",
             "access-token": "Přístupový token",
             "isgateway": "Je bránou",
+            "activity-time-from-gateway-device": "Čas aktivity ze zařízení brány",
             "description": "Popis"
         },
         "stepper-text":{
@@ -1329,6 +1766,7 @@
     "legend": {
         "direction": "Směr legendy",
         "position": "Pozice legendy",
+        "sort-legend": "Setřídit datové klíče v legendě",
         "show-max": "Zobrazit max hodnotu",
         "show-min": "Zobrazit min hodnotu",
         "show-avg": "Zobrazit průměrnou hodnotu",
@@ -1525,6 +1963,12 @@
         "help": "Nápověda",
         "reset-debug-mode": "Resetovat režim ladění na všech uzlech"
     },
+    "timezone": {
+        "timezone": "Časová zóna",
+        "select-timezone": "Vyberte časovou zónu",
+        "no-timezones-matching": "žádné časové zóny odpovídající '{{timezone}}' nebyly nalezeny.",
+        "timezone-required": "Časová zóna je povinná."
+      },
     "queue": {
       "select_name": "Vybrat název fronty",
       "name": "Název fronty",
@@ -1563,6 +2007,87 @@
         "isolated-tb-core-details": "Vyžaduje samostatnou mikroslužbu(y) pro každého izolovaného tenanta",
         "isolated-tb-rule-engine-details": "Vyžaduje samostatnou mikroslužbu(y) pro každého izolovaného tenanta"
     },
+    "tenant-profile": {
+        "tenant-profile": "Profil tenanta",
+        "tenant-profiles": "Profily tenantů",
+        "add": "Přidat profil tenanta",
+        "edit": "Editovat profil tenanta",
+        "tenant-profile-details": "Detail profilu tenanta",
+        "no-tenant-profiles-text": "Nebyly nalezeny žádné profily tenantů",
+        "search": "Vyhledat profily tenantů",
+        "selected-tenant-profiles": "Vybráno { count, plural, 1 {1 profilů tenantů} other {# profilů tenantů} }",
+        "no-tenant-profiles-matching": "Žádné profily tenantů odpovídající '{{entity}}' nebyly nalezeny.",
+        "tenant-profile-required": "Profil tenanta je povinný",
+        "idCopiedMessage": "Id profilu tenanta bylo zkopírováno do schránky",
+        "set-default": "Učinit profil tenanta defaultním",
+        "delete": "Smazat profil tenanta",
+        "copyId": "Kopírovat Id profilu tenanta",
+        "name": "Název",
+        "name-required": "Název je povinný.",
+        "data": "Data profilu",
+        "profile-configuration": "Konfigurace profilu",
+        "description": "Popis",
+        "default": "Defaultní",
+        "delete-tenant-profile-title": "Jste si jisti, že chcete smazat profil tenanta '{{tenantProfileName}}'?",
+        "delete-tenant-profile-text": "Buďte opatrní, protože po potvrzení nebude možné profil tenanta ani žádná související data obnovit.",
+        "delete-tenant-profiles-title": "Jste si jisti, že chcete smazat { count, plural, 1 {1 profil tenanta} other {# profilů tenanta} }?",
+        "delete-tenant-profiles-text": "Buďte opatrní, protože po potvrzení budou všechny vybrané profily tenantů odstraněny a žádná související data nebude možné obnovit.",
+        "set-default-tenant-profile-title": "Jste si jisti, že chcete učinit profil tenanta '{{tenantProfileName}}' defaultním?",
+        "set-default-tenant-profile-text": "Po potvrzení bude profil tenanta označen jako defaultní a bude použit pro nové tenanty bez specifikovaného profilu.",
+        "no-tenant-profiles-found": "Nebyly nalezeny žádné profily tenantů.",
+        "create-new-tenant-profile": "Vytvořit nový!",
+        "maximum-devices": "Maximální počet zařízení (0 - neomezeno)",
+        "maximum-devices-required": "Maximální počet zařízení je povinný.",
+        "maximum-devices-range": "Minimální počet zařízení nemůže být záporný",
+        "maximum-assets": "Maximální počet aktiv (0 - neomezeno)",
+        "maximum-assets-required": "Maximální počet aktiv je povinný.",
+        "maximum-assets-range": "Maximální počet aktiv nemůže být záporný",
+        "maximum-customers": "Maximální počet zákazníků (0 - neomezeno)",
+        "maximum-customers-required": "Maximální počet zákazníkůje povinný.",
+        "maximum-customers-range": "Maximální počet zákazníků nemůže být záporný",
+        "maximum-users": "Maximální počet uživatelů (0 - neomezeno)",
+        "maximum-users-required": "Maximální počet uživatelů je povinný.",
+        "maximum-users-range": "Maximální počet uživatelů nemůže být záporný",
+        "maximum-dashboards": "Maximální počet dashboardů (0 - neomezeno)",
+        "maximum-dashboards-required": "Maximální počet dashboardů je povinný.",
+        "maximum-dashboards-range": "Maximální počet dashboardů nemůže být záporný",
+        "maximum-rule-chains": "Maximální počet řetězů pravidel (0 - neomezeno)",
+        "maximum-rule-chains-required": "Maximální počet řetězů pravidel je povinný.",
+        "maximum-rule-chains-range": "Maximální počet řetězů pravidel nemůže být záporný",
+        "transport-tenant-msg-rate-limit": "Limit přenosu zpráv tenanta.",
+        "transport-tenant-telemetry-msg-rate-limit": "Limit přenosu zpráv telemetrie tenanta.",
+        "transport-tenant-telemetry-data-points-rate-limit": "Limit přenosu datových bodů telemetrie tenanta.",
+        "transport-device-msg-rate-limit": "Limit přenosu zpráv zařízení.",
+        "transport-device-telemetry-msg-rate-limit": "Limit přenosu zpráv zařízení telemetrie tenanta.",
+        "transport-device-telemetry-data-points-rate-limit": "Limit přenosu datových bodů zařízení telemetrie tenanta.",
+        "max-transport-messages": "Maximální počet zpráv přenosu (0 - neomezeno)",
+        "max-transport-messages-required": "Maximální počet zpráv přenosu je povinný.",
+        "max-transport-messages-range": "Maximální počet zpráv přenosu nemůže být záporný",
+        "max-transport-data-points": "Maximální počet datových bodů přenosu (0 - neomezeno)",
+        "max-transport-data-points-required": "Maximální počet datových bodů přenosu je povinný.",
+        "max-transport-data-points-range": "Maximální počet datových bodů přenosu nemůže být záporný",
+        "max-r-e-executions": "Maximální počet zpracování enginu pro zpracování pravidel (0 - neomezeno)",
+        "max-r-e-executions-required": "Maximální počet zpracování enginu pro zpracování pravidel je povinný.",
+        "max-r-e-executions-range": "Maximální počet zpracování enginu pro zpracování pravidel nemůže být záporný",
+        "max-j-s-executions": "Maximální počet JavaScript zpracování (0 - neomezeno)",
+        "max-j-s-executions-required": "Maximální počet JavaScript zpracování je povinný.",
+        "max-j-s-executions-range": "Maximální počet JavaScript zpracování nemůže být záporný",
+        "max-d-p-storage-days": "Maximální počet dnů uložení datových bodů (0 - neomezeno)",
+        "max-d-p-storage-days-required": "Maximální počet dnů uložení datových bodů je povinný.",
+        "max-d-p-storage-days-range": "Maximální počet dnů uložení datových bodů nemůže být záporný",
+        "default-storage-ttl-days": "Defaultní počet dnů TTL úložiště (0 - neomezeno)",
+        "default-storage-ttl-days-required": "Defaultní počet dnů TTL úložiště je povinný.",
+        "default-storage-ttl-days-range": "Defaultní počet dnů TTL úložiště nemůže být záporný",
+        "max-rule-node-executions-per-message": "Maximální počet zpracování uzlů pravidel na zprávu (0 - neomezeno)",
+        "max-rule-node-executions-per-message-required": "Maximální počet zpracování uzlů pravidel na zprávu je povinný.",
+        "max-rule-node-executions-per-message-range": "Maximální počet zpracování uzlů pravidel na zprávu nemůže být záporný",
+        "max-emails": "Maximální počet odeslaných emailů (0 - neomezeno)",
+        "max-emails-required": "Maximální počet odeslaných emailů je povinný.",
+        "max-emails-range": "Maximální počet odeslaných emailů nemůže být záporný",
+        "max-sms": "Maximální počet odeslaných SMS (0 - neomezeno)",
+        "max-sms-required": "Maximální počet odeslaných SMS je povinný.",
+        "max-sms-range": "Maximální počet odeslaných SMS nemůže být záporný"
+    },
     "timeinterval": {
         "seconds-interval": "{ seconds, plural, 1 {1 vteřina} other {# vteřin} }",
         "minutes-interval": "{ minutes, plural, 1 {1 minuta} other {# minut} }",
@@ -1574,8 +2099,14 @@
         "seconds": "Vteřiny",
         "advanced": "Rozšířené"
     },
+    "timeunit": {
+        "seconds": "Vteřiny",
+        "minutes": "Minuty",
+        "hours": "Hodiny",
+        "days": "Dny"
+    },
     "timewindow": {
-        "days": "{ days, plural, 1 { den } other {# days } }",
+        "days": "{ days, plural, 1 { den } other {# dnů } }",
         "hours": "{ hours, plural, 0 { hodina } 1 {1 hodina } other {# hodin } }",
         "minutes": "{ minutes, plural, 0 { minuta } 1 {1 minuta } other {# minut } }",
         "seconds": "{ seconds, plural, 0 { vteřina } 1 {1 vteřina } other {# vteřin } }",
@@ -1694,6 +2225,7 @@
         "type": "Typ widgetu",
         "resources": "Zdroje",
         "resource-url": "JavaScript/CSS URL",
+        "resource-is-module": "Je modulem",
         "remove-resource": "Odebrat zdroj",
         "add-resource": "Přidat zdroj",
         "html": "HTML",
@@ -1711,7 +2243,10 @@
         "widget-template-load-failed-error": "Nahrání šablony widgetu selhalo!",
         "add": "Přidat widget",
         "undo": "Vrátit změny widgetu",
-        "export": "Exportovat widget"
+        "export": "Exportovat widget",
+        "no-data": "Nejsou k dispozici žádná data pro zobrazení ve widgetu",
+        "data-overflow": "Widget zobrazuje {{count}} z {{total}} entit",
+        "alarm-data-overflow": "Widget zobrazuje alarmy {{allowedEntities}} (maxima možných) entit z {{totalEntities}} entit"
     },
     "widget-action": {
         "header-button": "Tlačítko hlavičky widgetu",
@@ -1724,7 +2259,14 @@
         "target-dashboard-state-required": "Cílový stav dashboardu je povinný",
         "set-entity-from-widget": "Nastavit entitu z widgetu",
         "target-dashboard": "Cílový dashboard",
-        "open-right-layout": "Otevřít rozmístění dashboardu vpravo (mobilní zobrazení)"
+        "open-right-layout": "Otevřít rozmístění dashboardu vpravo (mobilní zobrazení)",
+        "open-in-separate-dialog": "Otevřít v samostatném okně",
+        "dialog-title": "Název okna",
+        "dialog-hide-dashboard-toolbar": "Skrýt v okně nástrojovou lištu dashboardu",
+        "dialog-width": "Šířka okna v procentech vzhledem k šířce obrazovky",
+        "dialog-height": "Výška okna v procentech vzhledem k výšce obrazovky",
+        "dialog-size-range-error": "Hodnota procentuální velikosti musí být v rozsahu od 1 do 100.",
+        "open-new-browser-tab": "Otevřít na nové záložce prohlížeče"
     },
     "widgets-bundle": {
         "current": "Vybraná kategorie",
@@ -1891,8 +2433,11 @@
             "entity-coordinate-required": "Obě pole, zeměpisná šířka i zeměpisná délka, jsou povinná",
             "entity-timeseries-required": "Časové řady entity jsou povinné",
             "get-location": "Získat aktuální polohu",
+            "invalid-date": "Neplatné datum",
             "latitude": "Zeměpisná šířka",
             "longitude": "Zeměpisná délka",
+            "min-value-error": "Minimální hodnota je {{value}}",
+            "max-value-error": "Maximální hodnota je {{value}}",
             "not-allowed-entity": "Vybraná entita nemůže mít sdílené atributy",
             "no-attribute-selected": "Není vybrán žádný atribut",
             "no-datakey-selected": "Není vybrán žádný datový klíč",
@@ -1900,7 +2445,10 @@
             "no-entity-selected": "Není vybrána žádná entita",
             "no-image": "Žádný obrázek",
             "no-support-geolocation": "Váš prohlížeč nepodporuje geolokaci",
-            "no-support-web-camera": "Žádná podporovaná webová kamera",
+            "no-support-web-camera": "Váš prohlížeč nepodporuje kamery",
+            "enable-https-use-widget": "Prosím povolte HTTPS abyste mohli používat tento widget",
+            "no-found-your-camera": "Nelze nalézt vyši kameru",
+            "no-permission-camera": "Přístup byl zakázán uživatelem / Tato stránka nemá oprávnění použít kameru",
             "no-timeseries-selected": "Nejsou vybrány žádné časové řady",
             "secret-key": "Tajný klíč",
             "secret-key-required": "Tajný klíč je povinný",