简柏林 / 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 5 import com.baomidou.mybatisplus.core.metadata.IPage;
6 6 import com.fasterxml.jackson.databind.JsonNode;
7 7 import com.fasterxml.jackson.databind.node.ObjectNode;
8   -import com.google.common.util.concurrent.MoreExecutors;
9 8 import lombok.RequiredArgsConstructor;
10 9 import org.apache.commons.lang3.StringUtils;
11   -import org.springframework.scheduling.annotation.Async;
12   -import org.springframework.scheduling.annotation.EnableAsync;
13 10 import org.springframework.stereotype.Service;
14 11 import org.springframework.transaction.annotation.Transactional;
15   -import org.thingsboard.common.util.ThingsBoardThreadFactory;
16 12 import org.thingsboard.server.common.data.id.EntityId;
17 13 import org.thingsboard.server.common.data.yunteng.constant.FastIotConstants;
18 14 import org.thingsboard.server.common.data.yunteng.core.exception.YtDataValidationException;
... ... @@ -29,476 +25,570 @@ import org.thingsboard.server.dao.yunteng.mapper.*;
29 25 import org.thingsboard.server.dao.yunteng.service.*;
30 26
31 27 import java.util.*;
32   -import java.util.concurrent.ExecutorService;
33 28 import java.util.concurrent.Executors;
34   -import java.util.concurrent.ScheduledExecutorService;
35 29 import java.util.concurrent.TimeUnit;
36 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 33 @Service
42 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 }
... ...