简柏林 / thingskit · Commits

Commit 0246ee682a7fb6e062483062d69903bf63cce977

Authored by 黄 x
1 parent 7902dee3

fix: 修改客户查询场景联动下对应组织的设备

Inline Side-by-side
Showing 1 changed file with 520 additions and 430 deletions
@@ -5,14 +5,10 @@ import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; @@ -5,14 +5,10 @@ import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
5 import com.baomidou.mybatisplus.core.metadata.IPage; 5 import com.baomidou.mybatisplus.core.metadata.IPage;
6 import com.fasterxml.jackson.databind.JsonNode; 6 import com.fasterxml.jackson.databind.JsonNode;
7 import com.fasterxml.jackson.databind.node.ObjectNode; 7 import com.fasterxml.jackson.databind.node.ObjectNode;
8 -import com.google.common.util.concurrent.MoreExecutors;  
9 import lombok.RequiredArgsConstructor; 8 import lombok.RequiredArgsConstructor;
10 import org.apache.commons.lang3.StringUtils; 9 import org.apache.commons.lang3.StringUtils;
11 -import org.springframework.scheduling.annotation.Async;  
12 -import org.springframework.scheduling.annotation.EnableAsync;  
13 import org.springframework.stereotype.Service; 10 import org.springframework.stereotype.Service;
14 import org.springframework.transaction.annotation.Transactional; 11 import org.springframework.transaction.annotation.Transactional;
15 -import org.thingsboard.common.util.ThingsBoardThreadFactory;  
16 import org.thingsboard.server.common.data.id.EntityId; 12 import org.thingsboard.server.common.data.id.EntityId;
17 import org.thingsboard.server.common.data.yunteng.constant.FastIotConstants; 13 import org.thingsboard.server.common.data.yunteng.constant.FastIotConstants;
18 import org.thingsboard.server.common.data.yunteng.core.exception.YtDataValidationException; 14 import org.thingsboard.server.common.data.yunteng.core.exception.YtDataValidationException;
@@ -29,476 +25,570 @@ import org.thingsboard.server.dao.yunteng.mapper.*; @@ -29,476 +25,570 @@ import org.thingsboard.server.dao.yunteng.mapper.*;
29 import org.thingsboard.server.dao.yunteng.service.*; 25 import org.thingsboard.server.dao.yunteng.service.*;
30 26
31 import java.util.*; 27 import java.util.*;
32 -import java.util.concurrent.ExecutorService;  
33 import java.util.concurrent.Executors; 28 import java.util.concurrent.Executors;
34 -import java.util.concurrent.ScheduledExecutorService;  
35 import java.util.concurrent.TimeUnit; 29 import java.util.concurrent.TimeUnit;
36 import java.util.stream.Collectors; 30 import java.util.stream.Collectors;
37 31
38 -/**  
39 - * @Description 场景联动业务实现层 @Author cxy @Date 2021/11/25 11:22  
40 - */ 32 +/** @Description 场景联动业务实现层 @Author cxy @Date 2021/11/25 11:22 */
41 @Service 33 @Service
42 @RequiredArgsConstructor 34 @RequiredArgsConstructor
43 -public class SceneLinkageServiceImpl extends AbstractBaseService<SceneLinkageMapper, SceneLinkage> implements SceneLinkageService {  
44 -  
45 - private final SceneLinkageMapper sceneLinkageMapper;  
46 - private final DeviceMapper deviceMapper;  
47 - private final DoActionMapper doActionMapper;  
48 - private final DoConditionMapper doConditionMapper;  
49 - private final TriggerMapper triggerMapper;  
50 - private final OrganizationMapper organizationMapper;  
51 - private final TriggerService triggerService;  
52 - private final DoConditionService doConditionService;  
53 - private final DoActionService doActionService;  
54 - /**  
55 - * 增加场景联动,触发器可以多个,执行条件可以多个,执行动作可以多个  
56 - *  
57 - * @param sceneLinkageDTO 场景对象  
58 - * @return SceneLinkageDTO 场景  
59 - */  
60 - @Override  
61 - @Transactional  
62 - public SceneLinkageDTO saveSceneLinkage(SceneLinkageDTO sceneLinkageDTO, String tenantId, String currentUserId, String customerId) {  
63 - sceneLinkageDTO.setTenantId(tenantId);  
64 - // 第一步保存场景,获取场景ID  
65 - // 场景对象  
66 - sceneLinkageDTO.setStatus(0);  
67 - SceneLinkage sceneLinkage = sceneLinkageDTO.getEntity(SceneLinkage.class);  
68 - // 新增  
69 - int insert = sceneLinkageMapper.insert(sceneLinkage);  
70 - if (insert > 0) {  
71 - sceneLinkage.copyToDTO(sceneLinkageDTO);  
72 - }  
73 -  
74 - String organizationId = sceneLinkage.getOrganizationId();  
75 - List<DeviceDTO> organizationDevices = findDeviceList(organizationId, tenantId, customerId);  
76 -  
77 - List<String> tbDeviceIds = new ArrayList<>();  
78 - for (DeviceDTO item : organizationDevices) {  
79 - tbDeviceIds.add(item.getTbDeviceId());  
80 - } 35 +public class SceneLinkageServiceImpl extends AbstractBaseService<SceneLinkageMapper, SceneLinkage>
  36 + implements SceneLinkageService {
  37 +
  38 + private final SceneLinkageMapper sceneLinkageMapper;
  39 + private final DeviceMapper deviceMapper;
  40 + private final DoActionMapper doActionMapper;
  41 + private final DoConditionMapper doConditionMapper;
  42 + private final TriggerMapper triggerMapper;
  43 + private final OrganizationMapper organizationMapper;
  44 + private final TriggerService triggerService;
  45 + private final DoConditionService doConditionService;
  46 + private final DoActionService doActionService;
  47 + /**
  48 + * 增加场景联动,触发器可以多个,执行条件可以多个,执行动作可以多个
  49 + *
  50 + * @param sceneLinkageDTO 场景对象
  51 + * @return SceneLinkageDTO 场景
  52 + */
  53 + @Override
  54 + @Transactional
  55 + public SceneLinkageDTO saveSceneLinkage(
  56 + SceneLinkageDTO sceneLinkageDTO, String tenantId, String currentUserId, String customerId) {
  57 + sceneLinkageDTO.setTenantId(tenantId);
  58 + // 第一步保存场景,获取场景ID
  59 + // 场景对象
  60 + sceneLinkageDTO.setStatus(0);
  61 + SceneLinkage sceneLinkage = sceneLinkageDTO.getEntity(SceneLinkage.class);
  62 + // 新增
  63 + int insert = sceneLinkageMapper.insert(sceneLinkage);
  64 + if (insert > 0) {
  65 + sceneLinkage.copyToDTO(sceneLinkageDTO);
  66 + }
81 67
82 - updateTrigger(sceneLinkageDTO, tbDeviceIds);  
83 - updateDoCondition(sceneLinkageDTO, tbDeviceIds);  
84 - updateDoAction(sceneLinkageDTO, tbDeviceIds); 68 + String organizationId = sceneLinkage.getOrganizationId();
  69 + List<DeviceDTO> organizationDevices = findDeviceList(organizationId, tenantId, customerId);
85 70
  71 + List<String> tbDeviceIds = new ArrayList<>();
  72 + for (DeviceDTO item : organizationDevices) {
  73 + tbDeviceIds.add(item.getTbDeviceId());
  74 + }
86 75
87 - return sceneLinkageDTO; 76 + updateTrigger(sceneLinkageDTO, tbDeviceIds);
  77 + updateDoCondition(sceneLinkageDTO, tbDeviceIds);
  78 + updateDoAction(sceneLinkageDTO, tbDeviceIds);
  79 +
  80 + return sceneLinkageDTO;
  81 + }
  82 +
  83 + /**
  84 + * byId删除场景联动
  85 + *
  86 + * @param ids 删除的ids
  87 + */
  88 + @Override
  89 + @Transactional
  90 + public void deleteSceneLinkage(Set<String> ids, String tenantId, String currentUserId) {
  91 + LambdaQueryWrapper<SceneLinkage> Wrapper =
  92 + new QueryWrapper<SceneLinkage>()
  93 + .lambda()
  94 + .eq(SceneLinkage::getTenantId, tenantId)
  95 + .eq(SceneLinkage::getCreator, currentUserId)
  96 + .in(SceneLinkage::getId, ids);
  97 + int result = sceneLinkageMapper.delete(Wrapper);
  98 + if (result != ids.size()) {
  99 + throw new YtDataValidationException("存在非当前用户创建的场景联动");
88 } 100 }
  101 + // 删除场景,一并删除数据库触发器,执行条件,执行动作的数据
  102 + triggerMapper.delete(
  103 + new LambdaQueryWrapper<Trigger>()
  104 + .eq(Trigger::getTenantId, tenantId)
  105 + .in(Trigger::getSceneLinkageId, ids));
  106 + doConditionMapper.delete(
  107 + new LambdaQueryWrapper<DoCondition>()
  108 + .eq(DoCondition::getTenantId, tenantId)
  109 + .in(DoCondition::getSceneLinkageId, ids));
  110 + doActionMapper.delete(
  111 + new LambdaQueryWrapper<DoAction>()
  112 + .eq(DoAction::getTenantId, tenantId)
  113 + .in(DoAction::getSceneLinkageId, ids));
  114 + }
  115 +
  116 + /**
  117 + * 修改场景联动和包含的触发器,执行条件,执行动作
  118 + *
  119 + * @param sceneLinkageDTO 场景
  120 + * @return SceneLinkageDTO 场景
  121 + */
  122 + @Override
  123 + @Transactional
  124 + public SceneLinkageDTO updateSceneLinkage(
  125 + SceneLinkageDTO sceneLinkageDTO, String tenantId, String currentUserId, String customerId) {
  126 + // 获取场景
  127 + SceneLinkage sceneLinkage = baseMapper.selectById(sceneLinkageDTO.getId());
  128 + if (sceneLinkage == null) {
  129 + throw new YtDataValidationException("此场景已不存在");
  130 + }
  131 + if (!sceneLinkage.getCreator().equals(currentUserId)) {
  132 + throw new YtDataValidationException("你不是此场景的创建者");
  133 + }
  134 + String organizationId = sceneLinkage.getOrganizationId();
  135 + List<DeviceDTO> organizationDevices = findDeviceList(organizationId, tenantId, customerId);
89 136
90 - /**  
91 - * byId删除场景联动  
92 - *  
93 - * @param ids 删除的ids  
94 - */  
95 - @Override  
96 - @Transactional  
97 - public void deleteSceneLinkage(Set<String> ids, String tenantId, String currentUserId) {  
98 - LambdaQueryWrapper<SceneLinkage> Wrapper = new QueryWrapper<SceneLinkage>().lambda().eq(SceneLinkage::getTenantId, tenantId).eq(SceneLinkage::getCreator, currentUserId).in(SceneLinkage::getId, ids);  
99 - int result = sceneLinkageMapper.delete(Wrapper);  
100 - if (result != ids.size()) {  
101 - throw new YtDataValidationException("存在非当前用户创建的场景联动");  
102 - }  
103 - // 删除场景,一并删除数据库触发器,执行条件,执行动作的数据  
104 - triggerMapper.delete(new LambdaQueryWrapper<Trigger>().eq(Trigger::getTenantId, tenantId).in(Trigger::getSceneLinkageId, ids));  
105 - doConditionMapper.delete(new LambdaQueryWrapper<DoCondition>().eq(DoCondition::getTenantId, tenantId).in(DoCondition::getSceneLinkageId, ids));  
106 - doActionMapper.delete(new LambdaQueryWrapper<DoAction>().eq(DoAction::getTenantId, tenantId).in(DoAction::getSceneLinkageId, ids)); 137 + List<String> tbDeviceIds = new ArrayList<>();
  138 + for (DeviceDTO item : organizationDevices) {
  139 + tbDeviceIds.add(item.getTbDeviceId());
107 } 140 }
108 141
109 - /**  
110 - * 修改场景联动和包含的触发器,执行条件,执行动作  
111 - *  
112 - * @param sceneLinkageDTO 场景  
113 - * @return SceneLinkageDTO 场景  
114 - */  
115 - @Override  
116 - @Transactional  
117 - public SceneLinkageDTO updateSceneLinkage(SceneLinkageDTO sceneLinkageDTO, String tenantId, String currentUserId, String customerId) {  
118 - // 获取场景  
119 - SceneLinkage sceneLinkage = baseMapper.selectById(sceneLinkageDTO.getId());  
120 - if (sceneLinkage == null) {  
121 - throw new YtDataValidationException("此场景已不存在"); 142 + updateTrigger(sceneLinkageDTO, tbDeviceIds);
  143 + updateDoCondition(sceneLinkageDTO, tbDeviceIds);
  144 + updateDoAction(sceneLinkageDTO, tbDeviceIds);
  145 +
  146 + sceneLinkageDTO.copyToEntity(sceneLinkage);
  147 + sceneLinkage.setTenantId(tenantId);
  148 + sceneLinkageMapper.updateById(sceneLinkage);
  149 + return sceneLinkage.getDTO(SceneLinkageDTO.class);
  150 + }
  151 +
  152 + /**
  153 + * 修改触发器
  154 + *
  155 + * @param sceneLinkage 场景联动信息
  156 + * @param tbDeviceIds 场景联动所属组织设备主键集合
  157 + */
  158 + private void updateTrigger(SceneLinkageDTO sceneLinkage, List<String> tbDeviceIds) {
  159 + List<TriggerDTO> triggerDTOS = sceneLinkage.getTriggers();
  160 + if (triggerDTOS != null && !triggerDTOS.isEmpty()) {
  161 + for (TriggerDTO triggerDTO : triggerDTOS) {
  162 + if (!TriggerTypeEnum.DEVICE_TRIGGER.equals(triggerDTO.getTriggerType())) {
  163 + continue;
122 } 164 }
123 - if (!sceneLinkage.getCreator().equals(currentUserId)) {  
124 - throw new YtDataValidationException("你不是此场景的创建者");  
125 - }  
126 - String organizationId = sceneLinkage.getOrganizationId();  
127 - List<DeviceDTO> organizationDevices = findDeviceList(organizationId, tenantId, customerId);  
128 -  
129 - List<String> tbDeviceIds = new ArrayList<>();  
130 - for (DeviceDTO item : organizationDevices) {  
131 - tbDeviceIds.add(item.getTbDeviceId()); 165 + List<String> deviceIds = triggerDTO.getEntityId();
  166 + if (ScopeEnum.PART.equals(triggerDTO.getEntityType())) {
  167 + if (deviceIds == null || deviceIds.isEmpty()) {
  168 + throw new YtDataValidationException(ErrorMessage.DEVICE_LOSED.getMessage());
  169 + } else {
  170 + for (String item : deviceIds) {
  171 + if (!tbDeviceIds.contains(item)) {
  172 + throw new YtDataValidationException(
  173 + ErrorMessage.ORGANIZATION_DEVICE_NOT_MATCHED_IN_TRIGGER.getMessage());
  174 + }
  175 + }
  176 + }
132 } 177 }
133 -  
134 - updateTrigger(sceneLinkageDTO, tbDeviceIds);  
135 - updateDoCondition(sceneLinkageDTO, tbDeviceIds);  
136 - updateDoAction(sceneLinkageDTO, tbDeviceIds);  
137 -  
138 - sceneLinkageDTO.copyToEntity(sceneLinkage);  
139 - sceneLinkage.setTenantId(tenantId);  
140 - sceneLinkageMapper.updateById(sceneLinkage);  
141 - return sceneLinkage.getDTO(SceneLinkageDTO.class); 178 + }
142 } 179 }
143 180
144 - /**  
145 - * 修改触发器  
146 - *  
147 - * @param sceneLinkage 场景联动信息  
148 - * @param tbDeviceIds 场景联动所属组织设备主键集合  
149 - */  
150 - private void updateTrigger(SceneLinkageDTO sceneLinkage, List<String> tbDeviceIds) {  
151 - List<TriggerDTO> triggerDTOS = sceneLinkage.getTriggers();  
152 - if (triggerDTOS != null && !triggerDTOS.isEmpty()) {  
153 - for (TriggerDTO triggerDTO : triggerDTOS) {  
154 - if (!TriggerTypeEnum.DEVICE_TRIGGER.equals(triggerDTO.getTriggerType())) {  
155 - continue;  
156 - }  
157 - List<String> deviceIds = triggerDTO.getEntityId();  
158 - if (ScopeEnum.PART.equals(triggerDTO.getEntityType())) {  
159 - if (deviceIds == null || deviceIds.isEmpty()) {  
160 - throw new YtDataValidationException(ErrorMessage.DEVICE_LOSED.getMessage());  
161 - } else {  
162 - for (String item : deviceIds) {  
163 - if (!tbDeviceIds.contains(item)) {  
164 - throw new YtDataValidationException(ErrorMessage.ORGANIZATION_DEVICE_NOT_MATCHED_IN_TRIGGER.getMessage());  
165 - }  
166 - }  
167 - }  
168 - }  
169 -  
170 -  
171 - } 181 + // 先删除触发器
  182 + triggerMapper.delete(
  183 + new QueryWrapper<Trigger>()
  184 + .lambda()
  185 + .eq(
  186 + StringUtils.isNoneBlank(sceneLinkage.getId()),
  187 + Trigger::getSceneLinkageId,
  188 + sceneLinkage.getId()));
  189 +
  190 + // 如果获取的触发器不为空,进行添加操作
  191 + if (triggerDTOS != null && !triggerDTOS.isEmpty()) {
  192 + List<Trigger> triggers =
  193 + triggerDTOS.stream()
  194 + .map(
  195 + triggerDTO -> {
  196 + triggerDTO.setTenantId(sceneLinkage.getTenantId());
  197 + triggerDTO.setSceneLinkageId(sceneLinkage.getId());
  198 + return triggerDTO.getEntity(Trigger.class);
  199 + })
  200 + .collect(Collectors.toList());
  201 + triggerService.insertBatch(triggers, 1000);
  202 + }
  203 + }
  204 +
  205 + /**
  206 + * 修改执行动作
  207 + *
  208 + * @param sceneLinkageDTO 场景联动信息
  209 + * @param tbDeviceIds 场景联动所属组织设备主键集合
  210 + */
  211 + private void updateDoAction(SceneLinkageDTO sceneLinkageDTO, List<String> tbDeviceIds) {
  212 + List<DoActionDTO> actionDTOS = sceneLinkageDTO.getDoActions();
  213 + if (actionDTOS != null && !actionDTOS.isEmpty()) {
  214 + for (DoActionDTO action : actionDTOS) {
  215 + if (!ActionTypeEnum.DEVICE_OUT.equals(action.getOutTarget())) {
  216 + continue;
172 } 217 }
173 -  
174 - // 先删除触发器  
175 - triggerMapper.delete(new QueryWrapper<Trigger>().lambda().eq(StringUtils.isNoneBlank(sceneLinkage.getId()), Trigger::getSceneLinkageId, sceneLinkage.getId()));  
176 -  
177 -  
178 - // 如果获取的触发器不为空,进行添加操作  
179 - if (triggerDTOS != null && !triggerDTOS.isEmpty()) {  
180 - List<Trigger> triggers = triggerDTOS.stream().map(triggerDTO -> {  
181 - triggerDTO.setTenantId(sceneLinkage.getTenantId());  
182 - triggerDTO.setSceneLinkageId(sceneLinkage.getId());  
183 - return triggerDTO.getEntity(Trigger.class);  
184 - }).collect(Collectors.toList());  
185 - triggerService.insertBatch(triggers, 1000); 218 + List<String> deviceIds = action.getDeviceId();
  219 + if (ScopeEnum.PART.equals(action.getEntityType())) {
  220 + if (deviceIds == null || deviceIds.isEmpty()) {
  221 + throw new YtDataValidationException(ErrorMessage.DEVICE_LOSED.getMessage());
  222 + } else {
  223 + for (String item : deviceIds) {
  224 + if (!tbDeviceIds.contains(item)) {
  225 + throw new YtDataValidationException(
  226 + ErrorMessage.ORGANIZATION_DEVICE_NOT_MATCHED_IN_ACTION.getMessage());
  227 + }
  228 + }
  229 + }
186 } 230 }
  231 + }
187 } 232 }
188 233
189 - /**  
190 - * 修改执行动作  
191 - *  
192 - * @param sceneLinkageDTO 场景联动信息  
193 - * @param tbDeviceIds 场景联动所属组织设备主键集合  
194 - */  
195 - private void updateDoAction(SceneLinkageDTO sceneLinkageDTO, List<String> tbDeviceIds) {  
196 - List<DoActionDTO> actionDTOS = sceneLinkageDTO.getDoActions();  
197 - if (actionDTOS != null && !actionDTOS.isEmpty()) {  
198 - for (DoActionDTO action : actionDTOS) {  
199 - if (!ActionTypeEnum.DEVICE_OUT.equals(action.getOutTarget())) {  
200 - continue;  
201 - }  
202 - List<String> deviceIds = action.getDeviceId();  
203 - if (ScopeEnum.PART.equals(action.getEntityType())) {  
204 - if (deviceIds == null || deviceIds.isEmpty()) {  
205 - throw new YtDataValidationException(ErrorMessage.DEVICE_LOSED.getMessage());  
206 - } else {  
207 - for (String item : deviceIds) {  
208 - if (!tbDeviceIds.contains(item)) {  
209 - throw new YtDataValidationException(ErrorMessage.ORGANIZATION_DEVICE_NOT_MATCHED_IN_ACTION.getMessage());  
210 - }  
211 - } 234 + doActionMapper.delete(
  235 + new QueryWrapper<DoAction>()
  236 + .lambda()
  237 + .eq(
  238 + StringUtils.isNoneBlank(sceneLinkageDTO.getId()),
  239 + DoAction::getSceneLinkageId,
  240 + sceneLinkageDTO.getId()));
  241 +
  242 + if (actionDTOS != null && !actionDTOS.isEmpty()) {
  243 + List<DoAction> collectA =
  244 + actionDTOS.stream()
  245 + .map(
  246 + doActionDTO -> {
  247 + doActionDTO.setTenantId(sceneLinkageDTO.getTenantId());
  248 + doActionDTO.setSceneLinkageId(sceneLinkageDTO.getId());
  249 + if (ActionTypeEnum.DEVICE_OUT.equals(doActionDTO.getOutTarget())) {
  250 + ObjectNode doContext = JacksonUtil.newObjectNode();
  251 + doContext.put("method", "methodThingskit");
  252 + doContext.put("params", doActionDTO.getDoContext());
  253 + doActionDTO.setDoContext(doContext);
212 } 254 }
213 - }  
214 - } 255 + return doActionDTO.getEntity(DoAction.class);
  256 + })
  257 + .collect(Collectors.toList());
  258 + doActionService.insertBatch(collectA, 1000);
  259 + }
  260 + }
  261 +
  262 + /**
  263 + * 修改执行动作
  264 + *
  265 + * @param sceneLinkageDTO 场景联动信息
  266 + * @param tbDeviceIds 场景联动所属组织设备主键集合
  267 + */
  268 + private void updateDoCondition(SceneLinkageDTO sceneLinkageDTO, List<String> tbDeviceIds) {
  269 + List<DoConditionDTO> conditionDTOS = sceneLinkageDTO.getDoConditions();
  270 + if (conditionDTOS != null && !conditionDTOS.isEmpty()) {
  271 + for (DoConditionDTO condition : conditionDTOS) {
  272 + if (!TriggerTypeEnum.DEVICE_TRIGGER.equals(condition.getTriggerType())) {
  273 + continue;
215 } 274 }
216 -  
217 - doActionMapper.delete(new QueryWrapper<DoAction>().lambda().eq(StringUtils.isNoneBlank(sceneLinkageDTO.getId()), DoAction::getSceneLinkageId, sceneLinkageDTO.getId()));  
218 -  
219 - if (actionDTOS != null && !actionDTOS.isEmpty()) {  
220 - List<DoAction> collectA = actionDTOS.stream().map(doActionDTO -> {  
221 - doActionDTO.setTenantId(sceneLinkageDTO.getTenantId());  
222 - doActionDTO.setSceneLinkageId(sceneLinkageDTO.getId());  
223 - if (ActionTypeEnum.DEVICE_OUT.equals(doActionDTO.getOutTarget())) {  
224 - ObjectNode doContext = JacksonUtil.newObjectNode();  
225 - doContext.put("method", "methodThingskit");  
226 - doContext.put("params", doActionDTO.getDoContext());  
227 - doActionDTO.setDoContext(doContext);  
228 - }  
229 - return doActionDTO.getEntity(DoAction.class);  
230 - }).collect(Collectors.toList());  
231 - doActionService.insertBatch(collectA, 1000);  
232 - 275 + List<String> deviceIds = condition.getEntityId();
  276 + if (ScopeEnum.PART.equals(condition.getEntityType())) {
  277 + if (deviceIds == null || deviceIds.isEmpty()) {
  278 + throw new YtDataValidationException(ErrorMessage.DEVICE_LOSED.getMessage());
  279 + } else {
  280 + for (String item : deviceIds) {
  281 + if (!tbDeviceIds.contains(item)) {
  282 + throw new YtDataValidationException(
  283 + ErrorMessage.ORGANIZATION_DEVICE_NOT_MATCHED_IN_ACTION.getMessage());
  284 + }
  285 + }
  286 + }
233 } 287 }
234 -  
235 - 288 + }
236 } 289 }
237 290
238 - /**  
239 - * 修改执行动作  
240 - *  
241 - * @param sceneLinkageDTO 场景联动信息  
242 - * @param tbDeviceIds 场景联动所属组织设备主键集合  
243 - */  
244 - private void updateDoCondition(SceneLinkageDTO sceneLinkageDTO, List<String> tbDeviceIds) {  
245 - List<DoConditionDTO> conditionDTOS = sceneLinkageDTO.getDoConditions();  
246 - if (conditionDTOS != null && !conditionDTOS.isEmpty()) {  
247 - for (DoConditionDTO condition : conditionDTOS) {  
248 - if (!TriggerTypeEnum.DEVICE_TRIGGER.equals(condition.getTriggerType())) {  
249 - continue;  
250 - }  
251 - List<String> deviceIds = condition.getEntityId();  
252 - if (ScopeEnum.PART.equals(condition.getEntityType())) {  
253 - if (deviceIds == null || deviceIds.isEmpty()) {  
254 - throw new YtDataValidationException(ErrorMessage.DEVICE_LOSED.getMessage());  
255 - } else {  
256 - for (String item : deviceIds) {  
257 - if (!tbDeviceIds.contains(item)) {  
258 - throw new YtDataValidationException(ErrorMessage.ORGANIZATION_DEVICE_NOT_MATCHED_IN_ACTION.getMessage());  
259 - }  
260 - }  
261 - } 291 + doConditionMapper.delete(
  292 + new QueryWrapper<DoCondition>()
  293 + .lambda()
  294 + .eq(
  295 + StringUtils.isNoneBlank(sceneLinkageDTO.getId()),
  296 + DoCondition::getSceneLinkageId,
  297 + sceneLinkageDTO.getId()));
  298 +
  299 + // 4.批量新增执行条件
  300 + if (conditionDTOS != null && !conditionDTOS.isEmpty()) {
  301 + List<DoCondition> collectC =
  302 + conditionDTOS.stream()
  303 + .map(
  304 + doConditionDTO -> {
  305 + doConditionDTO.setTenantId(sceneLinkageDTO.getTenantId());
  306 + doConditionDTO.setSceneLinkageId(sceneLinkageDTO.getId());
  307 + return doConditionDTO.getEntity(DoCondition.class);
  308 + })
  309 + .collect(Collectors.toList());
  310 + doConditionService.insertBatch(collectC, 1000);
  311 + }
  312 + }
  313 +
  314 + /**
  315 + * 通过分页查询
  316 + *
  317 + * @param queryMap 封装参数
  318 + * @return SceneLinkageDTO 场景对象
  319 + */
  320 + @Override
  321 + public YtPageData<SceneLinkageDTO> page(
  322 + Map<String, Object> queryMap, String tenantId, boolean isCustomerUser) {
  323 + queryMap.put("tenantId", tenantId);
  324 + // 拿到传入的组织id
  325 + String organizationId = (String) queryMap.get("organizationId");
  326 + // 不为空
  327 + if (null != organizationId && !StringUtils.isEmpty(organizationId)) {
  328 + queryMap.put(
  329 + "organizationIds", getQueryOrganizationIds(tenantId, List.of(organizationId)));
  330 + }
  331 + if (!isCustomerUser) {
  332 + queryMap.remove("currentUser");
  333 + }
  334 + IPage<SceneLinkage> page = getPage(queryMap, FastIotConstants.DefaultOrder.CREATE_TIME, false);
  335 + IPage<SceneLinkageDTO> scenePage = baseMapper.getScenePage(page, queryMap);
  336 + return getPageData(scenePage, SceneLinkageDTO.class);
  337 + }
  338 +
  339 + /** 获取当前租户的场景联动 */
  340 + @Override
  341 + public List<SceneLinkageDTO> findSceneLinkage(SceneLinkageDTO sceneLinkageDTO, String tenantId) {
  342 + List<SceneLinkage> scenelinkageList =
  343 + baseMapper.selectList(
  344 + new QueryWrapper<SceneLinkage>()
  345 + .lambda()
  346 + .eq(SceneLinkage::getTenantId, tenantId)
  347 + .like(SceneLinkage::getName, sceneLinkageDTO.getName())
  348 + .like(SceneLinkage::getOrganizationId, sceneLinkageDTO.getOrganizationId())
  349 + .like(SceneLinkage::getStatus, sceneLinkageDTO.getStatus()));
  350 + return ReflectUtils.sourceToTarget(scenelinkageList, SceneLinkageDTO.class);
  351 + }
  352 +
  353 + /**
  354 + * 修改当前场景联动的状态,启用或者停用
  355 + *
  356 + * @param sceneLinkageId 场景id
  357 + * @param status 状态
  358 + */
  359 + @Override
  360 + @Transactional(rollbackFor = Exception.class)
  361 + public void updateSceneStatus(String sceneLinkageId, int status, String tenantId) {
  362 + Optional.ofNullable(
  363 + baseMapper.selectOne(
  364 + new QueryWrapper<SceneLinkage>()
  365 + .lambda()
  366 + .eq(SceneLinkage::getId, sceneLinkageId)
  367 + .eq(SceneLinkage::getTenantId, tenantId)))
  368 + .ifPresent(
  369 + sceneLinkage -> {
  370 + sceneLinkage.setStatus(status);
  371 + baseMapper.updateById(sceneLinkage);
  372 + });
  373 + }
  374 +
  375 + /**
  376 + * @param organizationId 组织ID
  377 + * @param tenantId 租户ID
  378 + * @param customerId 客户ID
  379 + * @return 设备集合
  380 + */
  381 + @Override
  382 + public List<DeviceDTO> findDeviceList(String organizationId, String tenantId, String customerId) {
  383 + List<String> organizationFilter = new ArrayList<>();
  384 + organizationFilter.add(organizationId);
  385 + // 查询该组织的所有子类
  386 + List<String> orgIds =
  387 + organizationMapper.findOrganizationTreeList(tenantId, organizationFilter).stream()
  388 + .map(organization -> organization.getId())
  389 + .collect(Collectors.toList());
  390 + // 拿到当前组织ids所包含的设备集合
  391 + if (orgIds.isEmpty()) {
  392 + throw new YtDataValidationException(ErrorMessage.ORGANIZATION_NOT_EXTIED.getMessage());
  393 + }
  394 + List<YtDevice> orgDevices =
  395 + deviceMapper.selectList(
  396 + new QueryWrapper<YtDevice>().lambda().in(YtDevice::getOrganizationId, orgIds));
  397 + List<String> customerDevices = null;
  398 + // 不等于默认的UUID就是客户用户
  399 + if (!customerId.equals(EntityId.NULL_UUID)) {
  400 + customerDevices = deviceMapper.findDeviceIdsByCustomerId(customerId);
  401 + }
  402 + if (!EntityId.NULL_UUID.toString().equals(customerId)
  403 + && (customerDevices == null || customerDevices.isEmpty())) {
  404 + return null;
  405 + }
  406 + List<DeviceDTO> result =
  407 + orgDevices.stream()
  408 + .map(device -> device.getDTO(DeviceDTO.class))
  409 + .collect(Collectors.toList());
  410 + if (!customerId.equals(EntityId.NULL_UUID.toString())) {
  411 + List<DeviceDTO> customerAllDevice = new ArrayList<>();
  412 + if (null != customerDevices && customerDevices.size() > 0) {
  413 + customerDevices.forEach(
  414 + item -> {
  415 + for (DeviceDTO dto : result) {
  416 + if (item.equals(dto.getTbDeviceId())) {
  417 + customerAllDevice.add(dto);
  418 + break;
262 } 419 }
263 - }  
264 - }  
265 -  
266 - doConditionMapper.delete(new QueryWrapper<DoCondition>().lambda().eq(StringUtils.isNoneBlank(sceneLinkageDTO.getId()), DoCondition::getSceneLinkageId, sceneLinkageDTO.getId()));  
267 -  
268 -  
269 - // 4.批量新增执行条件  
270 - if (conditionDTOS != null && !conditionDTOS.isEmpty()) {  
271 - List<DoCondition> collectC = conditionDTOS.stream().map(doConditionDTO -> {  
272 -  
273 - doConditionDTO.setTenantId(sceneLinkageDTO.getTenantId());  
274 - doConditionDTO.setSceneLinkageId(sceneLinkageDTO.getId());  
275 - return doConditionDTO.getEntity(DoCondition.class);  
276 - }).collect(Collectors.toList());  
277 - doConditionService.insertBatch(collectC, 1000);  
278 -  
279 - } 420 + }
  421 + });
  422 + }
  423 + return customerAllDevice.size() > 0 ? customerAllDevice : null;
280 } 424 }
281 425
282 - /**  
283 - * 通过分页查询  
284 - *  
285 - * @param queryMap 封装参数  
286 - * @return SceneLinkageDTO 场景对象  
287 - */  
288 - @Override  
289 - public YtPageData<SceneLinkageDTO> page(Map<String, Object> queryMap, String tenantId, boolean isCustomerUser) {  
290 - queryMap.put("tenantId", tenantId);  
291 - // 拿到传入的组织id  
292 - String organizationId = (String) queryMap.get("organizationId");  
293 - // 不为空  
294 - if (null != organizationId && !StringUtils.isEmpty(organizationId)) {  
295 - queryMap.put("organizationIds", getQueryOrganizationIds(tenantId, Arrays.asList(organizationId)));  
296 - }  
297 - if (!isCustomerUser) {  
298 - queryMap.remove("currentUser");  
299 - }  
300 - IPage<SceneLinkage> page = getPage(queryMap, FastIotConstants.DefaultOrder.CREATE_TIME, false);  
301 - IPage<SceneLinkageDTO> scenePage = baseMapper.getScenePage(page, queryMap);  
302 - return getPageData(scenePage, SceneLinkageDTO.class); 426 + return result;
  427 + }
  428 +
  429 + /**
  430 + * 场景联动节点配置信息
  431 + *
  432 + * @param currentSceneId 场景联动主键
  433 + * @param tenantId 租户主键
  434 + * @param customerId 客户主键
  435 + * @param state 是否禁用场景联动，true标识禁用，false标识启用。
  436 + * @return
  437 + */
  438 + @Override
  439 + public JsonNode getRuleNodeConfig(
  440 + String currentSceneId, String tenantId, String customerId, Integer state) {
  441 + List<SceneLinkage> runningScenes =
  442 + baseMapper.selectList(
  443 + new QueryWrapper<SceneLinkage>()
  444 + .lambda()
  445 + .eq(SceneLinkage::getTenantId, tenantId)
  446 + .eq(SceneLinkage::getStatus, FastIotConstants.StateValue.ENABLE));
  447 + Set<String> enableIds = new HashSet<>();
  448 + Map<String, String> sceneInform = new HashMap<>();
  449 + for (SceneLinkage item : runningScenes) {
  450 + enableIds.add(item.getId());
  451 + sceneInform.put(item.getId(), item.getName());
303 } 452 }
304 -  
305 - /**  
306 - * 获取当前租户的场景联动  
307 - */  
308 - @Override  
309 - public List<SceneLinkageDTO> findSceneLinkage(SceneLinkageDTO sceneLinkageDTO, String tenantId) {  
310 - List<SceneLinkage> scenelinkageList = baseMapper.selectList(new QueryWrapper<SceneLinkage>().lambda().eq(SceneLinkage::getTenantId, tenantId).like(SceneLinkage::getName, sceneLinkageDTO.getName()).like(SceneLinkage::getOrganizationId, sceneLinkageDTO.getOrganizationId()).like(SceneLinkage::getStatus, sceneLinkageDTO.getStatus()));  
311 - return ReflectUtils.sourceToTarget(scenelinkageList, SceneLinkageDTO.class); 453 + SceneLinkage self = baseMapper.selectById(currentSceneId);
  454 + if (self == null) {
  455 + throw new YtDataValidationException(ErrorMessage.SCENE_REACT_NOT_EXTIED.getMessage());
312 } 456 }
313 -  
314 - /**  
315 - * 修改当前场景联动的状态,启用或者停用  
316 - *  
317 - * @param sceneLinkageId 场景id  
318 - * @param status 状态  
319 - */  
320 - @Override  
321 - @Transactional(rollbackFor = Exception.class)  
322 - public void updateSceneStatus(String sceneLinkageId, int status, String tenantId) {  
323 - Optional.ofNullable(baseMapper.selectOne(new QueryWrapper<SceneLinkage>().lambda().eq(SceneLinkage::getId, sceneLinkageId).eq(SceneLinkage::getTenantId, tenantId))).ifPresent(sceneLinkage -> {  
324 - sceneLinkage.setStatus(status);  
325 - baseMapper.updateById(sceneLinkage);  
326 - }); 457 + if (state == FastIotConstants.StateValue.DISABLE) {
  458 + enableIds.remove(currentSceneId);
  459 + sceneInform.remove(currentSceneId);
  460 + } else {
  461 + enableIds.add(currentSceneId);
  462 + sceneInform.put(currentSceneId, self.getName());
327 } 463 }
328 464
329 - /**  
330 - * @param organizationId 组织ID  
331 - * @param tenantId 租户ID  
332 - * @param customerId 客户ID  
333 - * @return 设备集合  
334 - */  
335 - @Override  
336 - public List<DeviceDTO> findDeviceList(String organizationId, String tenantId, String customerId) {  
337 - List<String> organizationFilter = new ArrayList<>();  
338 - organizationFilter.add(organizationId);  
339 - // 查询该组织的所有子类  
340 - List<String> orgIds = organizationMapper.findOrganizationTreeList(tenantId, organizationFilter).stream().map(organization -> organization.getId()).collect(Collectors.toList());  
341 - // 拿到当前组织ids所包含的设备集合  
342 - if (orgIds.isEmpty()) {  
343 - throw new YtDataValidationException(ErrorMessage.ORGANIZATION_NOT_EXTIED.getMessage());  
344 - }  
345 - List<YtDevice> orgDevices = deviceMapper.selectList(new QueryWrapper<YtDevice>().lambda().in(YtDevice::getOrganizationId, orgIds));  
346 -  
347 -  
348 - List<String> customerDevices = deviceMapper.findDeviceIdsByCustomerId(customerId);  
349 - if (!EntityId.NULL_UUID.toString().equals(customerId) && (customerDevices == null || customerDevices.isEmpty())) {  
350 - return null;  
351 - }  
352 - List<DeviceDTO> result = orgDevices.stream()  
353 -// .filter(f -> customerDevices.contains(f.getTbDeviceId()))  
354 - .map(device -> {  
355 - DeviceDTO dto = device.getDTO(DeviceDTO.class);  
356 - if(customerDevices != null && !customerDevices.isEmpty() && customerDevices.contains(device.getTbDeviceId())){  
357 - dto.setEnable(true);  
358 - }else{  
359 - dto.setEnable(false);  
360 - }  
361 - return dto;  
362 - })  
363 - .collect(Collectors.toList());  
364 -  
365 -  
366 - return result; 465 + if (enableIds.size() <= 0) {
  466 + return null;
367 } 467 }
368 468
369 - /**  
370 - * 场景联动节点配置信息  
371 - *  
372 - * @param currentSceneId 场景联动主键  
373 - * @param tenantId 租户主键  
374 - * @param customerId 客户主键  
375 - * @param state 是否禁用场景联动，true标识禁用，false标识启用。  
376 - * @return  
377 - */  
378 - @Override  
379 - public JsonNode getRuleNodeConfig(String currentSceneId, String tenantId, String customerId, Integer state) {  
380 - List<SceneLinkage> runningScenes = baseMapper.selectList(new QueryWrapper<SceneLinkage>().lambda().eq(SceneLinkage::getTenantId, tenantId).eq(SceneLinkage::getStatus, FastIotConstants.StateValue.ENABLE));  
381 - Set<String> enableIds = new HashSet<>();  
382 - Map<String, String> sceneInform = new HashMap<>();  
383 - for (SceneLinkage item : runningScenes) {  
384 - enableIds.add(item.getId());  
385 - sceneInform.put(item.getId(), item.getName());  
386 - }  
387 - SceneLinkage self = baseMapper.selectById(currentSceneId);  
388 - if (self == null) {  
389 - throw new YtDataValidationException(ErrorMessage.SCENE_REACT_NOT_EXTIED.getMessage());  
390 - }  
391 - if (state == FastIotConstants.StateValue.DISABLE) {  
392 - enableIds.remove(currentSceneId);  
393 - sceneInform.remove(currentSceneId);  
394 - } else {  
395 - enableIds.add(currentSceneId);  
396 - sceneInform.put(currentSceneId, self.getName());  
397 - }  
398 -  
399 - if (enableIds.size() <= 0) {  
400 - return null;  
401 - }  
402 -  
403 - List<DeviceDTO> organizationDevices = findDeviceList(self.getOrganizationId(), tenantId, customerId);  
404 - List<String> allDevices = new ArrayList<>();  
405 - for (DeviceDTO item : organizationDevices) {  
406 - allDevices.add(item.getTbDeviceId());  
407 - }  
408 -  
409 -  
410 - Map<String, List<String>> matchedDevices = new HashMap<>();  
411 -  
412 - List<Trigger> triggers = triggerMapper.selectList(new QueryWrapper<Trigger>().lambda().eq(Trigger::getTenantId, tenantId).eq(Trigger::getTriggerType, TriggerTypeEnum.DEVICE_TRIGGER).in(Trigger::getSceneLinkageId, enableIds));  
413 - 469 + List<DeviceDTO> organizationDevices =
  470 + findDeviceList(self.getOrganizationId(), tenantId, customerId);
  471 + List<String> allDevices = new ArrayList<>();
  472 + for (DeviceDTO item : organizationDevices) {
  473 + allDevices.add(item.getTbDeviceId());
  474 + }
414 475
415 - triggers.forEach(trigger -> {  
416 - String scenId = trigger.getSceneLinkageId();  
417 - List<String> devices = trigger.getEntityId();  
418 - if (ScopeEnum.ALL.equals(trigger.getEntityType()) && currentSceneId.equals(scenId)) {  
419 - devices = allDevices;  
420 - }  
421 - deviceSceneMap(matchedDevices, devices, scenId); 476 + Map<String, List<String>> matchedDevices = new HashMap<>();
  477 +
  478 + List<Trigger> triggers =
  479 + triggerMapper.selectList(
  480 + new QueryWrapper<Trigger>()
  481 + .lambda()
  482 + .eq(Trigger::getTenantId, tenantId)
  483 + .eq(Trigger::getTriggerType, TriggerTypeEnum.DEVICE_TRIGGER)
  484 + .in(Trigger::getSceneLinkageId, enableIds));
  485 +
  486 + triggers.forEach(
  487 + trigger -> {
  488 + String scenId = trigger.getSceneLinkageId();
  489 + List<String> devices = trigger.getEntityId();
  490 + if (ScopeEnum.ALL.equals(trigger.getEntityType()) && currentSceneId.equals(scenId)) {
  491 + devices = allDevices;
  492 + }
  493 + deviceSceneMap(matchedDevices, devices, scenId);
422 }); 494 });
423 495
424 -  
425 - if (matchedDevices.isEmpty()) {  
426 - return null;  
427 - }  
428 -  
429 - Executors.newScheduledThreadPool(1).schedule(()->{  
430 - freshEntityIds(currentSceneId, allDevices, triggers);  
431 - },1, TimeUnit.SECONDS);  
432 -  
433 - Map<String, Map> engineConfig = new HashMap<>();  
434 - engineConfig.put("scenes", matchedDevices);  
435 - engineConfig.put("names", sceneInform);  
436 -  
437 -  
438 - return JacksonUtil.convertValue(engineConfig, JsonNode.class); 496 + if (matchedDevices.isEmpty()) {
  497 + return null;
439 } 498 }
440 499
441 - /**  
442 - * 异步刷新场景联动的设备ID  
443 - *  
444 - * @param sceneId  
445 - * @param allDevices  
446 - * @param triggers  
447 - */  
448 - public void freshEntityIds(String sceneId, List<String> allDevices, List<Trigger> triggers) {  
449 - triggers.forEach(trigger -> {  
450 - if (ScopeEnum.ALL.equals(trigger.getEntityType()) && sceneId.equals(trigger.getSceneLinkageId())) {  
451 - trigger.setEntityId(allDevices);  
452 - triggerMapper.updateById(trigger);  
453 - } 500 + Executors.newScheduledThreadPool(1)
  501 + .schedule(
  502 + () -> {
  503 + freshEntityIds(currentSceneId, allDevices, triggers);
  504 + },
  505 + 1,
  506 + TimeUnit.SECONDS);
  507 +
  508 + Map<String, Map> engineConfig = new HashMap<>();
  509 + engineConfig.put("scenes", matchedDevices);
  510 + engineConfig.put("names", sceneInform);
  511 +
  512 + return JacksonUtil.convertValue(engineConfig, JsonNode.class);
  513 + }
  514 +
  515 + /**
  516 + * 异步刷新场景联动的设备ID
  517 + *
  518 + * @param sceneId
  519 + * @param allDevices
  520 + * @param triggers
  521 + */
  522 + public void freshEntityIds(String sceneId, List<String> allDevices, List<Trigger> triggers) {
  523 + triggers.forEach(
  524 + trigger -> {
  525 + if (ScopeEnum.ALL.equals(trigger.getEntityType())
  526 + && sceneId.equals(trigger.getSceneLinkageId())) {
  527 + trigger.setEntityId(allDevices);
  528 + triggerMapper.updateById(trigger);
  529 + }
454 }); 530 });
455 531
456 - List<DoCondition> conditions = doConditionMapper.selectList(new QueryWrapper<DoCondition>().lambda().eq(DoCondition::getSceneLinkageId, sceneId).eq(DoCondition::getEntityType, ScopeEnum.ALL));  
457 - conditions.forEach(item -> {  
458 - if (sceneId.equals(item.getSceneLinkageId())) {  
459 - item.setEntityId(allDevices);  
460 - doConditionMapper.updateById(item);  
461 - } 532 + List<DoCondition> conditions =
  533 + doConditionMapper.selectList(
  534 + new QueryWrapper<DoCondition>()
  535 + .lambda()
  536 + .eq(DoCondition::getSceneLinkageId, sceneId)
  537 + .eq(DoCondition::getEntityType, ScopeEnum.ALL));
  538 + conditions.forEach(
  539 + item -> {
  540 + if (sceneId.equals(item.getSceneLinkageId())) {
  541 + item.setEntityId(allDevices);
  542 + doConditionMapper.updateById(item);
  543 + }
462 }); 544 });
463 545
464 - List<DoAction> actions = doActionMapper.selectList(new QueryWrapper<DoAction>().lambda().eq(DoAction::getSceneLinkageId, sceneId).eq(DoAction::getEntityType, ScopeEnum.ALL));  
465 - actions.forEach(item -> {  
466 - if (sceneId.equals(item.getSceneLinkageId())) {  
467 - item.setDeviceId(allDevices);  
468 - doActionMapper.updateById(item);  
469 - } 546 + List<DoAction> actions =
  547 + doActionMapper.selectList(
  548 + new QueryWrapper<DoAction>()
  549 + .lambda()
  550 + .eq(DoAction::getSceneLinkageId, sceneId)
  551 + .eq(DoAction::getEntityType, ScopeEnum.ALL));
  552 + actions.forEach(
  553 + item -> {
  554 + if (sceneId.equals(item.getSceneLinkageId())) {
  555 + item.setDeviceId(allDevices);
  556 + doActionMapper.updateById(item);
  557 + }
470 }); 558 });
  559 + }
  560 +
  561 + /**
  562 + * 设备与场景联动的映射集合
  563 + *
  564 + * @param resultMap 缓存设备和场景联动映射结果的集合
  565 + * @param devices 设备主键集合
  566 + * @param scenId 场景联动主键
  567 + */
  568 + private void deviceSceneMap(
  569 + Map<String, List<String>> resultMap, List<String> devices, String scenId) {
  570 + for (String deviceId : devices) {
  571 + List<String> scenes = resultMap.computeIfAbsent(deviceId, k -> new ArrayList<String>());
  572 + if (!scenes.contains(scenId)) {
  573 + scenes.add(scenId);
  574 + }
  575 + if (scenes.isEmpty()) {
  576 + resultMap.remove(deviceId);
  577 + } else {
  578 + resultMap.put(deviceId, scenes);
  579 + }
471 } 580 }
472 -  
473 - /**  
474 - * 设备与场景联动的映射集合  
475 - *  
476 - * @param resultMap 缓存设备和场景联动映射结果的集合  
477 - * @param devices 设备主键集合  
478 - * @param scenId 场景联动主键  
479 - */  
480 - private void deviceSceneMap(Map<String, List<String>> resultMap, List<String> devices, String scenId) {  
481 - for (String deviceId : devices) {  
482 - List<String> scenes = resultMap.computeIfAbsent(deviceId, k -> new ArrayList<String>());  
483 - if (!scenes.contains(scenId)) {  
484 - scenes.add(scenId);  
485 - }  
486 - if (scenes.isEmpty()) {  
487 - resultMap.remove(deviceId);  
488 - } else {  
489 - resultMap.put(deviceId, scenes);  
490 - }  
491 - }  
492 - }  
493 -  
494 - private List<String> getQueryOrganizationIds(String tenantId, List<String> organizationIds) {  
495 - // 查询该组织的所有子类  
496 - List<OrganizationDTO> organizationDTOS = organizationMapper.findOrganizationTreeList(tenantId, organizationIds);  
497 - // 遍历组织id  
498 - List<String> queryOrganizationIds = new ArrayList<>();  
499 - organizationDTOS.forEach(item -> queryOrganizationIds.add(item.getId()));  
500 - Set<String> set = new HashSet<>();  
501 - set.addAll(queryOrganizationIds);  
502 - return new ArrayList<>(set);  
503 - } 581 + }
  582 +
  583 + private List<String> getQueryOrganizationIds(String tenantId, List<String> organizationIds) {
  584 + // 查询该组织的所有子类
  585 + List<OrganizationDTO> organizationDTOS =
  586 + organizationMapper.findOrganizationTreeList(tenantId, organizationIds);
  587 + // 遍历组织id
  588 + List<String> queryOrganizationIds = new ArrayList<>();
  589 + organizationDTOS.forEach(item -> queryOrganizationIds.add(item.getId()));
  590 + Set<String> set = new HashSet<>();
  591 + set.addAll(queryOrganizationIds);
  592 + return new ArrayList<>(set);
  593 + }
504 } 594 }