diff --git a/application/src/main/java/org/thingsboard/server/controller/RuleChainController.java b/application/src/main/java/org/thingsboard/server/controller/RuleChainController.java index c1c06544ed..5c54c0232e 100644 --- a/application/src/main/java/org/thingsboard/server/controller/RuleChainController.java +++ b/application/src/main/java/org/thingsboard/server/controller/RuleChainController.java @@ -24,6 +24,7 @@ import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Value; import org.springframework.http.HttpStatus; import org.springframework.security.access.prepost.PreAuthorize; +import org.springframework.util.CollectionUtils; import org.springframework.util.StringUtils; import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.RequestBody; @@ -49,6 +50,8 @@ import org.thingsboard.server.common.data.page.PageLink; import org.thingsboard.server.common.data.plugin.ComponentLifecycleEvent; import org.thingsboard.server.common.data.rule.DefaultRuleChainCreateRequest; import org.thingsboard.server.common.data.rule.RuleChain; +import org.thingsboard.server.common.data.rule.RuleChainData; +import org.thingsboard.server.common.data.rule.RuleChainImportResult; import org.thingsboard.server.common.data.rule.RuleChainMetaData; import org.thingsboard.server.common.data.rule.RuleNode; import org.thingsboard.server.common.msg.TbMsg; @@ -386,6 +389,36 @@ public class RuleChainController extends BaseController { } } + @PreAuthorize("hasAuthority('TENANT_ADMIN')") + @RequestMapping(value = "/ruleChains/export", params = {"limit"}, method = RequestMethod.GET) + @ResponseBody + public RuleChainData exportRuleChains(@RequestParam("limit") int limit) throws ThingsboardException { + try { + TenantId tenantId = getCurrentUser().getTenantId(); + PageLink pageLink = new PageLink(limit); + return checkNotNull(ruleChainService.exportTenantRuleChains(tenantId, pageLink)); + } catch (Exception e) { + throw handleException(e); + } + } + + @PreAuthorize("hasAuthority('TENANT_ADMIN')") + @RequestMapping(value = "/ruleChains/import", method = RequestMethod.POST) + @ResponseBody + public void importRuleChains(@RequestBody RuleChainData ruleChainData, @RequestParam(required = false, defaultValue = "false") boolean overwrite) throws ThingsboardException { + try { + TenantId tenantId = getCurrentUser().getTenantId(); + List importResults = ruleChainService.importTenantRuleChains(tenantId, ruleChainData, overwrite); + if (!CollectionUtils.isEmpty(importResults)) { + for (RuleChainImportResult importResult : importResults) { + tbClusterService.onEntityStateChange(importResult.getTenantId(), importResult.getRuleChainId(), importResult.getLifecycleEvent()); + } + } + } catch (Exception e) { + throw handleException(e); + } + } + private String msgToOutput(TbMsg msg) throws Exception { ObjectNode msgData = objectMapper.createObjectNode(); if (!StringUtils.isEmpty(msg.getData())) { diff --git a/common/dao-api/src/main/java/org/thingsboard/server/dao/rule/RuleChainService.java b/common/dao-api/src/main/java/org/thingsboard/server/dao/rule/RuleChainService.java index 9d9ba00322..05fda67939 100644 --- a/common/dao-api/src/main/java/org/thingsboard/server/dao/rule/RuleChainService.java +++ b/common/dao-api/src/main/java/org/thingsboard/server/dao/rule/RuleChainService.java @@ -16,6 +16,7 @@ package org.thingsboard.server.dao.rule; import com.google.common.util.concurrent.ListenableFuture; +import org.thingsboard.server.common.data.exception.ThingsboardException; import org.thingsboard.server.common.data.id.RuleChainId; import org.thingsboard.server.common.data.id.RuleNodeId; import org.thingsboard.server.common.data.id.TenantId; @@ -23,6 +24,8 @@ import org.thingsboard.server.common.data.page.PageData; import org.thingsboard.server.common.data.page.PageLink; import org.thingsboard.server.common.data.relation.EntityRelation; import org.thingsboard.server.common.data.rule.RuleChain; +import org.thingsboard.server.common.data.rule.RuleChainData; +import org.thingsboard.server.common.data.rule.RuleChainImportResult; import org.thingsboard.server.common.data.rule.RuleChainMetaData; import org.thingsboard.server.common.data.rule.RuleNode; @@ -63,4 +66,8 @@ public interface RuleChainService { void deleteRuleChainsByTenantId(TenantId tenantId); + RuleChainData exportTenantRuleChains(TenantId tenantId, PageLink pageLink) throws ThingsboardException; + + List importTenantRuleChains(TenantId tenantId, RuleChainData ruleChainData, boolean overwrite); + } diff --git a/common/data/src/main/java/org/thingsboard/server/common/data/rule/RuleChainData.java b/common/data/src/main/java/org/thingsboard/server/common/data/rule/RuleChainData.java new file mode 100644 index 0000000000..e4b9ec3442 --- /dev/null +++ b/common/data/src/main/java/org/thingsboard/server/common/data/rule/RuleChainData.java @@ -0,0 +1,27 @@ +/** + * Copyright © 2016-2020 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.common.data.rule; + +import lombok.Data; + +import java.util.List; + +@Data +public class RuleChainData { + + List ruleChains; + List metadata; +} diff --git a/common/data/src/main/java/org/thingsboard/server/common/data/rule/RuleChainImportResult.java b/common/data/src/main/java/org/thingsboard/server/common/data/rule/RuleChainImportResult.java new file mode 100644 index 0000000000..53b899e04b --- /dev/null +++ b/common/data/src/main/java/org/thingsboard/server/common/data/rule/RuleChainImportResult.java @@ -0,0 +1,31 @@ +/** + * Copyright © 2016-2020 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.common.data.rule; + +import lombok.AllArgsConstructor; +import lombok.Data; +import org.thingsboard.server.common.data.id.RuleChainId; +import org.thingsboard.server.common.data.id.TenantId; +import org.thingsboard.server.common.data.plugin.ComponentLifecycleEvent; + +@Data +@AllArgsConstructor +public class RuleChainImportResult { + + private TenantId tenantId; + private RuleChainId ruleChainId; + private ComponentLifecycleEvent lifecycleEvent; +} diff --git a/dao/src/main/java/org/thingsboard/server/dao/rule/BaseRuleChainService.java b/dao/src/main/java/org/thingsboard/server/dao/rule/BaseRuleChainService.java index 9be9467fd8..9c5fb32da9 100644 --- a/dao/src/main/java/org/thingsboard/server/dao/rule/BaseRuleChainService.java +++ b/dao/src/main/java/org/thingsboard/server/dao/rule/BaseRuleChainService.java @@ -15,12 +15,16 @@ */ package org.thingsboard.server.dao.rule; +import com.datastax.oss.driver.api.core.uuid.Uuids; +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.node.ObjectNode; import com.google.common.util.concurrent.ListenableFuture; import lombok.extern.slf4j.Slf4j; import org.apache.commons.lang3.StringUtils; import org.hibernate.exception.ConstraintViolationException; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; +import org.springframework.util.CollectionUtils; import org.thingsboard.server.common.data.BaseData; import org.thingsboard.server.common.data.EntityType; import org.thingsboard.server.common.data.Tenant; @@ -30,11 +34,14 @@ import org.thingsboard.server.common.data.id.RuleNodeId; import org.thingsboard.server.common.data.id.TenantId; import org.thingsboard.server.common.data.page.PageData; import org.thingsboard.server.common.data.page.PageLink; +import org.thingsboard.server.common.data.plugin.ComponentLifecycleEvent; import org.thingsboard.server.common.data.relation.EntityRelation; import org.thingsboard.server.common.data.relation.RelationTypeGroup; import org.thingsboard.server.common.data.rule.NodeConnectionInfo; import org.thingsboard.server.common.data.rule.RuleChain; import org.thingsboard.server.common.data.rule.RuleChainConnectionInfo; +import org.thingsboard.server.common.data.rule.RuleChainData; +import org.thingsboard.server.common.data.rule.RuleChainImportResult; import org.thingsboard.server.common.data.rule.RuleChainMetaData; import org.thingsboard.server.common.data.rule.RuleNode; import org.thingsboard.server.dao.entity.AbstractEntityService; @@ -46,9 +53,14 @@ import org.thingsboard.server.dao.tenant.TenantDao; import java.util.ArrayList; import java.util.HashMap; +import java.util.Iterator; import java.util.List; import java.util.Map; +import java.util.Optional; import java.util.concurrent.ExecutionException; +import java.util.stream.Collectors; + +import static org.thingsboard.server.common.data.DataConstants.TENANT; /** * Created by igor on 3/12/18. @@ -57,6 +69,7 @@ import java.util.concurrent.ExecutionException; @Slf4j public class BaseRuleChainService extends AbstractEntityService implements RuleChainService { + private static final int DEFAULT_PAGE_SIZE = 1000; @Autowired private RuleChainDao ruleChainDao; @@ -358,6 +371,141 @@ public class BaseRuleChainService extends AbstractEntityService implements RuleC tenantRuleChainsRemover.removeEntities(tenantId, tenantId); } + @Override + public RuleChainData exportTenantRuleChains(TenantId tenantId, PageLink pageLink) { + Validator.validateId(tenantId, "Incorrect tenant id for search rule chain request."); + Validator.validatePageLink(pageLink); + PageData ruleChainData = ruleChainDao.findRuleChainsByTenantId(tenantId.getId(), pageLink); + List ruleChains = ruleChainData.getData(); + List metadata = ruleChains.stream().map(rc -> loadRuleChainMetaData(tenantId, rc.getId())).collect(Collectors.toList()); + RuleChainData rcData = new RuleChainData(); + rcData.setRuleChains(ruleChains); + rcData.setMetadata(metadata); + setRandomRuleChainIds(rcData); + resetRuleNodeIds(metadata); + return rcData; + } + + @Override + public List importTenantRuleChains(TenantId tenantId, RuleChainData ruleChainData, boolean overwrite) { + List importResults = new ArrayList<>(); + setRandomRuleChainIds(ruleChainData); + resetRuleNodeIds(ruleChainData.getMetadata()); + resetRuleChainMetadataTenantIds(tenantId, ruleChainData.getMetadata()); + if (overwrite) { + List persistentRuleChains = findAllTenantRuleChains(tenantId); + for (RuleChain ruleChain : ruleChainData.getRuleChains()) { + ComponentLifecycleEvent lifecycleEvent; + Optional persistentRuleChainOpt = persistentRuleChains.stream().filter(rc -> rc.getName().equals(ruleChain.getName())).findFirst(); + if (persistentRuleChainOpt.isPresent()) { + setNewRuleChainId(ruleChain, ruleChainData.getMetadata(), ruleChain.getId(), persistentRuleChainOpt.get().getId()); + ruleChain.setRoot(persistentRuleChainOpt.get().isRoot()); + lifecycleEvent = ComponentLifecycleEvent.UPDATED; + } else { + ruleChain.setRoot(false); + lifecycleEvent = ComponentLifecycleEvent.CREATED; + } + ruleChain.setTenantId(tenantId); + ruleChainDao.save(tenantId, ruleChain); + importResults.add(new RuleChainImportResult(tenantId, ruleChain.getId(), lifecycleEvent)); + } + } else { + if (!CollectionUtils.isEmpty(ruleChainData.getRuleChains())) { + ruleChainData.getRuleChains().forEach(rc -> { + rc.setTenantId(tenantId); + rc.setRoot(false); + RuleChain savedRc = ruleChainDao.save(tenantId, rc); + importResults.add(new RuleChainImportResult(tenantId, savedRc.getId(), ComponentLifecycleEvent.CREATED)); + }); + } + } + if (!CollectionUtils.isEmpty(ruleChainData.getMetadata())) { + ruleChainData.getMetadata().forEach(md -> saveRuleChainMetaData(tenantId, md)); + } + return importResults; + } + + private void resetRuleChainMetadataTenantIds(TenantId tenantId, List metaData) { + for (RuleChainMetaData md : metaData) { + for (RuleNode node : md.getNodes()) { + JsonNode nodeConfiguration = node.getConfiguration(); + searchTenantIdRecursive(tenantId, nodeConfiguration); + } + } + } + + private void searchTenantIdRecursive(TenantId tenantId, JsonNode node) { + Iterator iter = node.fieldNames(); + boolean isTenantId = false; + while (iter.hasNext()) { + String field = iter.next(); + if ("entityType".equals(field) && TENANT.equals(node.get(field).asText())) { + isTenantId = true; + break; + } + } + if (isTenantId) { + ObjectNode objNode = (ObjectNode) node; + objNode.put("id", tenantId.getId().toString()); + } else { + Iterator childIter = node.iterator(); + while (childIter.hasNext()) { + searchTenantIdRecursive(tenantId, childIter.next()); + } + } + } + + private void setRandomRuleChainIds(RuleChainData ruleChainData) { + for (RuleChain ruleChain : ruleChainData.getRuleChains()) { + RuleChainId oldRuleChainId = ruleChain.getId(); + RuleChainId newRuleChainId = new RuleChainId(Uuids.timeBased()); + setNewRuleChainId(ruleChain, ruleChainData.getMetadata(), oldRuleChainId, newRuleChainId); + ruleChain.setTenantId(null); + } + } + + private void resetRuleNodeIds(List metaData) { + for (RuleChainMetaData md : metaData) { + for (RuleNode node : md.getNodes()) { + node.setId(null); + node.setRuleChainId(null); + } + } + } + + private List findAllTenantRuleChains(TenantId tenantId) { + PageLink pageLink = new PageLink(DEFAULT_PAGE_SIZE); + return findAllTenantRuleChainsRecursive(tenantId, new ArrayList<>(), pageLink); + } + + private List findAllTenantRuleChainsRecursive(TenantId tenantId, List accumulator, PageLink pageLink) { + PageData persistentRuleChainData = findTenantRuleChains(tenantId, pageLink); + List ruleChains = persistentRuleChainData.getData(); + if (!CollectionUtils.isEmpty(ruleChains)) { + accumulator.addAll(ruleChains); + } + if (persistentRuleChainData.hasNext()) { + return findAllTenantRuleChainsRecursive(tenantId, accumulator, pageLink.nextPageLink()); + } + return accumulator; + } + + private void setNewRuleChainId(RuleChain ruleChain, List metadata, RuleChainId oldRuleChainId, RuleChainId newRuleChainId) { + ruleChain.setId(newRuleChainId); + for (RuleChainMetaData metaData : metadata) { + if (metaData.getRuleChainId().equals(oldRuleChainId)) { + metaData.setRuleChainId(newRuleChainId); + } + if (!CollectionUtils.isEmpty(metaData.getRuleChainConnections())) { + for (RuleChainConnectionInfo rcConnInfo : metaData.getRuleChainConnections()) { + if (rcConnInfo.getTargetRuleChainId().equals(oldRuleChainId)) { + rcConnInfo.setTargetRuleChainId(newRuleChainId); + } + } + } + } + } + private void checkRuleNodesAndDelete(TenantId tenantId, RuleChainId ruleChainId) { try{ ruleChainDao.removeById(tenantId, ruleChainId.getId());