proj_name
stringclasses 131
values | relative_path
stringlengths 30
228
| class_name
stringlengths 1
68
| func_name
stringlengths 1
48
| masked_class
stringlengths 78
9.82k
| func_body
stringlengths 46
9.61k
| len_input
int64 29
2.01k
| len_output
int64 14
1.94k
| total
int64 55
2.05k
| relevant_context
stringlengths 0
38.4k
|
|---|---|---|---|---|---|---|---|---|---|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/device-manager/src/main/java/org/jetlinks/community/device/service/term/DeviceProtocolTerm.java
|
DeviceProtocolTerm
|
createFragments
|
class DeviceProtocolTerm extends AbstractTermFragmentBuilder {
public DeviceProtocolTerm() {
super("dev-protocol", "按协议查询设备");
}
@Override
public SqlFragments createFragments(String columnFullName, RDBColumnMetadata column, Term term) {<FILL_FUNCTION_BODY>}
}
|
PrepareSqlFragments sqlFragments = PrepareSqlFragments.of();
List<Object> idList = convertList(column, term);
if (term.getOptions().contains("not")) {
sqlFragments.addSql("not");
}
sqlFragments
.addSql("exists(select 1 from ",getTableName("dev_product",column)," _product where _product.id = " + columnFullName);
sqlFragments
.addSql(" and _product.message_protocol = ?");
sqlFragments.addSql(")").addParameter(idList);
return sqlFragments;
| 83
| 164
| 247
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/device-manager/src/main/java/org/jetlinks/community/device/service/term/DeviceTagTerm.java
|
DeviceTagTerm
|
acceptTerm
|
class DeviceTagTerm extends AbstractTermFragmentBuilder {
public static final String termType = "dev-tag";
public DeviceTagTerm() {
super(termType, "根据设备标签查询设备");
}
private void acceptTerm(boolean and, RDBColumnMetadata column, PrepareSqlFragments fragments, String terms) {<FILL_FUNCTION_BODY>}
private void acceptTerm(boolean and, PrepareSqlFragments fragments, Map<?, ?> terms) {
acceptTerm(and, fragments, terms.entrySet().stream().map(e -> {
Map<String, String> tag = new HashMap<>();
tag.put("key", String.valueOf(e.getKey()));
tag.put("value", String.valueOf(e.getValue()));
return tag;
}).collect(Collectors.toList()));
}
private void acceptTerm(boolean and, PrepareSqlFragments fragments, Collection<?> tags) {
int len = 0;
fragments.addSql("and (");
for (Object tag : tags) {
if (len++ > 0) {
fragments.addSql(and ? "and" : "or");
}
String key;
String value;
if (tag instanceof Map) {
@SuppressWarnings("all")
Map<Object, Object> map = ((Map) tag);
//key or column
key = String.valueOf(map.getOrDefault("key", map.get("column")));
value = String.valueOf(map.get("value"));
} else if (tag instanceof Term) {
key = ((Term) tag).getColumn();
value = String.valueOf(((Term) tag).getValue());
} else {
throw new IllegalArgumentException("illegal tag value format");
}
fragments.addSql("(d.key = ? and d.value like ?)")
.addParameter(key, value);
}
if (tags.isEmpty()) {
fragments.addSql("1=2");
}
fragments.addSql(")");
}
@Override
public SqlFragments createFragments(String columnFullName, RDBColumnMetadata column, Term term) {
PrepareSqlFragments fragments = PrepareSqlFragments.of();
fragments.addSql("exists(select 1 from ",getTableName("dev_device_tags",column)," d where d.device_id =", columnFullName);
Object value = term.getValue();
boolean and = term.getOptions().contains("and");
if (value instanceof Map) {
acceptTerm(and, fragments, (Map<?, ?>) value);
} else if (value instanceof Collection) {
acceptTerm(and, fragments, (Collection<?>) value);
} else {
acceptTerm(and, column, fragments, String.valueOf(value));
}
fragments.addSql(")");
return fragments;
}
static DeviceTagTerm.WhereBuilder builder = new DeviceTagTerm.WhereBuilder();
static class WhereBuilder extends AbstractTermsFragmentBuilder<RDBColumnMetadata> {
@Override
protected SqlFragments createTermFragments(RDBColumnMetadata parameter, Term term) {
PrepareSqlFragments sqlFragments = PrepareSqlFragments.of();
sqlFragments.addSql("(d.key = ?")
.addParameter(term.getColumn())
.addSql("and");
if (parameter == null) {
sqlFragments.addSql("d.value = ?").addParameter(term.getValue());
} else {
sqlFragments.addFragments(parameter
.findFeatureNow(TermFragmentBuilder.createFeatureId(term.getTermType()))
.createFragments("d.value", parameter, term)
);
}
sqlFragments
.addSql(")");
return sqlFragments;
}
@Override
protected SqlFragments createTermFragments(RDBColumnMetadata parameter, List<Term> terms) {
return super.createTermFragments(parameter, terms);
}
}
}
|
//json
if (terms.startsWith("[")) {
acceptTerm(and, fragments, JSON.parseArray(terms, Map.class));
} else if (terms.startsWith("{")) {
acceptTerm(and, fragments, JSON.parseObject(terms));
} else if (terms.contains(":") && !terms.contains(" ")) {
List<Map<String, String>> tags = Stream
.of(terms.split(","))
.map(str -> str.split(":"))
.map(str -> {
Map<String, String> tag = new HashMap<>();
tag.put("key", str[0]);
tag.put("value", str.length > 1 ? str[1] : null);
return tag;
})
.collect(Collectors.toList());
acceptTerm(and, fragments, tags);
} else {
//SQL表达式
List<Term> tagKeys = TermExpressionParser.parse(terms);
SqlFragments expr = builder.createTermFragments(column, tagKeys);
if (expr.isNotEmpty()) {
fragments.addSql("and (").addFragments(expr).addSql(")");
}
}
| 1,036
| 307
| 1,343
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/device-manager/src/main/java/org/jetlinks/community/device/service/term/DeviceTypeTerm.java
|
DeviceTypeTerm
|
createFragments
|
class DeviceTypeTerm extends AbstractTermFragmentBuilder {
public DeviceTypeTerm() {
super("dev-device-type", "按设备类型查询设备");
}
@Override
public SqlFragments createFragments(String columnFullName, RDBColumnMetadata column, Term term) {<FILL_FUNCTION_BODY>}
}
|
PrepareSqlFragments sqlFragments = PrepareSqlFragments.of();
List<Object> idList = convertList(column, term);
if (term.getOptions().contains("not")) {
sqlFragments.addSql("not");
}
sqlFragments
.addSql("exists(select 1 from ",getTableName("dev_product",column)," _product where _product.id = " + columnFullName);
sqlFragments
.addSql(" and _product.device_type in(");
sqlFragments.addSql(idList.stream().map(str -> "?").collect(Collectors.joining(",")))
.addParameter(idList)
.addSql("))");
return sqlFragments;
| 86
| 195
| 281
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/device-manager/src/main/java/org/jetlinks/community/device/web/DeviceCategoryController.java
|
DeviceCategoryController
|
getAllCategoryTree
|
class DeviceCategoryController implements ReactiveServiceCrudController<DeviceCategoryEntity,String> {
private final DeviceCategoryService categoryService;
@GetMapping
@QueryNoPagingOperation(summary = "获取全部分类")
@Authorize(merge = false)
public Flux<DeviceCategoryEntity> getAllCategory(@Parameter(hidden = true) QueryParamEntity query) {
return this
.categoryService
.createQuery()
.setParam(query)
.fetch();
}
@GetMapping("/_tree")
@QueryNoPagingOperation(summary = "获取全部分类(树结构)")
@Authorize(merge = false)
public Flux<DeviceCategoryEntity> getAllCategoryTree(@Parameter(hidden = true) QueryParamEntity query) {<FILL_FUNCTION_BODY>}
@PostMapping("/_tree")
@QueryNoPagingOperation(summary = "获取全部分类(树结构)")
@Authorize(merge = false)
public Flux<DeviceCategoryEntity> getAllCategoryTreeByQueryParam(@RequestBody Mono<QueryParamEntity> query) {
return this
.categoryService
.query(query)
.collectList()
.flatMapMany(all-> Flux.fromIterable(TreeSupportEntity.list2tree(all, DeviceCategoryEntity::setChildren)));
}
@Override
public ReactiveCrudService<DeviceCategoryEntity, String> getService() {
return categoryService;
}
}
|
return this
.categoryService
.createQuery()
.setParam(query)
.fetch()
.collectList()
.flatMapMany(all-> Flux.fromIterable(TreeSupportEntity.list2tree(all, DeviceCategoryEntity::setChildren)));
| 368
| 71
| 439
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/device-manager/src/main/java/org/jetlinks/community/device/web/DeviceMessageController.java
|
DeviceMessageController
|
mapReply
|
class DeviceMessageController {
@Autowired
private DeviceRegistry registry;
//获取设备属性
@GetMapping("/{deviceId}/property/{property:.+}")
@SneakyThrows
@Deprecated
public Flux<?> getProperty(@PathVariable String deviceId, @PathVariable String property) {
return registry
.getDevice(deviceId)
.switchIfEmpty(ErrorUtils.notFound("设备不存在"))
.map(DeviceOperator::messageSender)//发送消息到设备
.map(sender -> sender.readProperty(property).messageId(IDGenerator.SNOW_FLAKE_STRING.generate()))
.flatMapMany(ReadPropertyMessageSender::send)
.map(mapReply(ReadPropertyMessageReply::getProperties));
}
//获取标准设备属性
@GetMapping("/standard/{deviceId}/property/{property:.+}")
@SneakyThrows
@Deprecated
public Mono<DevicePropertiesEntity> getStandardProperty(@PathVariable String deviceId, @PathVariable String property) {
return Mono.from(registry
.getDevice(deviceId)
.switchIfEmpty(ErrorUtils.notFound("设备不存在"))
.flatMapMany(deviceOperator -> deviceOperator.messageSender()
.readProperty(property).messageId(IDGenerator.SNOW_FLAKE_STRING.generate())
.send()
.map(mapReply(ReadPropertyMessageReply::getProperties))
.flatMap(map -> {
Object value = map.get(property);
return deviceOperator.getMetadata()
.map(deviceMetadata -> deviceMetadata.getProperty(property)
.map(PropertyMetadata::getValueType)
.orElse(new StringType()))
.map(dataType -> DevicePropertiesEntity.builder()
.deviceId(deviceId)
.productId(property)
.build()
.withValue(dataType, value));
})))
;
}
//设置设备属性
@PostMapping("/setting/{deviceId}/property")
@SneakyThrows
@Deprecated
public Flux<?> settingProperties(@PathVariable String deviceId, @RequestBody Map<String, Object> properties) {
return registry
.getDevice(deviceId)
.switchIfEmpty(ErrorUtils.notFound("设备不存在"))
.map(operator -> operator
.messageSender()
.writeProperty()
.messageId(IDGenerator.SNOW_FLAKE_STRING.generate())
.write(properties)
)
.flatMapMany(WritePropertyMessageSender::send)
.map(mapReply(WritePropertyMessageReply::getProperties));
}
//设备功能调用
@PostMapping("invoked/{deviceId}/function/{functionId}")
@SneakyThrows
@Deprecated
public Flux<?> invokedFunction(@PathVariable String deviceId,
@PathVariable String functionId,
@RequestBody Map<String, Object> properties) {
return registry
.getDevice(deviceId)
.switchIfEmpty(ErrorUtils.notFound("设备不存在"))
.flatMap(operator -> operator
.messageSender()
.invokeFunction(functionId)
.messageId(IDGenerator.SNOW_FLAKE_STRING.generate())
.setParameter(properties)
.validate()
)
.flatMapMany(FunctionInvokeMessageSender::send)
.map(mapReply(FunctionInvokeMessageReply::getOutput));
}
//获取设备所有属性
@PostMapping("/{deviceId}/properties")
@SneakyThrows
@Deprecated
public Flux<?> getProperties(@PathVariable String deviceId,
@RequestBody Mono<List<String>> properties) {
return registry.getDevice(deviceId)
.switchIfEmpty(ErrorUtils.notFound("设备不存在"))
.map(DeviceOperator::messageSender)
.flatMapMany((sender) ->
properties.flatMapMany(list ->
sender.readProperty(list.toArray(new String[0]))
.messageId(IDGenerator.SNOW_FLAKE_STRING.generate())
.send()))
.map(mapReply(ReadPropertyMessageReply::getProperties));
}
private static <R extends DeviceMessageReply, T> Function<R, T> mapReply(Function<R, T> function) {<FILL_FUNCTION_BODY>}
}
|
return reply -> {
if (ErrorCode.REQUEST_HANDLING.name().equals(reply.getCode())) {
throw new DeviceOperationException(ErrorCode.REQUEST_HANDLING, reply.getMessage());
}
if (!reply.isSuccess()) {
throw new BusinessException(reply.getMessage(), reply.getCode());
}
T mapped = function.apply(reply);
if (mapped == null) {
throw new BusinessException(reply.getMessage(), reply.getCode());
}
return mapped;
};
| 1,127
| 141
| 1,268
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/device-manager/src/main/java/org/jetlinks/community/device/web/GatewayDeviceController.java
|
GatewayDeviceController
|
queryGatewayDevice
|
class GatewayDeviceController {
@Autowired
private LocalDeviceInstanceService instanceService;
@Autowired
private LocalDeviceProductService productService;
@Autowired
private DeviceRegistry registry;
@SuppressWarnings("all")
private Mono<List<String>> getGatewayProductList() {
return productService
.createQuery()
.select(DeviceProductEntity::getId)
.where(DeviceProductEntity::getDeviceType, DeviceType.gateway)
.fetch()
.map(DeviceProductEntity::getId)
.collectList()
.filter(CollectionUtils::isNotEmpty);
}
@GetMapping("/_query")
@QueryAction
@QueryOperation(summary = "查询网关设备详情")
public Mono<PagerResult<GatewayDeviceInfo>> queryGatewayDevice(@Parameter(hidden = true) QueryParamEntity param) {<FILL_FUNCTION_BODY>}
@GetMapping("/{id}")
@QueryAction
@QueryOperation(summary = "获取单个网关设备详情")
public Mono<GatewayDeviceInfo> getGatewayInfo(@PathVariable String id) {
return Mono.zip(
instanceService.findById(id),
instanceService.createQuery()
.where()
.is(DeviceInstanceEntity::getParentId, id)
.fetch()
.collectList()
.defaultIfEmpty(Collections.emptyList()),
GatewayDeviceInfo::of);
}
@PostMapping("/{gatewayId}/bind/{deviceId}")
@SaveAction
@QueryOperation(summary = "绑定单个子设备到网关设备")
public Mono<GatewayDeviceInfo> bindDevice(@PathVariable @Parameter(description = "网关设备ID") String gatewayId,
@PathVariable @Parameter(description = "子设备ID") String deviceId) {
return instanceService
.checkCyclicDependency(deviceId, gatewayId)
.then(
instanceService
.createUpdate()
.set(DeviceInstanceEntity::getParentId, gatewayId)
.where(DeviceInstanceEntity::getId, deviceId)
.execute()
.then(registry.getDevice(gatewayId)
.flatMap(gwOperator -> gwOperator.getProtocol()
.flatMap(protocolSupport -> protocolSupport.onChildBind(gwOperator,
Flux.from(registry.getDevice(deviceId)))
)
)
)
)
.then(getGatewayInfo(gatewayId));
}
@PostMapping("/{gatewayId}/bind")
@SaveAction
@QueryOperation(summary = "绑定多个子设备到网关设备")
public Mono<GatewayDeviceInfo> bindDevice(@PathVariable @Parameter(description = "网关设备ID") String gatewayId,
@RequestBody @Parameter(description = "子设备ID集合") Mono<List<String>> deviceId) {
return deviceId
.flatMapIterable(Function.identity())
.flatMap(childId -> instanceService
.checkCyclicDependency(childId, gatewayId)
.thenReturn(childId))
.collectList()
.filter(CollectionUtils::isNotEmpty)
.flatMap(deviceIdList -> instanceService
.createUpdate()
.set(DeviceInstanceEntity::getParentId, gatewayId)
.where()
.in(DeviceInstanceEntity::getId, deviceIdList)
.execute()
.then(registry.getDevice(gatewayId)
.flatMap(gwOperator -> gwOperator.getProtocol()
.flatMap(protocolSupport -> protocolSupport.onChildBind(gwOperator,
Flux.fromIterable(deviceIdList).flatMap(id -> registry.getDevice(id)))
)
)
)
).then(getGatewayInfo(gatewayId));
}
@PostMapping("/{gatewayId}/unbind/{deviceId}")
@SaveAction
@QueryOperation(summary = "从网关设备中解绑子设备")
public Mono<GatewayDeviceInfo> unBindDevice(@PathVariable @Parameter(description = "网关设备ID") String gatewayId,
@PathVariable @Parameter(description = "自设备ID") String deviceId) {
return instanceService
.createUpdate()
.setNull(DeviceInstanceEntity::getParentId)
.where(DeviceInstanceEntity::getId, deviceId)
.and(DeviceInstanceEntity::getParentId, gatewayId)
.execute()
.filter(i -> i > 0)
.then(registry.getDevice(gatewayId)
.flatMap(gwOperator -> gwOperator.getProtocol()
.flatMap(protocolSupport -> protocolSupport.onChildUnbind(gwOperator,
Flux.from(registry.getDevice(deviceId)))
)
)
)
.then(getGatewayInfo(gatewayId));
}
}
|
return this
.getGatewayProductList()
.flatMap(productIdList -> param
.toNestQuery(query -> query.in(DeviceInstanceEntity::getProductId, productIdList))
.execute(instanceService::queryPager)
.filter(r -> r.getTotal() > 0)
.flatMap(result -> {
Map<String, DeviceInstanceEntity> mapping =
result.getData()
.stream()
.collect(Collectors.toMap(DeviceInstanceEntity::getId, Function.identity()));
//查询所有子设备并按父设备ID分组
return instanceService
.createQuery()
.where()
.in(DeviceInstanceEntity::getParentId, mapping.keySet())
.fetch()
.groupBy(DeviceInstanceEntity::getParentId, Integer.MAX_VALUE)
.flatMap(group -> {
String parentId = group.key();
return group
.collectList()
//将父设备和分组的子设备合并在一起
.map(children -> GatewayDeviceInfo.of(mapping.get(parentId), children));
})
//收集所有有子设备的网关设备信息
.collectMap(GatewayDeviceInfo::getId)
.defaultIfEmpty(Collections.emptyMap())
.flatMapMany(map -> Flux
.fromIterable(mapping.values())
.flatMap(ins -> Mono
.justOrEmpty(map.get(ins.getId()))
//处理没有子设备的网关信息
.switchIfEmpty(Mono.fromSupplier(() -> GatewayDeviceInfo.of(ins, Collections.emptyList())))))
.collectList()
.map(list -> PagerResult.of(result.getTotal(), list, param));
}))
.defaultIfEmpty(PagerResult.empty());
| 1,258
| 464
| 1,722
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/device-manager/src/main/java/org/jetlinks/community/device/web/TransparentMessageCodecController.java
|
TransparentMessageCodecController
|
getTypescriptDeclares
|
class TransparentMessageCodecController {
private final ReactiveRepository<TransparentMessageCodecEntity, String> repository;
private final DeviceRegistry registry;
@PostMapping("/decode-test")
@QueryAction
@Operation(summary = "测试解码")
public Mono<TransparentMessageDecodeResponse> getCodec(@RequestBody Mono<TransparentMessageDecodeRequest> requestMono) {
return requestMono
.flatMapMany(req -> TransparentMessageCodecProviders
.getProviderNow(req.getProvider())
.createCodec(req.getConfiguration())
.flatMapMany(codec -> codec.decode(req.toMessage())))
.collectList()
.map(TransparentMessageDecodeResponse::of)
.onErrorResume(err -> LocaleUtils.doWithReactive(
err,
Throwable::getLocalizedMessage,
(e, msg) -> TransparentMessageDecodeResponse.error(msg)));
}
@GetMapping("/{productId}/{deviceId}.d.ts")
@QueryAction
@Operation(summary = "获取设备的TypeScript定义信息")
public Mono<String> getTypescriptDeclares(@PathVariable String productId,
@PathVariable String deviceId) {
return registry
.getDevice(deviceId)
.flatMap(DeviceOperator::getMetadata)
.flatMap(this::getTypescriptDeclares);
}
@GetMapping("/{productId}.d.ts")
@QueryAction
@Operation(summary = "获取产品的TypeScript定义信息")
public Mono<String> getTypescriptDeclares(@PathVariable String productId) {
return registry
.getProduct(productId)
.flatMap(DeviceProductOperator::getMetadata)
.flatMap(this::getTypescriptDeclares);
}
@GetMapping("/{productId}/{deviceId}")
@QueryAction
@Operation(summary = "获取设备的解析规则")
public Mono<TransparentMessageCodecEntity> getCodec(@PathVariable String productId,
@PathVariable String deviceId) {
return repository
.findById(TransparentMessageCodecEntity.createId(productId, deviceId))
//设备没有则获取产品的
.switchIfEmpty(Mono.defer(() -> {
if (StringUtils.hasText(deviceId)) {
return repository.findById(TransparentMessageCodecEntity.createId(productId, null));
}
return Mono.empty();
}));
}
@GetMapping("/{productId}")
@QueryAction
@Operation(summary = "获取产品的解析规则")
public Mono<TransparentMessageCodecEntity> getCodec(@PathVariable String productId) {
return getCodec(productId, null);
}
@PostMapping("/{productId}/{deviceId}")
@SaveAction
@Operation(summary = "保存设备解析规则")
public Mono<Void> saveCodec(@PathVariable String productId,
@PathVariable String deviceId,
@RequestBody Mono<TransparentMessageCodecRequest> requestMono) {
return requestMono
.flatMap(request-> {
TransparentMessageCodecEntity codec = new TransparentMessageCodecEntity();
codec.setProductId(productId);
codec.setDeviceId(deviceId);
codec.setProvider(request.getProvider());
codec.setConfiguration(request.getConfiguration());
return repository.save(codec);
})
.then();
}
@PostMapping("/{productId}")
@Operation(summary = "保存产品解析规则")
public Mono<Void> saveCodec(@PathVariable String productId,
@RequestBody Mono<TransparentMessageCodecRequest> requestMono) {
return saveCodec(productId, null, requestMono);
}
@DeleteMapping("/{productId}/{deviceId}")
@SaveAction
@Operation(summary = "重置设备的解析规则")
public Mono<Void> removeCodec(@PathVariable String productId,
@PathVariable String deviceId) {
return repository
.deleteById(TransparentMessageCodecEntity.createId(productId, deviceId))
.then();
}
@DeleteMapping("/{productId}")
@SaveAction
@Operation(summary = "重置产品的解析规则")
public Mono<Void> removeCodec(@PathVariable String productId) {
return removeCodec(productId, null);
}
private Mono<String> getTypescriptDeclares(DeviceMetadata metadata) {<FILL_FUNCTION_BODY>}
}
|
StringBuilder builder = new StringBuilder();
TypeScriptUtils.createMetadataDeclare(metadata, builder);
TypeScriptUtils.loadDeclare("transparent-codec", builder);
return Mono.just(builder.toString());
| 1,192
| 59
| 1,251
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/device-manager/src/main/java/org/jetlinks/community/device/web/excel/DeviceExcelImporter.java
|
DeviceExcelImporter
|
customImport
|
class DeviceExcelImporter extends AbstractImporter<DeviceExcelInfo> {
@Getter
private final DeviceProductEntity product;
private final Map<String, PropertyMetadata> tagMapping = new HashMap<>();
private final Map<String, ConfigPropertyMetadata> configMapping = new HashMap<>();
private final Authentication auth;
public DeviceExcelImporter(FileManager fileManager,
WebClient client,
DeviceProductEntity product,
List<ConfigPropertyMetadata> configs,
Authentication auth) {
super(fileManager, client);
this.product = product;
this.auth = auth;
List<PropertyMetadata> tags = product.parseMetadata().getTags();
for (PropertyMetadata tag : tags) {
tagMapping.put(tag.getName(), tag);
}
for (ConfigPropertyMetadata config : configs) {
configMapping.put(config.getName(), config);
}
}
@Override
protected Mono<Void> handleData(Flux<DeviceExcelInfo> data) {
return data
.doOnNext(ValidatorUtils::tryValidate)
.map(deviceExcelInfo -> deviceExcelInfo.initDeviceInstance(product, auth))
.then();
}
@Override
protected DeviceExcelInfo newInstance() {
DeviceExcelInfo deviceExcelInfo = new DeviceExcelInfo();
deviceExcelInfo.setTagMapping(tagMapping);
deviceExcelInfo.setConfigMapping(configMapping);
return deviceExcelInfo;
}
@Override
protected void customImport(ImportHelper<DeviceExcelInfo> helper) {<FILL_FUNCTION_BODY>}
}
|
helper.fallbackSingle(true);
for (PropertyMetadata tag : tagMapping.values()) {
helper.addHeader(tag.getId(), tag.getName());
}
for (ConfigPropertyMetadata config : configMapping.values()) {
helper.addHeader(config.getProperty(), config.getName());
}
| 417
| 79
| 496
|
<methods>public non-sealed void <init>() ,public Flux<ImportResult<org.jetlinks.community.device.web.excel.DeviceExcelInfo>> doImport(java.lang.String, java.lang.String) ,public Flux<ImportResult<org.jetlinks.community.device.web.excel.DeviceExcelInfo>> doImport(java.lang.String) <variables>protected final non-sealed org.springframework.web.reactive.function.client.WebClient client,protected final non-sealed org.jetlinks.community.io.file.FileManager fileManager
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/device-manager/src/main/java/org/jetlinks/community/device/web/excel/DeviceExcelInfo.java
|
DeviceExcelInfo
|
getExportHeaderMapping
|
class DeviceExcelInfo implements Jsonable {
@org.jetlinks.community.io.excel.annotation.ExcelHeader(value = "设备ID")
@NotBlank(message = "设备ID不能为空")
private String id;
@org.jetlinks.community.io.excel.annotation.ExcelHeader(value = "设备名称")
@NotBlank(message = "设备名称不能为空")
private String name;
private String orgName;
private String productName;
@org.jetlinks.community.io.excel.annotation.ExcelHeader(value = "父设备ID")
private String parentId;
private List<DeviceTagEntity> tags = new ArrayList<>();
private DeviceInstanceEntity device;
private Map<String, PropertyMetadata> tagMapping;
private Map<String, ConfigPropertyMetadata> configMapping;
private Map<String, Object> configuration = new HashMap<>();
private long rowNumber;
private String state;
public void config(String key, Object value) {
if (value == null || value instanceof String && !StringUtils.hasText((String) value)) {
return;
}
configuration.put(key, value);
}
public void tag(String key, String name, Object value, String type) {
if (value == null) {
return;
}
DeviceTagEntity entity = new DeviceTagEntity();
entity.setKey(key);
entity.setValue(String.valueOf(value));
entity.setName(name);
entity.setDeviceId(id);
entity.setType(type);
entity.setId(DeviceTagEntity.createTagId(id,key));
tags.add(entity);
}
public void setId(String id) {
this.id = id;
for (DeviceTagEntity tag : tags) {
tag.setDeviceId(id);
tag.setId(DeviceTagEntity.createTagId(tag.getDeviceId(),tag.getKey()));
}
}
public void with(String key, Object value) {
FastBeanCopier.copy(Collections.singletonMap(key, value), this);
}
public Map<String,Object> toMap(){
Map<String,Object> val = FastBeanCopier.copy(this,new HashMap<>());
for (DeviceTagEntity tag : tags) {
val.put(tag.getKey(),tag.getValue());
}
return val;
}
public static List<ExcelHeader> getTemplateHeaderMapping(DeviceExcelFilterColumns filterColumns,
List<PropertyMetadata> tags,
List<ConfigPropertyMetadata> configs) {
List<ExcelHeader> arr =
Arrays.stream(new ExcelHeader[]{
new ExcelHeader("id", "设备ID", CellDataType.STRING),
new ExcelHeader("name", "设备名称", CellDataType.STRING),
new ExcelHeader("parentId", "父设备ID", CellDataType.STRING)
})
.filter(a-> !filterColumns.getColumns().contains(a.getKey()))
.collect(Collectors.toList());
for (PropertyMetadata tag : tags) {
arr.add(new ExcelHeader(tag.getId(), StringUtils.isEmpty(tag.getName()) ? tag.getId() : tag.getName(), CellDataType.STRING));
}
for (ConfigPropertyMetadata config : configs) {
arr.add(new ExcelHeader("configuration." + config.getProperty(), StringUtils.isEmpty(config.getName()) ? config
.getProperty() : config.getName(), CellDataType.STRING));
}
return arr;
}
public static List<ExcelHeader> getExportHeaderMapping(DeviceExcelFilterColumns filterColumns,
List<PropertyMetadata> tags,
List<ConfigPropertyMetadata> configs) {<FILL_FUNCTION_BODY>}
public static Map<String, String> getImportHeaderMapping() {
Map<String, String> mapping = new HashMap<>();
mapping.put("设备ID", "id");
mapping.put("设备名称", "name");
mapping.put("名称", "name");
// mapping.put("所属机构", "orgName");
mapping.put("父设备ID", "parentId");
return mapping;
}
public DeviceExcelInfo initDeviceInstance(DeviceProductEntity product, Authentication auth) {
DeviceInstanceEntity entity = FastBeanCopier.copy(this, new DeviceInstanceEntity());
entity.setProductId(product.getId());
entity.setProductName(product.getName());
entity.setCreateTimeNow();
entity.setCreatorId(auth.getUser().getId());
entity.setCreatorName(auth.getUser().getName());
entity.setModifyTimeNow();
entity.setModifierId(auth.getUser().getId());
entity.setModifierName(auth.getUser().getName());
ValidatorUtils.tryValidate(entity);
this.device = entity;
return this;
}
@Override
public void fromJson(JSONObject json) {
Jsonable.super.fromJson(json);
for (Map.Entry<String, PropertyMetadata> entry : tagMapping.entrySet()) {
PropertyMetadata maybeTag = entry.getValue();
if (maybeTag != null) {
tag(
maybeTag.getId(),
entry.getKey(),
Optional.ofNullable(json.getString(maybeTag.getId())).orElse(null),
maybeTag.getValueType().getId()
);
}
}
for (Map.Entry<String, ConfigPropertyMetadata> entry : configMapping.entrySet()) {
ConfigPropertyMetadata maybeConfig = entry.getValue();
if (maybeConfig != null) {
config(
maybeConfig.getProperty(),
Optional.ofNullable(json.getString(maybeConfig.getProperty())).orElse(null)
);
}
}
}
}
|
List<ExcelHeader> arr =
Arrays.stream(new ExcelHeader[]{
new ExcelHeader("id", "设备ID", CellDataType.STRING),
new ExcelHeader("name", "设备名称", CellDataType.STRING),
new ExcelHeader("productName", "产品名称", CellDataType.STRING),
new ExcelHeader("parentId", "父设备ID", CellDataType.STRING),
new ExcelHeader("state", "状态", CellDataType.STRING)
})
.filter(a-> !filterColumns.getColumns().contains(a.getKey()))
.collect(Collectors.toList());
for (PropertyMetadata tag : tags) {
arr.add(new ExcelHeader(tag.getId(), StringUtils.isEmpty(tag.getName()) ? tag.getId() : tag.getName(), CellDataType.STRING));
}
for (ConfigPropertyMetadata config : configs) {
arr.add(new ExcelHeader("configuration." + config.getProperty(),
StringUtils.isEmpty(config.getName()) ? config.getProperty() : config.getName(),
CellDataType.STRING));
}
return arr;
| 1,494
| 277
| 1,771
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/device-manager/src/main/java/org/jetlinks/community/device/web/excel/DeviceWrapper.java
|
DeviceWrapper
|
wrap
|
class DeviceWrapper extends RowWrapper<DeviceExcelInfo> {
Map<String, PropertyMetadata> tagMapping = new HashMap<>();
Map<String, ConfigPropertyMetadata> configMapping = new HashMap<>();
static Map<String, String> headerMapping = DeviceExcelInfo.getImportHeaderMapping();
public static DeviceWrapper empty = new DeviceWrapper(Collections.emptyList(), Collections.emptyList());
public DeviceWrapper(List<PropertyMetadata> tags, List<ConfigPropertyMetadata> configs) {
for (PropertyMetadata tag : tags) {
tagMapping.put(tag.getName(), tag);
}
for (ConfigPropertyMetadata config : configs) {
configMapping.put(config.getName(), config);
}
}
@Override
protected DeviceExcelInfo newInstance() {
return new DeviceExcelInfo();
}
@Override
protected DeviceExcelInfo wrap(DeviceExcelInfo deviceExcelInfo, Cell header, Cell cell) {<FILL_FUNCTION_BODY>}
}
|
String headerText = header.valueAsText().orElse("null");
PropertyMetadata maybeTag = tagMapping.get(headerText);
ConfigPropertyMetadata maybeConfig = configMapping.get(headerText);
if (maybeTag != null) {
deviceExcelInfo.tag(maybeTag.getId(), headerText, cell.value().orElse(null), maybeTag.getValueType().getId());
} else if (maybeConfig != null) {
deviceExcelInfo.config(maybeConfig.getProperty(), cell.value().orElse(null));
} else {
deviceExcelInfo.with(headerMapping.getOrDefault(headerText, headerText), cell.value().orElse(null));
}
deviceExcelInfo.setRowNumber(cell.getRowIndex());
return deviceExcelInfo;
| 253
| 203
| 456
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/device-manager/src/main/java/org/jetlinks/community/device/web/excel/PropertyMetadataWrapper.java
|
PropertyMetadataWrapper
|
wrap
|
class PropertyMetadataWrapper extends RowWrapper<PropertyMetadataExcelInfo> {
private final Map<String, String> propertyMapping = new HashMap<>();
public PropertyMetadataWrapper(List<ConfigMetadata> expands) {
propertyMapping.put("属性ID", "property");
propertyMapping.put("属性名称", "name");
propertyMapping.put("数据类型", "dataType");
propertyMapping.put("单位", "unit");
propertyMapping.put("精度", "scale");
propertyMapping.put("数据类型配置", "valueType");
propertyMapping.put("来源", "source");
propertyMapping.put("属性说明", "description");
propertyMapping.put("读写类型", "type");
for (ConfigMetadata expand : expands) {
for (ConfigPropertyMetadata property : expand.getProperties()) {
propertyMapping.put(expand.getName() + "-" + property.getName(), property.getProperty());
propertyMapping.put(property.getName(), property.getProperty());
}
}
}
@Override
protected PropertyMetadataExcelInfo newInstance() {
return new PropertyMetadataExcelInfo();
}
@Override
protected PropertyMetadataExcelInfo wrap(PropertyMetadataExcelInfo instance, Cell header, Cell dataCell) {<FILL_FUNCTION_BODY>}
private Object propertyTypeToLowerCase(String headerText, Object value) {
if ("类型".equals(headerText)) {
return value.toString().toLowerCase();
}
return value;
}
}
|
String headerText = header.valueAsText().orElse("null");
Object value = dataCell.valueAsText().orElse("");
if (propertyMapping.containsKey(headerText)) {
instance.with(propertyMapping.get(headerText), propertyTypeToLowerCase(headerText, value));
}
instance.setRowNumber(dataCell.getRowIndex() + 1);
return instance;
| 378
| 103
| 481
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/device-manager/src/main/java/org/jetlinks/community/device/web/protocol/ProtocolDetail.java
|
ProtocolDetail
|
of
|
class ProtocolDetail {
@Schema(description = "协议ID")
private String id;
@Schema(description = "协议名称")
private String name;
@Schema(description = "协议说明")
private String description;
private List<TransportDetail> transports;
public static Mono<ProtocolDetail> of(ProtocolSupport support) {<FILL_FUNCTION_BODY>}
}
|
return support
.getSupportedTransport()
.flatMap(trans -> TransportDetail.of(support, trans))
.collectList()
.map(details -> new ProtocolDetail(support.getId(), support.getName(),support.getDescription(), details));
| 104
| 68
| 172
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/device-manager/src/main/java/org/jetlinks/community/device/web/protocol/TransportDetail.java
|
TransportDetail
|
of
|
class TransportDetail {
@Schema(description = "ID")
private String id;
@Schema(description = "名称")
private String name;
@Schema(description = "其他设置")
private List<ProtocolFeature> features;
@Schema(description = "路由信息")
private List<Route> routes;
@Schema(description = "文档信息")
private String document;
@Schema(description = "默认物模型")
private String metadata;
public static Mono<TransportDetail> of(ProtocolSupport support, Transport transport) {<FILL_FUNCTION_BODY>}
}
|
return Mono
.zip(
support
//T1: 路由信息
.getRoutes(transport)
.collectList(),
support
//T2: 协议特性
.getFeatures(transport)
.map(ProtocolFeature::of)
.collectList(),
support
//T3: 默认物模型
.getDefaultMetadata(transport)
.flatMap(JetLinksDeviceMetadataCodec.getInstance()::encode)
.defaultIfEmpty("")
)
.map(tp3 -> new TransportDetail(
transport.getId(),
transport.getName(),
tp3.getT2(),
tp3.getT1(),
support.getDocument(transport),
tp3.getT3()));
| 158
| 199
| 357
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/device-manager/src/main/java/org/jetlinks/community/device/web/request/ProtocolDecodePayload.java
|
ProtocolDecodePayload
|
doDecode
|
class ProtocolDecodePayload {
private DefaultTransport transport;
private PayloadType payloadType = PayloadType.STRING;
private String payload;
public EncodedMessage toEncodedMessage() {
if (transport == DefaultTransport.MQTT || transport == DefaultTransport.MQTT_TLS) {
if (payload.startsWith("{")) {
SimpleMqttMessage message = FastBeanCopier.copy(JSON.parseObject(payload), new SimpleMqttMessage());
message.setPayloadType(MessagePayloadType.of(payloadType.getId()));
}
return SimpleMqttMessage.of(payload);
} else if (transport == DefaultTransport.CoAP || transport == DefaultTransport.CoAP_DTLS) {
return DefaultCoapMessage.of(payload);
}
return EncodedMessage.simple(payloadType.write(payload));
}
public Publisher<? extends Message> doDecode(ProtocolSupport support, DeviceOperator deviceOperator) {<FILL_FUNCTION_BODY>}
}
|
return support
.getMessageCodec(getTransport())
.flatMapMany(codec -> codec.decode(new FromDeviceMessageContext() {
@Override
public EncodedMessage getMessage() {
return toEncodedMessage();
}
@Override
public DeviceSession getSession() {
return null;
}
@Nullable
@Override
public DeviceOperator getDevice() {
return deviceOperator;
}
}));
| 265
| 116
| 381
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/device-manager/src/main/java/org/jetlinks/community/device/web/request/ProtocolEncodePayload.java
|
ProtocolEncodePayload
|
doEncode
|
class ProtocolEncodePayload {
private DefaultTransport transport;
private String payload;
private PayloadType payloadType = PayloadType.STRING;
public Message toDeviceMessage() {
return MessageType.convertMessage(JSON.parseObject(payload))
.orElseThrow(() -> new IllegalArgumentException("无法识别的消息"));
}
public Publisher<Object> doEncode(ProtocolSupport support, DeviceOperator operator) {<FILL_FUNCTION_BODY>}
}
|
return support.getMessageCodec(getTransport())
.flatMapMany(codec -> codec.encode(new MessageEncodeContext() {
@Override
public Message getMessage() {
return toDeviceMessage();
}
@Nullable
@Override
public DeviceOperator getDevice() {
return operator;
}
}))
.map(msg -> {
if (msg instanceof MqttMessage) {
JSONObject obj = (JSONObject) JSON.toJSON(msg);
obj.put("payload", payloadType.read(msg.getPayload()));
obj.remove("bytes");
return obj;
}
return getPayloadType().read(msg.getPayload());
});
| 125
| 182
| 307
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/device-manager/src/main/java/org/jetlinks/community/device/web/request/TransparentMessageDecodeRequest.java
|
TransparentMessageDecodeRequest
|
toMessage
|
class TransparentMessageDecodeRequest extends TransparentMessageCodecRequest {
// headers:{
// "topic":"/xxxx",
// "url":"/xxx"
// }
private Map<String, Object> headers;
@NotBlank
private String payload;
@SneakyThrows
public DirectDeviceMessage toMessage() {<FILL_FUNCTION_BODY>}
}
|
ValidatorUtils.tryValidate(this);
DirectDeviceMessage message = new DirectDeviceMessage();
message.setDeviceId("test");
if (MapUtils.isNotEmpty(headers)) {
headers.forEach(message::addHeader);
}
byte[] data;
if (payload.startsWith("0x")) {
data = Hex.decodeHex(payload.substring(2));
} else {
data = payload.getBytes(StandardCharsets.UTF_8);
}
message.setPayload(data);
return message;
| 102
| 147
| 249
|
<methods>public non-sealed void <init>() <variables>private Map<java.lang.String,java.lang.Object> configuration,private @NotBlank String provider
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/device-manager/src/main/java/org/jetlinks/community/device/web/response/ChildrenDeviceInfo.java
|
ChildrenDeviceInfo
|
of
|
class ChildrenDeviceInfo {
private String id;
private String name;
private String description;
private DeviceState state;
public static ChildrenDeviceInfo of(DeviceInstanceEntity instance){<FILL_FUNCTION_BODY>}
}
|
ChildrenDeviceInfo deviceInfo=new ChildrenDeviceInfo();
deviceInfo.setId(instance.getId());
deviceInfo.setName(instance.getName());
deviceInfo.setState(instance.getState());
deviceInfo.setDescription(instance.getDescribe());
return deviceInfo;
| 64
| 74
| 138
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/device-manager/src/main/java/org/jetlinks/community/device/web/response/GatewayDeviceInfo.java
|
GatewayDeviceInfo
|
of
|
class GatewayDeviceInfo {
private String id;
private String name;
private String description;
private DeviceState state;
private List<ChildrenDeviceInfo> children;
public static GatewayDeviceInfo of(DeviceInstanceEntity gateway, List<DeviceInstanceEntity> children) {<FILL_FUNCTION_BODY>}
}
|
GatewayDeviceInfo info = new GatewayDeviceInfo();
info.setId(gateway.getId());
info.setName(gateway.getName());
info.setDescription(gateway.getDescribe());
info.setState(gateway.getState());
info.setChildren(children.stream().map(ChildrenDeviceInfo::of).collect(Collectors.toList()));
return info;
| 88
| 102
| 190
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/device-manager/src/main/java/org/jetlinks/community/device/web/response/TransparentMessageDecodeResponse.java
|
TransparentMessageDecodeResponse
|
error
|
class TransparentMessageDecodeResponse {
private boolean success;
private String reason;
private List<Object> outputs;
public static TransparentMessageDecodeResponse of(List<DeviceMessage> messages) {
TransparentMessageDecodeResponse response = new TransparentMessageDecodeResponse();
response.success = true;
response.outputs = messages
.stream()
.map(DeviceMessage::toJson)
.collect(Collectors.toList());
return response;
}
public static TransparentMessageDecodeResponse error(String reason) {<FILL_FUNCTION_BODY>}
public static TransparentMessageDecodeResponse of(Throwable err) {
return error(err.getLocalizedMessage());
}
}
|
TransparentMessageDecodeResponse response = new TransparentMessageDecodeResponse();
response.success = false;
response.reason = reason;
return response;
| 187
| 42
| 229
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/network-manager/src/main/java/org/jetlinks/community/network/manager/debug/DebugUtils.java
|
DebugUtils
|
stringToBytes
|
class DebugUtils {
static byte[] stringToBytes(String text){<FILL_FUNCTION_BODY>}
}
|
byte[] payload;
if (StringUtils.isEmpty(text)) {
payload = new byte[0];
} else {
if (text.startsWith("0x")) {
payload = ByteBufUtil.decodeHexDump(text, 2, text.length()-2);
} else {
payload = text.getBytes();
}
}
return payload;
| 33
| 99
| 132
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/network-manager/src/main/java/org/jetlinks/community/network/manager/debug/DeviceDebugSubscriptionProvider.java
|
DeviceDebugSubscriptionProvider
|
handleTraceEnable
|
class DeviceDebugSubscriptionProvider implements SubscriptionProvider {
private final EventBus eventBus;
private final DeviceRegistry registry;
@Override
public String id() {
return "device-debug";
}
@Override
public String name() {
return "设备诊断";
}
@Override
public String[] getTopicPattern() {
return new String[]{"/debug/device/*/trace"};
}
@Override
public Flux<?> subscribe(SubscribeRequest request) {
String deviceId = TopicUtils
.getPathVariables("/debug/device/{deviceId}/trace", request.getTopic())
.get("deviceId");
return startDebug(deviceId);
}
/**
* @param deviceId deviceId
* @see DeviceTracer
* @see EventBusSpanExporter
*/
Flux<TraceData> startDebug(String deviceId) {
if (TraceHolder.isDisabled()) {
return Flux
.just(TraceData
.of(TraceDataType.log,
true,
"0",
"error",
"链路追踪功能已禁用,请联系管理员.",
System.currentTimeMillis(),
System.currentTimeMillis()));
}
//订阅设备跟踪信息
return Flux
.merge(this
.getTraceData(DeviceTracer.SpanName.operation(deviceId, "*"))
.flatMap(this::convertDeviceTrace),
registry
.getDevice(deviceId)
.flatMap(device -> device
.getProtocol()
.map(pro -> ProtocolTracer.SpanName.operation(pro.getId(), "*")))
.flatMapMany(this::getTraceData)
.flatMap(this::convertProtocolTrace)
);
}
private Mono<TraceData> convertProtocolTrace(SpanDataInfo traceData) {
String errorInfo = traceData
.getEvent(SemanticAttributes.EXCEPTION_EVENT_NAME)
.flatMap(event -> event.getAttribute(SemanticAttributes.EXCEPTION_STACKTRACE))
.orElse(null);
String operation = traceData.getName().substring(traceData.getName().lastIndexOf("/") + 1);
//协议跟踪只展示错误信息,因为协议无法定位到具体的设备,如果现实全部跟踪信息可能会有很多信息
if (StringUtils.hasText(errorInfo)) {
return Mono.just(TraceData
.of(TraceDataType.log,
true,
traceData.getTraceId(),
operation,
getDeviceTraceDetail(traceData),
traceData.getStartWithNanos() / 1000 / 1000,
traceData.getStartWithNanos() / 1000 / 1000
));
}
return Mono.empty();
}
private boolean hasError(SpanDataInfo data) {
return data
.getEvent(SemanticAttributes.EXCEPTION_EVENT_NAME)
.isPresent();
}
private Object getDeviceTraceDetail(SpanDataInfo data) {
String message = data
.getAttribute(DeviceTracer.SpanKey.message)
.orElse(null);
String response = data
.getAttribute(DeviceTracer.SpanKey.response)
.orElse(null);
if (StringUtils.hasText(message)) {
if (StringUtils.hasText(response)) {
return String.join("\n\n", response);
}
return message;
}
if (StringUtils.hasText(response)) {
return response;
}
String errorInfo = data
.getEvent(SemanticAttributes.EXCEPTION_EVENT_NAME)
.flatMap(event -> event.getAttribute(SemanticAttributes.EXCEPTION_STACKTRACE))
.orElse(null);
if (StringUtils.hasText(errorInfo)) {
return errorInfo;
}
return JSON.toJSONString(data.getAttributes(), SerializerFeature.PrettyFormat);
}
private Mono<TraceData> convertDeviceTrace(SpanDataInfo traceData) {
String name = traceData.getName();
String operation = name.substring(name.lastIndexOf("/") + 1);
return Mono.just(TraceData
.of(TraceDataType.data,
hasError(traceData),
traceData.getTraceId(),
operation,
getDeviceTraceDetail(traceData),
traceData.getStartWithNanos() / 1000 / 1000,
traceData.getStartWithNanos() / 1000 / 1000
));
}
private Flux<SpanDataInfo> getTraceData(String name) {
//启用跟踪
Disposable disposable = enableSpan(name);
return eventBus
.subscribe(Subscription
.builder()
.subscriberId("device_debug_tracer")
.topics("/trace/*" + name)
.broker()
.local()
.build(),
SpanDataInfo.class)
//完成时关闭跟踪
.doFinally(s -> disposable.dispose());
}
private Disposable enableSpan(String name) {
Disposable.Composite disposable = Disposables.composite();
String id = IDGenerator.UUID.generate();
eventBus
.publish("/_sys/_trace/opt", new TraceOpt(id, name, true))
.subscribe();
disposable.add(() -> eventBus
.publish("/_sys/_trace/opt", new TraceOpt(id, name, false))
.subscribe());
return disposable;
}
@Subscribe(value = "/_sys/_trace/opt", features = {Subscription.Feature.broker, Subscription.Feature.local})
public Mono<Void> handleTraceEnable(TraceOpt opt) {<FILL_FUNCTION_BODY>}
@Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor
public static class TraceOpt {
private String id;
private String span;
private boolean enable;
}
public enum TraceDataType {
/**
* 和设备有关联的数据
*/
data,
/**
* 和设备没有关联的日志信息
*/
log
}
@Setter
@Getter
@AllArgsConstructor(staticName = "of")
@NoArgsConstructor
@ToString
public static class TraceData implements Serializable {
static Set<String> downstreamOperation = new HashSet<>(
Arrays.asList(
"downstream", "encode", "request"
)
);
private static final long serialVersionUID = 1L;
// 跟踪数据类型
private TraceDataType type;
//是否有错误信息
private boolean error;
// 跟踪ID
private String traceId;
/**
* @see DeviceTracer.SpanName
* 操作. encode,decode
*/
private String operation;
// 数据内容
private Object detail;
//开始时间 毫秒
private long startTime;
//结束时间 毫秒
private long endTime;
//是否上行操作
public boolean isUpstream() {
return !isDownstream();
}
//是否下行操作
public boolean isDownstream() {
return operation != null && downstreamOperation.contains(operation);
}
}
}
|
if (opt.enable) {
log.debug("enable trace {} id:{}", opt.span, opt.id);
TraceHolder.enable(opt.span, opt.id);
} else {
log.debug("remove trace {} id:{}", opt.span, opt.id);
TraceHolder.removeEnabled(opt.span, opt.id);
}
return Mono.empty();
| 1,924
| 103
| 2,027
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/network-manager/src/main/java/org/jetlinks/community/network/manager/debug/MqttClientDebugSubscriptionProvider.java
|
MqttClientDebugSubscriptionProvider
|
subscribe
|
class MqttClientDebugSubscriptionProvider implements SubscriptionProvider {
private final NetworkManager networkManager;
public MqttClientDebugSubscriptionProvider(NetworkManager networkManager) {
this.networkManager = networkManager;
}
@Override
public String id() {
return "network-client-mqtt-debug";
}
@Override
public String name() {
return "MQTT客户端调试";
}
@Override
public String[] getTopicPattern() {
return new String[]{
"/network/mqtt/client/*/_subscribe/*",
"/network/mqtt/client/*/_publish/*"
};
}
@Override
public Flux<Object> subscribe(SubscribeRequest request) {<FILL_FUNCTION_BODY>}
public Flux<Object> mqttClientSubscribe(MqttClient client,
PayloadType type,
SubscribeRequest request) {
String topics = request.getString("topics", "/#");
return client
.subscribe(Arrays.asList(topics.split("[\n]")))
.map(mqttMessage -> Message.success(request.getId(), request.getTopic(), MqttMessageResponse.of(mqttMessage, type)));
}
public Flux<String> mqttClientPublish(MqttClient client,
PayloadType type,
SubscribeRequest request) {
MqttMessageRequest messageRequest = FastBeanCopier.copy(request.values(), new MqttMessageRequest());
return client
.publish(MqttMessageRequest.of(messageRequest, type))
.thenReturn("推送成功")
.flux();
}
}
|
DebugAuthenticationHandler.handle(request);
Map<String, String> vars = TopicUtils.getPathVariables("/network/mqtt/client/{id}/{pubsub}/{type}", request.getTopic());
String clientId = vars.get("id");
String pubsub = vars.get("pubsub");
PayloadType type = PayloadType.valueOf(vars.get("type").toUpperCase());
return networkManager
.<MqttClient>getNetwork(DefaultNetworkType.MQTT_CLIENT, clientId)
.flatMapMany(mqtt ->
"_subscribe".equals(pubsub)
? mqttClientSubscribe(mqtt, type, request)
: mqttClientPublish(mqtt, type, request))
;
| 438
| 203
| 641
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/network-manager/src/main/java/org/jetlinks/community/network/manager/debug/MqttServerDebugSubscriptionProvider.java
|
MqttClientMessage
|
of
|
class MqttClientMessage {
private String type;
private String typeText;
private Object data;
public static MqttClientMessage of(MqttConnection connection) {
Map<String, Object> data = new HashMap<>();
data.put("clientId", connection.getClientId());
data.put("address", connection.getClientAddress().toString());
connection.getAuth().ifPresent(auth -> {
data.put("username", auth.getUsername());
data.put("password", auth.getPassword());
});
return MqttClientMessage.of("connection", "连接", data);
}
public static MqttClientMessage ofDisconnect(MqttConnection connection) {
Map<String, Object> data = new HashMap<>();
data.put("clientId", connection.getClientId());
data.put("address", connection.getClientAddress().toString());
connection.getAuth().ifPresent(auth -> {
data.put("username", auth.getUsername());
data.put("password", auth.getPassword());
});
return MqttClientMessage.of("disconnection", "断开连接", data);
}
public static MqttClientMessage of(MqttConnection connection, MqttSubscription subscription) {
Map<String, Object> data = new HashMap<>();
data.put("clientId", connection.getClientId());
data.put("address", connection.getClientAddress().toString());
data.put("topics", subscription
.getMessage()
.topicSubscriptions()
.stream()
.map(subs -> "QoS:" + subs.qualityOfService().value() + " Topic:" + subs.topicName())
);
return MqttClientMessage.of("subscription", "订阅", data);
}
public static MqttClientMessage of(MqttConnection connection, MqttUnSubscription subscription) {<FILL_FUNCTION_BODY>}
public static MqttClientMessage of(MqttConnection connection, MqttPublishing subscription, PayloadType type) {
Map<String, Object> data = new HashMap<>();
data.put("clientId", connection.getClientId());
data.put("address", connection.getClientAddress().toString());
data.put("message", MqttMessageResponse.of(subscription.getMessage(), type));
return MqttClientMessage.of("publish", "推送消息", data);
}
}
|
Map<String, Object> data = new HashMap<>();
data.put("clientId", connection.getClientId());
data.put("address", connection.getClientAddress().toString());
data.put("topics", subscription
.getMessage()
.topics()
);
return MqttClientMessage.of("unsubscription", "取消订阅", data);
| 620
| 95
| 715
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/network-manager/src/main/java/org/jetlinks/community/network/manager/debug/TcpClientDebugSubscriptionProvider.java
|
TcpClientDebugSubscriptionProvider
|
subscribe
|
class TcpClientDebugSubscriptionProvider implements SubscriptionProvider {
private final NetworkManager networkManager;
public TcpClientDebugSubscriptionProvider(NetworkManager networkManager) {
this.networkManager = networkManager;
}
@Override
public String id() {
return "network-tcp-client-debug";
}
@Override
public String name() {
return "TCP客户端调试";
}
@Override
public String[] getTopicPattern() {
return new String[]{
"/network/tcp/client/*/_send",
"/network/tcp/client/*/_subscribe"
};
}
@Override
public Flux<String> subscribe(SubscribeRequest request) {
String id = request.getTopic().split("[/]")[4];
if (request.getTopic().endsWith("_send")) {
return send(id, request);
} else {
return subscribe(id, request);
}
}
public Flux<String> send(String id, SubscribeRequest request) {
String message = request.getString("request")
.orElseThrow(() -> new IllegalArgumentException("参数[request]不能为空"));
byte[] payload=DebugUtils.stringToBytes(message);
return networkManager
.<TcpClient>getNetwork(DefaultNetworkType.TCP_CLIENT, id)
.flatMap(client -> client.send(new TcpMessage(Unpooled.wrappedBuffer(payload))))
.thenReturn("推送成功")
.flux();
}
@SuppressWarnings("all")
public Flux<String> subscribe(String id, SubscribeRequest request) {<FILL_FUNCTION_BODY>}
}
|
String message = request.getString("response").filter(StringUtils::hasText).orElse(null);
byte[] payload =DebugUtils.stringToBytes(message);
return networkManager
.<TcpClient>getNetwork(DefaultNetworkType.TCP_CLIENT, id)
.flatMapMany(client -> client
.subscribe()
.flatMap(msg -> client
.send(new TcpMessage(Unpooled.wrappedBuffer(payload)))
.thenReturn(msg))
.map(TcpMessage::toString)
);
| 439
| 142
| 581
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/network-manager/src/main/java/org/jetlinks/community/network/manager/debug/TcpServerDebugSubscriptionProvider.java
|
TcpServerDebugSubscriptionProvider
|
subscribe
|
class TcpServerDebugSubscriptionProvider implements SubscriptionProvider {
private final NetworkManager networkManager;
public TcpServerDebugSubscriptionProvider(NetworkManager networkManager) {
this.networkManager = networkManager;
}
@Override
public String id() {
return "network-tcp-server-debug";
}
@Override
public String name() {
return "TCP服务调试";
}
@Override
public String[] getTopicPattern() {
return new String[]{
"/network/tcp/server/*/_subscribe"
};
}
@Override
public Flux<TcpClientMessage> subscribe(SubscribeRequest request) {
String id = request.getTopic().split("[/]")[4];
return subscribe(id, request);
}
@SuppressWarnings("all")
public Flux<TcpClientMessage> subscribe(String id, SubscribeRequest request) {<FILL_FUNCTION_BODY>}
@AllArgsConstructor(staticName = "of")
@Getter
@Setter
public static class TcpClientMessage {
private String type;
private String typeText;
private Object data;
public static TcpClientMessage of(TcpClient client) {
Map<String, Object> data = new HashMap<>();
data.put("address", client.getRemoteAddress());
return TcpClientMessage.of("connection", "连接", data);
}
public static TcpClientMessage ofDisconnect(TcpClient client) {
Map<String, Object> data = new HashMap<>();
data.put("address", client.getRemoteAddress());
return TcpClientMessage.of("disconnection", "断开连接", data);
}
public static TcpClientMessage of(TcpClient connection, TcpMessage message) {
Map<String, Object> data = new HashMap<>();
data.put("address", connection.getRemoteAddress().toString());
data.put("message", message.toString());
return TcpClientMessage.of("publish", "订阅", data);
}
}
}
|
String message = request.getString("response").filter(StringUtils::hasText).orElse(null);
byte[] payload = DebugUtils.stringToBytes(message);
return Flux.create(sink ->
sink.onDispose(networkManager
.<TcpServer>getNetwork(DefaultNetworkType.TCP_SERVER, id)
.flatMap(server ->
server
.handleConnection()
.doOnNext(client -> sink.next(TcpClientMessage.of(client)))
.flatMap(client -> {
client.onDisconnect(() -> {
sink.next(TcpClientMessage.ofDisconnect(client));
});
return client
.subscribe()
.map(msg -> TcpClientMessage.of(client, msg))
.doOnNext(sink::next)
.flatMap(msg -> {
if (payload.length > 0) {
return client.send(new TcpMessage(Unpooled.wrappedBuffer(payload)));
}
return Mono.empty();
})
.then();
})
.then()
)
.doOnError(sink::error)
.subscriberContext(sink.currentContext())
.subscribe()
));
| 538
| 322
| 860
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/network-manager/src/main/java/org/jetlinks/community/network/manager/entity/CertificateEntity.java
|
CertificateConfig
|
validate
|
class CertificateConfig {
@Schema(description = "PEM:私钥内容")
private String key;
@Schema(description = "PEM:证书内容")
private String cert;
@Schema(description = "PEM:信任证书,用于客户端模式")
private String trust;
//JKS 或者 PFX 才有效
@Schema(description = "证书库内容(base64)", hidden = true)
private String keystoreBase64;
//JKS 或者 PFX 才有效
@Schema(description = "信任库内容(base64)", hidden = true)
private String trustKeyStoreBase64;
//JKS 或者 PFX 才有效
@Schema(description = "证书密码", hidden = true)
private String keystorePwd;
//JKS 或者 PFX 才有效
@Schema(description = "信任库密码", hidden = true)
private String trustKeyStorePwd;
}
@Override
public void tryValidate(Class<?>... groups) {
super.tryValidate(groups);
//新增时校验证书
if (groups.length == 0 || groups[0] == CreateGroup.class) {
validate();
}
}
public void validate() {<FILL_FUNCTION_BODY>
|
Assert.notNull(configs, "error.cert_configs_can_not_be_null");
if (format == CertificateFormat.PEM) {
if (mode == CertificateMode.server) {
Assert.hasText(configs.getKey(), "error.pem_key_can_not_be_empty");
Assert.hasText(configs.getCert(), "error.pem_cert_can_not_be_empty");
} else if (mode == CertificateMode.client) {
Assert.hasText(configs.getTrust(), "error.pem_trust_can_not_be_empty");
}
}
format.init(new DefaultCertificate(getId(), getName()), configs);
| 339
| 184
| 523
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/network-manager/src/main/java/org/jetlinks/community/network/manager/entity/NetworkConfigEntity.java
|
NetworkConfigEntity
|
getConfig
|
class NetworkConfigEntity extends GenericEntity<String> implements RecordCreationEntity {
@Column
@NotNull(message = "名称不能为空")
@Schema(description = "名称")
@Generated
private String name;
@Column
@Generated
@Schema(description = "说明")
private String description;
/**
* 组件类型
*
* @see NetworkType
* @see org.jetlinks.community.network.NetworkTypes
*/
@Schema(description="组件类型")
@Generated
@Column(nullable = false)
@NotNull(message = "类型不能为空")
private String type;
@Column(nullable = false)
@EnumCodec
@Generated
@ColumnType(javaType = String.class)
@DefaultValue("enabled")
@Schema(description = "状态")
private NetworkConfigState state;
@Column(updatable = false)
@Schema(
description = "创建者ID(只读)"
, accessMode = Schema.AccessMode.READ_ONLY
)
@Generated
private String creatorId;
@Column(updatable = false)
@DefaultValue(generator = Generators.CURRENT_TIME)
@Schema(
description = "创建时间(只读)"
, accessMode = Schema.AccessMode.READ_ONLY
)
@Generated
private Long createTime;
@Column
@Generated
@JsonCodec
@ColumnType(jdbcType = JDBCType.CLOB, javaType = String.class)
@Schema(description = "配置(根据类型不同而不同)")
private Map<String, Object> configuration;
@Column
@Generated
@DefaultValue("true")
@Schema(description = "集群是否共享配置")
private Boolean shareCluster;
@Column
@Generated
@JsonCodec
@ColumnType(jdbcType = JDBCType.CLOB, javaType = String.class)
@Schema(description = "集群配置")
private List<Configuration> cluster;
public Optional<Map<String, Object>> getConfig(String serverId) {<FILL_FUNCTION_BODY>}
public NetworkType lookupNetworkType() {
return NetworkType.lookup(type).orElseGet(() -> NetworkType.of(type));
}
public NetworkType getTypeObject() {
return lookupNetworkType();
}
public List<NetworkProperties> toNetworkPropertiesList() {
if (Boolean.FALSE.equals(shareCluster) && cluster != null) {
return cluster
.stream()
.map(conf -> toNetworkProperties(conf.configuration))
.collect(Collectors.toList());
} else {
return Collections.singletonList(toNetworkProperties(configuration));
}
}
@Getter
@Setter
@Generated
public static class Configuration implements Serializable {
private String serverId;
private Map<String, Object> configuration;
}
public NetworkProperties toNetworkProperties(Map<String, Object> conf) {
NetworkProperties properties = new NetworkProperties();
properties.setConfigurations(conf);
properties.setEnabled(state == NetworkConfigState.enabled);
properties.setId(getId());
properties.setType(getType());
properties.setName(name);
return properties;
}
public NetworkProperties toNetworkProperties() {
return toNetworkProperties(configuration);
}
}
|
if ((Boolean.FALSE.equals(shareCluster))
&& CollectionUtils.isNotEmpty(cluster)) {
return cluster.stream()
.filter(conf -> serverId.equals(conf.serverId))
.findAny()
.map(Configuration::getConfiguration);
}
return Optional.ofNullable(configuration);
| 884
| 83
| 967
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/network-manager/src/main/java/org/jetlinks/community/network/manager/service/CertificateService.java
|
CertificateService
|
getCertificate
|
class CertificateService
extends GenericReactiveCrudService<CertificateEntity, String>
implements CertificateManager {
@Override
public Mono<Certificate> getCertificate(String id) {<FILL_FUNCTION_BODY>}
}
|
return createQuery()
.where(CertificateEntity::getId, id)
.fetchOne()
.map(entity -> {
DefaultCertificate defaultCertificate = new DefaultCertificate(entity.getId(), entity.getName());
return entity.getFormat().init(defaultCertificate, entity.getConfigs());
});
| 64
| 82
| 146
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/network-manager/src/main/java/org/jetlinks/community/network/manager/service/DeviceGatewayConfigService.java
|
DeviceGatewayConfigService
|
getReference
|
class DeviceGatewayConfigService implements DeviceGatewayPropertiesManager, DataReferenceProvider {
private final DeviceGatewayService deviceGatewayService;
@Override
public String getId() {
return DataReferenceManager.TYPE_NETWORK;
}
@Override
public Flux<DataReferenceInfo> getReference(String networkId) {<FILL_FUNCTION_BODY>}
@Override
public Flux<DataReferenceInfo> getReferences() {
return deviceGatewayService
.createQuery()
.where()
.and(DeviceGatewayEntity::getChannel, DeviceGatewayProvider.CHANNEL_NETWORK)
.notNull(DeviceGatewayEntity::getChannelId)
.fetch()
.map(e -> DataReferenceInfo.of(e.getId(),DataReferenceManager.TYPE_NETWORK, e.getChannelId(), e.getName()));
}
public DeviceGatewayConfigService(DeviceGatewayService deviceGatewayService) {
this.deviceGatewayService = deviceGatewayService;
}
@Override
public Mono<DeviceGatewayProperties> getProperties(String id) {
return deviceGatewayService
.findById(id)
// .switchIfEmpty(Mono.error(new NotFoundException("该设备网关不存在")))
.map(DeviceGatewayEntity::toProperties);
}
@Override
public Flux<DeviceGatewayProperties> getPropertiesByChannel(String channel) {
return deviceGatewayService
.createQuery()
.where()
.and(DeviceGatewayEntity::getChannel, channel)
.fetch()
.map(DeviceGatewayEntity::toProperties);
}
}
|
return deviceGatewayService
.createQuery()
.where()
.and(DeviceGatewayEntity::getChannel, DeviceGatewayProvider.CHANNEL_NETWORK)
.is(DeviceGatewayEntity::getChannelId, networkId)
.fetch()
.map(e -> DataReferenceInfo.of(e.getId(),DataReferenceManager.TYPE_NETWORK, e.getChannelId(), e.getName()));
| 444
| 112
| 556
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/network-manager/src/main/java/org/jetlinks/community/network/manager/service/DeviceGatewayEventHandler.java
|
DeviceGatewayEventHandler
|
putGatewayInfo
|
class DeviceGatewayEventHandler implements CommandLineRunner {
public static final String DO_NOT_RELOAD_GATEWAY = "_do_not_reload_device_gateway";
private final DeviceGatewayService deviceGatewayService;
private final DeviceGatewayManager deviceGatewayManager;
private final DataReferenceManager referenceManager;
private final Duration gatewayStartupDelay = Duration.ofSeconds(5);
public DeviceGatewayEventHandler(DeviceGatewayService deviceGatewayService,
DeviceGatewayManager deviceGatewayManager,
DataReferenceManager referenceManager) {
this.deviceGatewayService = deviceGatewayService;
this.deviceGatewayManager = deviceGatewayManager;
this.referenceManager = referenceManager;
}
@EventListener
public void handlePrepareSave(EntityPrepareSaveEvent<DeviceGatewayEntity> event) {
putGatewayInfo(event.getEntity());
event.async(gatewayConfigValidate(event.getEntity()));
}
@EventListener
public void handlePrepareCreate(EntityPrepareCreateEvent<DeviceGatewayEntity> event) {
putGatewayInfo(event.getEntity());
event.async(gatewayConfigValidate(event.getEntity()));
}
@EventListener
public void handlePrepareUpdate(EntityPrepareModifyEvent<DeviceGatewayEntity> event) {
putGatewayInfo(event.getAfter());
event.async(gatewayConfigValidate(event.getBefore()));
}
@EventListener
public void handleGatewayDelete(EntityBeforeDeleteEvent<DeviceGatewayEntity> event) {
//删除网关时检测是否已被使用
event.async(
Flux.fromIterable(event.getEntity())
.flatMap(gateway -> referenceManager.assertNotReferenced(DataReferenceManager.TYPE_DEVICE_GATEWAY, gateway.getId()))
);
}
@EventListener
public void handleCreated(EntityCreatedEvent<DeviceGatewayEntity> event) {
event.async(
reloadGateway(Flux
.fromIterable(event.getEntity())
.filter(gateway -> gateway.getState() == DeviceGatewayState.enabled))
);
}
@EventListener
public void handleSaved(EntitySavedEvent<DeviceGatewayEntity> event) {
event.async(
reloadGateway(Flux
.fromIterable(event.getEntity())
.filter(gateway -> gateway.getState() == DeviceGatewayState.enabled))
);
}
//网关更新时，自动重新加载
@EventListener
public void handleModify(EntityModifyEvent<DeviceGatewayEntity> event) {
event.async(
Mono.deferContextual(ctx -> {
if (ctx.getOrEmpty(DO_NOT_RELOAD_GATEWAY).isPresent()) {
return Mono.empty();
}
return reloadGateway(Flux
.fromIterable(event.getAfter())
.filter(gateway -> gateway.getState() == DeviceGatewayState.enabled));
})
);
}
private Mono<Void> reloadGateway(Flux<DeviceGatewayEntity> gatewayEntities) {
return gatewayEntities
.flatMap(gateway -> deviceGatewayManager.reload(gateway.getId()))
.then();
}
private void putGatewayInfo(List<DeviceGatewayEntity> entities) {<FILL_FUNCTION_BODY>}
// 检验网关配置参数
private Mono<Void> gatewayConfigValidate(List<DeviceGatewayEntity> entityList) {
return Flux.fromIterable(entityList)
.filter(entity -> entity.getConfiguration() != null)
.flatMap(entity ->
Mono.justOrEmpty(deviceGatewayManager.getProvider(entity.getProvider()))
.switchIfEmpty(Mono.error(
() -> new UnsupportedOperationException("error.unsupported_device_gateway_provider")
))
.flatMap(gatewayProvider -> gatewayProvider.createDeviceGateway(entity.toProperties())))
.then();
}
@Override
public void run(String... args) {
log.debug("start device gateway in {} later", gatewayStartupDelay);
Mono.delay(gatewayStartupDelay)
.then(
Mono.defer(() -> deviceGatewayService
.createQuery()
.where()
.and(DeviceGatewayEntity::getState, DeviceGatewayState.enabled)
.fetch()
.map(DeviceGatewayEntity::getId)
.flatMap(id -> Mono
.defer(() -> deviceGatewayManager
.getGateway(id)
.flatMap(DeviceGateway::startup))
.onErrorResume((err) -> {
log.error(err.getMessage(), err);
return Mono.empty();
})
)
.then())
)
.subscribe();
}
}
|
for (DeviceGatewayEntity entity : entities) {
DeviceGatewayProvider provider = deviceGatewayManager
.getProvider(entity.getProvider())
.orElseThrow(() -> new UnsupportedOperationException("error.unsupported_device_gateway_provider"));
if (!StringUtils.hasText(entity.getId())) {
entity.setId(IDGenerator.SNOW_FLAKE_STRING.generate());
}
//接入方式
entity.setChannel(provider.getChannel());
//传输协议,如TCP,MQTT
if (!StringUtils.hasText(entity.getTransport())) {
entity.setTransport(provider.getTransport().getId());
}
//没有指定channelId则使用id作为channelId
if (!StringUtils.hasText(entity.getChannelId())) {
entity.setChannelId(entity.getId());
}
//协议
if (provider instanceof ProtocolSupport) {
entity.setProtocol(provider.getId());
}
}
| 1,309
| 253
| 1,562
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/network-manager/src/main/java/org/jetlinks/community/network/manager/service/DeviceGatewayService.java
|
DeviceGatewayService
|
deleteById
|
class DeviceGatewayService extends GenericReactiveCrudService<DeviceGatewayEntity, String> {
public Mono<Integer> updateState(String id, DeviceGatewayState state) {
return createUpdate()
.where()
.and(DeviceGatewayEntity::getId, id)
.set(DeviceGatewayEntity::getState, state)
.set(DeviceGatewayEntity::getStateTime, System.currentTimeMillis())
.execute()
.contextWrite(Context.of(DO_NOT_RELOAD_GATEWAY, true));
}
@Override
public Mono<Integer> deleteById(Publisher<String> idPublisher) {<FILL_FUNCTION_BODY>}
}
|
return this
.findById(Flux.from(idPublisher))
.switchIfEmpty(Mono.error(new NotFoundException("error.device_gateway_not_exist")))
.doOnNext(deviceGatewayEntity -> {
if (DeviceGatewayState.enabled.equals(deviceGatewayEntity.getState())) {
throw new UnsupportedOperationException("error.device_gateway_enabled");
}
})
.map(DeviceGatewayEntity::getId)
.as(super::deleteById);
| 185
| 137
| 322
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/network-manager/src/main/java/org/jetlinks/community/network/manager/service/NetworkChannelProvider.java
|
NetworkChannelProvider
|
toChannelInfo
|
class NetworkChannelProvider implements ChannelProvider {
public static final String CHANNEL = "network";
private final NetworkManager networkManager;
private final NetworkConfigService configService;
@Override
public String getChannel() {
return CHANNEL;
}
@Override
public Mono<ChannelInfo> getChannelInfo(String channelId) {
return configService
.findById(channelId)
.flatMap(this::toChannelInfo);
}
public Mono<ChannelInfo> toChannelInfo(NetworkConfigEntity entity){<FILL_FUNCTION_BODY>}
}
|
ChannelInfo info = new ChannelInfo();
info.setId(entity.getId());
info.setDescription(entity.getDescription());
info.setName(entity.getName());
return Mono
.justOrEmpty(networkManager.getProvider(entity.getType()))
.flatMap(provider -> Flux
.fromIterable(entity.toNetworkPropertiesList())
.flatMap(provider::createConfig)
.as(FluxUtils.safeMap(conf -> {
if (conf instanceof ClientNetworkConfig) {
//客户端则返回远程地址
return ((ClientNetworkConfig) conf).getRemoteAddress();
}
if (conf instanceof ServerNetworkConfig) {
//服务端返回公共访问地址
return ((ServerNetworkConfig) conf).getPublicAddress();
}
return null;
}))
.distinct()
.map(address -> Address.of(address,
//todo 真实状态检查?
entity.getState() == NetworkConfigState.enabled
? Address.HEALTH_OK
: Address.HEALTH_DISABLED))
.collectList())
.doOnNext(info::setAddresses)
.thenReturn(info);
| 153
| 307
| 460
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/network-manager/src/main/java/org/jetlinks/community/network/manager/service/NetworkConfigService.java
|
NetworkConfigService
|
shutdown
|
class NetworkConfigService extends GenericReactiveCrudService<NetworkConfigEntity, String> {
private final NetworkManager networkManager;
public NetworkConfigService(NetworkManager networkManager) {
this.networkManager = networkManager;
}
@Override
public Mono<Integer> deleteById(Publisher<String> idPublisher) {
return this
.findById(Flux.from(idPublisher))
.flatMap(config -> networkManager
.destroy(config.lookupNetworkType(), config.getId())
.thenReturn(config.getId()))
.as(super::deleteById)
;
}
public Mono<Void> start(String id) {
return this
.findById(id)
.switchIfEmpty(Mono.error(() -> new NotFoundException("error.configuration_does_not_exist", id)))
.flatMap(conf -> this
.createUpdate()
.set(NetworkConfigEntity::getState, NetworkConfigState.enabled)
.where(conf::getId)
.execute()
.thenReturn(conf))
.flatMap(conf -> networkManager.reload(conf.lookupNetworkType(), id));
}
public Mono<Void> shutdown(String id) {<FILL_FUNCTION_BODY>}
}
|
return this
.findById(id)
.switchIfEmpty(Mono.error(() -> new NotFoundException("error.configuration_does_not_exist",id)))
.flatMap(conf -> this
.createUpdate()
.set(NetworkConfigEntity::getState, NetworkConfigState.disabled)
.where(conf::getId)
.execute()
.thenReturn(conf))
.flatMap(conf -> networkManager.shutdown(conf.lookupNetworkType(), id));
| 328
| 126
| 454
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/network-manager/src/main/java/org/jetlinks/community/network/manager/service/NetworkEntityEventHandler.java
|
NetworkEntityEventHandler
|
handleCertificateDelete
|
class NetworkEntityEventHandler {
private final NetworkConfigService networkService;
private final DataReferenceManager referenceManager;
private final NetworkManager networkManager;
//禁止删除已有网络组件使用的证书
@EventListener
public void handleCertificateDelete(EntityBeforeDeleteEvent<CertificateEntity> event) {<FILL_FUNCTION_BODY>}
//禁止删除已有网关使用的网络组件
@EventListener
public void handleNetworkDelete(EntityBeforeDeleteEvent<NetworkConfigEntity> event) {
event.async(
Flux.fromIterable(event.getEntity())
.flatMap(e -> referenceManager.assertNotReferenced(DataReferenceManager.TYPE_NETWORK, e.getId()))
);
}
@EventListener
public void handleNetworkCreated(EntityCreatedEvent<NetworkConfigEntity> event) {
event.async(
Flux.fromIterable(event.getEntity())
.flatMapIterable(NetworkConfigEntity::toNetworkPropertiesList)
.flatMap(this::networkConfigValidate)
.then(handleEvent(event.getEntity()))
);
}
@EventListener
public void handleNetworkSaved(EntitySavedEvent<NetworkConfigEntity> event) {
event.async(
Flux.fromIterable(event.getEntity())
.filter(conf -> conf.getConfiguration() != null || conf.getCluster() != null)
.flatMapIterable(NetworkConfigEntity::toNetworkPropertiesList)
.flatMap(this::networkConfigValidate)
.then(handleEvent(event.getEntity()))
);
}
@EventListener
public void handleNetworkModify(EntityModifyEvent<NetworkConfigEntity> event) {
event.async(
Flux.fromIterable(event.getAfter())
.filter(conf -> conf.getConfiguration() != null || conf.getCluster() != null)
.flatMapIterable(NetworkConfigEntity::toNetworkPropertiesList)
.flatMap(this::networkConfigValidate)
.then(handleEvent(event.getAfter()))
);
}
//网络组件配置验证
private Mono<Void> networkConfigValidate(NetworkProperties properties) {
return Mono.justOrEmpty(networkManager.getProvider(properties.getType()))
.flatMap(networkProvider -> networkProvider.createConfig(properties))
.then();
}
private Mono<Void> handleEvent(Collection<NetworkConfigEntity> entities) {
return Flux
.fromIterable(entities)
.filter(conf -> conf.getState() == NetworkConfigState.enabled)
.flatMap(conf -> networkManager.reload(conf.lookupNetworkType(), conf.getId()))
.then();
}
}
|
event.async(
Flux.fromIterable(event.getEntity())
.flatMap(e -> networkService
.createQuery()
// FIXME: 2021/9/13 由于网络组件没有直接记录证书，还有更好的处理办法？
.$like$(NetworkConfigEntity::getConfiguration, e.getId())
.or()
.$like$(NetworkConfigEntity::getCluster, e.getId())
.count()
.doOnNext(i -> {
if (i > 0) {
throw new BusinessException("error.certificate_has_bean_use_by_network");
}
})
)
);
| 697
| 172
| 869
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/network-manager/src/main/java/org/jetlinks/community/network/manager/service/ProtocolDataReferenceProvider.java
|
ProtocolDataReferenceProvider
|
getReference
|
class ProtocolDataReferenceProvider implements DataReferenceProvider {
private final DeviceGatewayService deviceGatewayService;
@Override
public String getId() {
return DataReferenceManager.TYPE_PROTOCOL;
}
@Override
public Flux<DataReferenceInfo> getReference(String protocolId) {<FILL_FUNCTION_BODY>}
@Override
public Flux<DataReferenceInfo> getReferences() {
return deviceGatewayService
.createQuery()
.where()
.notNull(DeviceGatewayEntity::getChannelId)
.fetch()
.map(e -> DataReferenceInfo.of(e.getId(),DataReferenceManager.TYPE_PROTOCOL, e.getChannelId(), e.getName()));
}
}
|
return deviceGatewayService
.createQuery()
.where()
.is(DeviceGatewayEntity::getProtocol, protocolId)
.fetch()
.map(e -> DataReferenceInfo.of(e.getId(),DataReferenceManager.TYPE_PROTOCOL, e.getProtocol(), e.getName()));
| 194
| 81
| 275
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/network-manager/src/main/java/org/jetlinks/community/network/manager/service/SyncDeviceGatewayState.java
|
SyncDeviceGatewayState
|
run
|
class SyncDeviceGatewayState implements CommandLineRunner {
private final DeviceGatewayService deviceGatewayService;
private final DeviceGatewayManager deviceGatewayManager;
private final Duration gatewayStartupDelay = Duration.ofSeconds(5);
public SyncDeviceGatewayState(DeviceGatewayService deviceGatewayService, DeviceGatewayManager deviceGatewayManager) {
this.deviceGatewayService = deviceGatewayService;
this.deviceGatewayManager = deviceGatewayManager;
}
@Override
public void run(String... args) {<FILL_FUNCTION_BODY>}
}
|
log.debug("start device gateway in {} later", gatewayStartupDelay);
Mono.delay(gatewayStartupDelay)
.then(
deviceGatewayService
.createQuery()
.where()
.and(DeviceGatewayEntity::getState, NetworkConfigState.enabled)
.fetch()
.map(DeviceGatewayEntity::getId)
.flatMap(deviceGatewayManager::getGateway)
.flatMap(DeviceGateway::startup)
.onErrorContinue((err, obj) -> {
log.error(err.getMessage(), err);
})
.then()
)
.subscribe();
| 167
| 169
| 336
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/network-manager/src/main/java/org/jetlinks/community/network/manager/session/DeviceSessionMeasurementProvider.java
|
DeviceSessionMeasurementDimension
|
createQuery
|
class DeviceSessionMeasurementDimension implements MeasurementDimension {
@Override
public DimensionDefinition getDefinition() {
return CommonDimensionDefinition.agg;
}
@Override
public DataType getValueType() {
return new ObjectType();
}
@Override
public ConfigMetadata getParams() {
return new DefaultConfigMetadata();
}
@Override
public boolean isRealTime() {
return false;
}
private AggregationQueryParam createQuery(MeasurementParameter parameter) {<FILL_FUNCTION_BODY>}
@Override
public Publisher<? extends Object> getValue(MeasurementParameter parameter) {
AggregationQueryParam queryParam = createQuery(parameter);
String format = parameter.getString("format", "yyyy-MM-dd");
DateTimeFormatter formatter = DateTimeFormat.forPattern(format);
return timeSeriesManager
.getService(metric)
.aggregation(queryParam)
.map(data -> SimpleMeasurementValue.of(
data.getLong("count", 0),
data.getString("time", ""),
data.getString("time").map(formatter::parseMillis).orElse(0L)
))
.sort()
.take(parameter.getInt("limit", 30));
}
}
|
return AggregationQueryParam
.of()
.agg("deviceId", "count", DISTINCT_COUNT)
.groupBy(parameter.getInterval("interval", parameter.getInterval("time", null)),
parameter.getString("format", "yyyy-MM-dd"))
.from(parameter.getDate("from", TimeUtils.parseDate("now-1d")))
.to(parameter.getDate("to").orElseGet(Date::new))
.filter(q -> q
.is("name", "duration")
//产品ID
.is("productId", parameter.getString("productId", null))
//设备ID
.is("deviceId", parameter.getString("deviceId", null))
);
| 336
| 184
| 520
|
<methods>public void <init>(org.jetlinks.community.dashboard.DashboardDefinition, org.jetlinks.community.dashboard.ObjectDefinition) ,public Mono<org.jetlinks.community.dashboard.Measurement> getMeasurement(java.lang.String) ,public Flux<org.jetlinks.community.dashboard.Measurement> getMeasurements() <variables>private org.jetlinks.community.dashboard.DashboardDefinition dashboardDefinition,private Map<java.lang.String,org.jetlinks.community.dashboard.Measurement> measurements,private org.jetlinks.community.dashboard.ObjectDefinition objectDefinition
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/network-manager/src/main/java/org/jetlinks/community/network/manager/web/CertificateController.java
|
CertificateController
|
upload
|
class CertificateController implements ReactiveServiceCrudController<CertificateEntity, String> {
@Autowired
private CertificateService certificateService;
@Override
public CertificateService getService() {
return certificateService;
}
@Autowired(required = false)
DataBufferFactory factory = new DefaultDataBufferFactory();
@GetMapping("/{id}/detail")
@QueryAction
@Operation(summary = "查看证书信息")
public Mono<String> getCertificateInfo(@PathVariable String id) {
return certificateService
.getCertificate(id)
.map(Certificate::toString);
}
@SaveAction
@PostMapping("/upload")
@SneakyThrows
@Operation(summary = "上传证书并返回证书BASE64")
public Mono<String> upload(@RequestPart("file")
@Parameter(name = "file", description = "文件") Part part) {<FILL_FUNCTION_BODY>}
}
|
if (part instanceof FilePart) {
return (part)
.content()
.collectList()
.flatMap(all -> Mono.fromCallable(() ->
Base64.encodeBase64String(StreamUtils.copyToByteArray(factory.join(all).asInputStream()))))
;
} else {
return Mono.error(() -> new IllegalArgumentException("[file] part is not a file"));
}
| 249
| 114
| 363
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/network-manager/src/main/java/org/jetlinks/community/network/manager/web/DeviceGatewayController.java
|
DeviceGatewayController
|
getProviders
|
class DeviceGatewayController implements ReactiveServiceCrudController<DeviceGatewayEntity, String> {
private final DeviceGatewayService deviceGatewayService;
private final ProtocolSupports protocolSupports;
private final DeviceGatewayManager gatewayManager;
private final DeviceSessionManager sessionManager;
@Override
@Generated
public DeviceGatewayService getService() {
return deviceGatewayService;
}
@PostMapping("/{id}/_startup")
@SaveAction
@Operation(summary = "启动网关")
public Mono<Void> startup(@PathVariable
@Parameter(description = "网关ID") String id) {
return gatewayManager
.start(id)
.then(deviceGatewayService.updateState(id, DeviceGatewayState.enabled))
.then();
}
@PostMapping("/{id}/_pause")
@SaveAction
@Operation(summary = "暂停")
public Mono<Void> pause(@PathVariable
@Parameter(description = "网关ID") String id) {
return gatewayManager
.getGateway(id)
.flatMap(DeviceGateway::pause)
.then(deviceGatewayService.updateState(id, DeviceGatewayState.paused))
.then();
}
@PostMapping("/{id}/_shutdown")
@SaveAction
@Operation(summary = "停止")
public Mono<Void> shutdown(@PathVariable
@Parameter(description = "网关ID") String id) {
return gatewayManager
.shutdown(id)
.then(deviceGatewayService.updateState(id, DeviceGatewayState.disabled).then());
}
@GetMapping("/{id}/detail")
@QueryAction
@Operation(summary = "获取单个接入网关详情")
public Mono<DeviceGatewayDetail> getDetail(@PathVariable
@Parameter(description = "网关ID") String id) {
return deviceGatewayService
.findById(id)
.flatMap(this::convertDetail);
}
@PostMapping("/detail/_query")
@QueryAction
@Operation(summary = "分页查询设备接入网关详情")
public Mono<PagerResult<DeviceGatewayDetail>> queryGateway(@RequestBody Mono<QueryParamEntity> paramBody) {
return paramBody
.flatMap(param -> deviceGatewayService
.queryPager(param)
.flatMap(result -> Flux
.fromIterable(result.getData())
.index()
//转为详情
.flatMap(tp2 -> this.convertDetail(tp2.getT2()).map(detail -> Tuples.of(tp2.getT1(), detail)))
//重新排序,因为转为详情是异步的可能导致顺序乱掉
.sort(Comparator.comparingLong(Tuple2::getT1))
.map(Tuple2::getT2)
.collectList()
.map(detail -> PagerResult.of(result.getTotal(), detail, param)))
);
}
private Mono<DeviceGatewayDetail> convertDetail(DeviceGatewayEntity entity) {
DeviceGatewayDetail detail = DeviceGatewayDetail.of(entity);
return Flux
.merge(
//通道信息
gatewayManager
.getChannel(entity.getChannel(), entity.getChannelId())
.map(detail::with),
//协议信息
entity.getProtocol() == null ? Mono.empty() : protocolSupports
.getProtocol(entity.getProtocol())
.onErrorResume(err->Mono.empty())
.flatMap(detail::with)
)
.last(detail);
}
@GetMapping(value = "/providers")
@Operation(summary = "获取支持的接入方式")
public Flux<DeviceGatewayProviderInfo> getProviders() {<FILL_FUNCTION_BODY>}
@GetMapping("/sessions")
@Operation(summary = "获取设备会话信息")
public Flux<DeviceSessionInfo> sessions(@RequestParam(required = false) Long pageIndex,
@RequestParam(required = false) Long pageSize) {
return sessionManager
.getSessionInfo()
.as(ReactorUtils.limit(pageIndex, pageSize));
}
@GetMapping("/sessions/{serverId}")
@Operation(summary = "获取设备会话信息")
public Flux<DeviceSessionInfo> sessions(@PathVariable String serverId,
@RequestParam(required = false) Long pageIndex,
@RequestParam(required = false) Long pageSize) {
return sessionManager
.getSessionInfo(serverId)
.as(ReactorUtils.limit(pageIndex, pageSize));
}
@DeleteMapping("/session/{deviceId}")
@Operation(summary = "移除设备会话")
@SaveAction
public Mono<Long> removeSession(@PathVariable String deviceId) {
return sessionManager.remove(deviceId,false);
}
}
|
return LocaleUtils
.currentReactive()
.flatMapMany(locale -> Flux
.fromIterable(gatewayManager.getProviders())
.map(provider -> DeviceGatewayProviderInfo.of(provider, locale)));
| 1,293
| 64
| 1,357
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/network-manager/src/main/java/org/jetlinks/community/network/manager/web/NetworkConfigController.java
|
NetworkConfigController
|
getAliveNetworkInfo
|
class NetworkConfigController implements ReactiveServiceCrudController<NetworkConfigEntity, String> {
private final NetworkConfigService configService;
private final NetworkManager networkManager;
private final DataReferenceManager referenceManager;
private final NetworkChannelProvider channelProvider;
@Generated
@Override
public NetworkConfigService getService() {
return configService;
}
@GetMapping("/{networkType}/_detail")
@QueryAction
@Operation(summary = "获取指定类型下全部的网络组件信息")
public Flux<ChannelInfo> getNetworkInfo(@PathVariable
@Parameter(description = "网络组件类型") String networkType) {
NetworkProvider<?> provider = networkManager
.getProvider(networkType)
.orElseThrow(() -> new I18nSupportException("error.unsupported_network_type", networkType));
return configService
.createQuery()
.where(NetworkConfigEntity::getType, networkType)
.orderBy(SortOrder.desc(NetworkConfigEntity::getId))
.fetch()
.flatMap(entity -> toConfigInfo(entity, provider));
}
/**
* 获取指定类型下可用的网络组件信息
* <pre>{@code
* POST /network/config/{networkType}/_alive?include=
* }</pre>
*/
@GetMapping("/{networkType}/_alive")
@QueryAction
@QueryOperation(summary = "获取指定类型下可用的网络组件信息")
public Flux<ChannelInfo> getAliveNetworkInfo(@PathVariable
@Parameter(description = "网络组件类型") String networkType,
@Parameter(description = "包含指定的网络组件ID")
@RequestParam(required = false) String include,
@Parameter(hidden = true) QueryParamEntity query) {<FILL_FUNCTION_BODY>}
private Mono<ChannelInfo> toConfigInfo(NetworkConfigEntity entity, NetworkProvider<?> provider) {
return channelProvider.toChannelInfo(entity);
}
@GetMapping("/supports")
@Operation(summary = "获取支持的网络组件类型")
public Flux<NetworkTypeInfo> getSupports() {
return Flux.fromIterable(networkManager.getProviders())
.map(NetworkProvider::getType)
.map(NetworkTypeInfo::of);
}
@PostMapping("/{id}/_start")
@SaveAction
@Operation(summary = "启动网络组件")
public Mono<Void> start(@PathVariable
@Parameter(description = "网络组件ID") String id) {
return configService.start(id);
}
@PostMapping("/{id}/_shutdown")
@SaveAction
@Operation(summary = "停止网络组件")
public Mono<Void> shutdown(@PathVariable
@Parameter(description = "网络组件ID") String id) {
return configService.shutdown(id);
}
}
|
NetworkProvider<?> provider = networkManager
.getProvider(networkType)
.orElseThrow(() -> new I18nSupportException("error.unsupported_network_type", networkType));
return configService
.createQuery()
.setParam(query)
.where(NetworkConfigEntity::getType, networkType)
.and(NetworkConfigEntity::getState, NetworkConfigState.enabled)
.orderBy(SortOrder.desc(NetworkConfigEntity::getId))
.fetch()
.filterWhen(config -> {
if (provider.isReusable() || Objects.equals(config.getId(), include)) {
return Mono.just(true);
}
//判断是否已经被使用
return referenceManager
.isReferenced(DataReferenceManager.TYPE_NETWORK, config.getId())
.as(BooleanUtils::not);
})
.flatMap(entity -> toConfigInfo(entity, provider));
| 752
| 240
| 992
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/network-manager/src/main/java/org/jetlinks/community/network/manager/web/NetworkResourceController.java
|
NetworkResourceController
|
getResources
|
class NetworkResourceController {
private final NetworkResourceManager resourceManager;
@GetMapping("/alive")
@Operation(summary = "获取可用的资源信息")
public Flux<NetworkResource> getResources() {<FILL_FUNCTION_BODY>}
@GetMapping("/alive/_all")
@Operation(summary = "获取全部集群节点的资源信息")
public Flux<NetworkResource> getAllResources() {
return resourceManager.getAliveResources();
}
@GetMapping("/alive/_current")
@Operation(summary = "获取当前集群节点的资源信息")
public Flux<NetworkResource> getCurrentAliveResources() {
return resourceManager.getAliveResources();
}
}
|
return resourceManager
.getAliveResources()
//只获取绑定全部网卡的信息
.filter(NetworkResource::hostIsBindAll)
.groupBy(NetworkResource::getHost)
.flatMap(group -> {
String host = group.key();
return group
//只获取端口交集
.reduce(NetworkResource.of(host), (a, b) -> a.retainPorts(b.getPorts()));
});
| 186
| 122
| 308
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/network-manager/src/main/java/org/jetlinks/community/network/manager/web/request/MqttMessageRequest.java
|
MqttMessageRequest
|
of
|
class MqttMessageRequest {
private String topic;
private int qosLevel;
private Object data;
private int messageId;
private boolean will;
private boolean dup;
private boolean retain;
public static MqttMessage of(MqttMessageRequest request, PayloadType type) {<FILL_FUNCTION_BODY>}
public static MqttMessageRequest of(MqttMessage message, PayloadType type) {
MqttMessageRequest requestMessage = new MqttMessageRequest();
requestMessage.setTopic(message.getTopic());
requestMessage.setQosLevel(message.getQosLevel());
requestMessage.setData(type.read(message.getPayload()));
requestMessage.setWill(message.isWill());
requestMessage.setDup(message.isDup());
requestMessage.setRetain(message.isRetain());
requestMessage.setMessageId(message.getMessageId());
return requestMessage;
}
}
|
SimpleMqttMessage message = FastBeanCopier.copy(request, new SimpleMqttMessage());
message.setPayload(type.write(request.getData()));
return message;
| 257
| 51
| 308
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/network-manager/src/main/java/org/jetlinks/community/network/manager/web/response/DeviceGatewayDetail.java
|
DeviceGatewayDetail
|
with
|
class DeviceGatewayDetail {
@Schema(description = "ID")
private String id;
@Schema(description = "名称")
private String name;
@Schema(description = "说明")
private String description;
/**
* @see DeviceGatewayProvider#getId()
*/
@Schema(description = "接入类型,如: modbus,mqtt-server")
private String provider;
/**
* @see ProtocolSupport#getId()
*/
@Schema(description = "消息协议")
private String protocol;
/**
* @see Transport#getId()
*/
@Schema(description = "传输协议,如:TCP,UDP")
private String transport;
/**
* @see ChannelProvider#getChannel()
*/
@Schema(description = "通道")
private String channel;
@Schema(description = "通道ID")
private String channelId;
@Schema(description = "状态")
private DeviceGatewayState state;
@Schema(description = "通道信息")
private ChannelInfo channelInfo;
@Schema(description = "消息协议详情")
private ProtocolDetail protocolDetail;
@Schema(description = "传输协议详情")
private TransportDetail transportDetail;
public static DeviceGatewayDetail of(DeviceGatewayEntity entity) {
return FastBeanCopier.copy(entity, new DeviceGatewayDetail());
}
public Mono<DeviceGatewayDetail> with(ProtocolSupport protocol) {<FILL_FUNCTION_BODY>}
public DeviceGatewayDetail with(ChannelInfo channelInfo) {
this.channelInfo = channelInfo;
return this;
}
}
|
this.protocolDetail = new ProtocolDetail(protocol.getId(), protocol.getName(), protocol.getDescription(), null);
return TransportDetail
.of(protocol, Transport.of(transport))
.doOnNext(this::setTransportDetail)
.thenReturn(this)
;
| 440
| 73
| 513
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/network-manager/src/main/java/org/jetlinks/community/network/manager/web/response/DeviceGatewayProviderInfo.java
|
DeviceGatewayProviderInfo
|
of
|
class DeviceGatewayProviderInfo {
@Schema(description = "接入方式ID")
private String id;
@Schema(description = "接入方式名称")
private String name;
@Schema(description = "接入方式说明")
private String description;
@Schema(description = "接入通道")
private String channel;
public static DeviceGatewayProviderInfo of(DeviceGatewayProvider provider, Locale locale) {<FILL_FUNCTION_BODY>}
}
|
DeviceGatewayProviderInfo info = new DeviceGatewayProviderInfo();
info.setId(provider.getId());
info.setChannel(provider.getChannel());
info.setName(LocaleUtils
.resolveMessage("device.gateway.provider." + provider.getId() + ".name",
locale,
provider.getName()));
info.setDescription(LocaleUtils
.resolveMessage("device.gateway.provider." + provider.getId() + ".description",
locale,
provider.getDescription()));
return info;
| 127
| 135
| 262
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/network-manager/src/main/java/org/jetlinks/community/network/manager/web/response/NetworkTypeInfo.java
|
NetworkTypeInfo
|
of
|
class NetworkTypeInfo {
private String id;
private String name;
public static NetworkTypeInfo of(NetworkType type) {<FILL_FUNCTION_BODY>}
}
|
NetworkTypeInfo info = new NetworkTypeInfo();
info.setId(type.getId());
info.setName(type.getName());
return info;
| 51
| 46
| 97
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/notify-manager/src/main/java/org/jetlinks/community/notify/manager/entity/Notification.java
|
Notification
|
from
|
class Notification implements Serializable {
private static final long serialVersionUID = -1L;
private String id;
private String subscribeId;
private String subscriberType;
private String subscriber;
private String topicProvider;
private String topicName;
private String message;
private Object detail;
private String code;
private String dataId;
private long notifyTime;
private List<String> notifyChannels;
public static Notification from(NotifySubscriberEntity entity) {<FILL_FUNCTION_BODY>}
public Notification copyWithMessage(Notify message) {
Notification target = FastBeanCopier.copy(this, new Notification());
target.setId(IDGenerator.SNOW_FLAKE_STRING.generate());
target.setMessage(message.getMessage());
target.setDataId(message.getDataId());
target.setNotifyTime(message.getNotifyTime());
target.setDetail(message.getDetail());
target.setCode(message.getCode());
return target;
}
public String createTopic() {
// /notifications/{订阅者类型:user}/{订阅者ID:userId}/{主题类型}/{订阅ID}
return "/notifications/" + getSubscriberType() + "/" + getSubscriber() + "/" + getTopicProvider() + "/" + getSubscribeId();
}
}
|
Notification notification = new Notification();
notification.subscribeId = entity.getId();
notification.subscriberType = entity.getSubscriberType();
notification.subscriber = entity.getSubscriber();
notification.topicName = entity.getTopicName();
notification.setTopicProvider(entity.getTopicProvider());
notification.setNotifyChannels(entity.getNotifyChannels());
return notification;
| 368
| 111
| 479
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/notify-manager/src/main/java/org/jetlinks/community/notify/manager/entity/NotificationEntity.java
|
NotificationEntity
|
from
|
class NotificationEntity extends GenericEntity<String> {
private static final long serialVersionUID = -1L;
@Column(length = 64, nullable = false, updatable = false)
@Hidden
private String subscribeId;
@Column(length = 32, nullable = false, updatable = false)
@Hidden
private String subscriberType;
@Column(length = 64, nullable = false, updatable = false)
@Hidden
private String subscriber;
@Column(length = 32, nullable = false, updatable = false)
@Schema(description = "主题标识,如:device_alarm")
private String topicProvider;
@Column(length = 64, nullable = false, updatable = false)
@Schema(description = "主题名称")
private String topicName;
@Column
@ColumnType(jdbcType = JDBCType.CLOB, javaType = String.class)
@Schema(description = "通知消息")
private String message;
@Column(length = 64)
@Schema(description = "数据ID")
private String dataId;
@Column(nullable = false)
@Schema(description = "通知时间")
private Long notifyTime;
@Column(length = 128)
@Schema(description = "通知编码")
private String code;
@Column
@Schema(description = "详情")
@ColumnType(jdbcType = JDBCType.CLOB, javaType = String.class)
private String detailJson;
@Column(length = 32)
@EnumCodec
@DefaultValue("unread")
@ColumnType(javaType = String.class)
@Schema(description = "通知状态")
private NotificationState state;
@Column(length = 1024)
@Schema(description = "说明")
private String description;
@SneakyThrows
public static NotificationEntity from(Notification notification) {<FILL_FUNCTION_BODY>}
}
|
NotificationEntity entity = FastBeanCopier.copy(notification, new NotificationEntity());
Object detail = notification.getDetail();
entity.setCode(notification.getCode());
if (detail != null) {
entity.setDetailJson(ObjectMappers.JSON_MAPPER.writeValueAsString(detail));
}
return entity;
| 521
| 93
| 614
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/notify-manager/src/main/java/org/jetlinks/community/notify/manager/entity/NotifyConfigEntity.java
|
NotifyConfigEntity
|
toProperties
|
class NotifyConfigEntity extends GenericEntity<String> implements RecordCreationEntity {
private static final long serialVersionUID = -6849794470754667710L;
@Override
@GeneratedValue(generator = Generators.SNOW_FLAKE)
@Pattern(regexp = "^[0-9a-zA-Z_\\-]+$", groups = CreateGroup.class)
@Schema(description = "设备ID(只能由数字,字母,下划线和中划线组成)")
public String getId() {
return super.getId();
}
/**
* 配置名称
*/
@Column
@Schema(description = "配置名称")
@NotBlank(groups = CreateGroup.class)
private String name;
/**
* 通知类型
*/
@Column
@Schema(description = "通知类型")
@NotBlank(groups = CreateGroup.class)
private String type;
/**
* 服务提供商
*/
@Column
@Schema(description = "服务提供商")
@NotBlank(groups = CreateGroup.class)
private String provider;
/**
* 描述
*/
@Column
@Schema(description = "描述")
private String description;
@Column(length = 512)
@JsonCodec
@ColumnType(javaType = String.class)
@Schema(description = "重试策略,如: [\"1s\",\"20s\",\"5m\",\"15m\"]")
@Hidden//暂未实现
private List<String> retryPolicy;
@Column
@DefaultValue("0")
@Schema(description = "最大重试次数")
@Hidden//暂未实现
private Integer maxRetryTimes;
@Column(updatable = false)
@Schema(
description = "创建者ID(只读)"
, accessMode = Schema.AccessMode.READ_ONLY
)
private String creatorId;
@Column(updatable = false)
@DefaultValue(generator = Generators.CURRENT_TIME)
@Schema(
description = "创建时间(只读)"
, accessMode = Schema.AccessMode.READ_ONLY
)
private Long createTime;
/**
* 配置详情
*/
@Column
@JsonCodec
@ColumnType(jdbcType = JDBCType.CLOB)
@Schema(description = "配置信息")
private Map<String, Object> configuration;
public NotifierProperties toProperties() {<FILL_FUNCTION_BODY>}
}
|
NotifierProperties properties = new NotifierProperties();
properties.setProvider(provider);
properties.setId(getId());
properties.setType(type);
properties.setConfiguration(configuration == null ? new HashMap<>() : configuration);
properties.setName(name);
return properties;
| 683
| 75
| 758
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/notify-manager/src/main/java/org/jetlinks/community/notify/manager/entity/NotifyHistoryEntity.java
|
NotifyHistoryEntity
|
of
|
class NotifyHistoryEntity extends GenericEntity<String> {
private static final long serialVersionUID = -6849794470754667710L;
@Column(length = 32, nullable = false, updatable = false)
@Schema(description = "通知ID")
private String notifierId;
@Column(nullable = false)
@DefaultValue("success")
@EnumCodec
@ColumnType(javaType = String.class)
@Schema(description = "状态")
private NotifyState state;
@Column(length = 1024)
@Schema(description = "错误类型")
private String errorType;
@Column
@ColumnType(jdbcType = JDBCType.CLOB, javaType = String.class)
@Schema(description = "异常栈")
private String errorStack;
@Column(length = 32, nullable = false)
@DefaultValue("-")
@Schema(description = "模版ID")
private String templateId;
@Column
@ColumnType(jdbcType = JDBCType.CLOB, javaType = String.class)
@Schema(description = "模版内容")
private String template;
@Column
@ColumnType(jdbcType = JDBCType.CLOB, javaType = String.class)
@JsonCodec
@Schema(description = "上下文")
private Map<String, Object> context;
@Column(length = 32, nullable = false)
@Schema(description = "服务商")
private String provider;
@Column(length = 32, nullable = false)
@Schema(description = "通知类型")
private String notifyType;
@Column
@DefaultValue(generator = Generators.CURRENT_TIME)
@Schema(description = "通知时间")
private Date notifyTime;
@Column
@DefaultValue("0")
@Schema(description = "重试次数")
private Integer retryTimes;
public static NotifyHistoryEntity of(SerializableNotifierEvent event) {<FILL_FUNCTION_BODY>}
public NotifyHistory toHistory(){
return FastBeanCopier.copy(this,new NotifyHistory());
}
}
|
NotifyHistoryEntity entity = FastBeanCopier.copy(event, new NotifyHistoryEntity());
if (null != event.getTemplate()) {
entity.setTemplate(JSON.toJSONString(event.getTemplate()));
}
if (event.isSuccess()) {
entity.setState(NotifyState.success);
} else {
entity.setErrorStack(event.getCause());
entity.setState(NotifyState.error);
}
return entity;
| 577
| 124
| 701
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/notify-manager/src/main/java/org/jetlinks/community/notify/manager/entity/NotifyTemplateEntity.java
|
NotifyTemplateEntity
|
toTemplateProperties
|
class NotifyTemplateEntity extends GenericEntity<String> implements RecordCreationEntity {
private static final long serialVersionUID = -6849794470754667710L;
@Override
@GeneratedValue(generator = Generators.SNOW_FLAKE)
@Pattern(regexp = "^[0-9a-zA-Z_\\-]+$", groups = CreateGroup.class)
@Schema(description = "模板ID(只能由数字,字母,下划线和中划线组成)")
public String getId() {
return super.getId();
}
@Column
@Schema(description = "通知类型ID")
@NotBlank(groups = CreateGroup.class)
private String type;
@Column
@Schema(description = "通知服务商ID")
@NotBlank(groups = CreateGroup.class)
private String provider;
@Column
@Schema(description = "模版名称")
private String name;
@Column
@ColumnType(jdbcType = JDBCType.LONGVARCHAR,javaType = String.class)
@JsonCodec
@Schema(description = "模版内容(根据服务商不同而不同)")
private Map<String,Object> template;
@Column(updatable = false)
@Schema(
description = "创建者ID(只读)"
, accessMode = Schema.AccessMode.READ_ONLY
)
private String creatorId;
@Column(updatable = false)
@DefaultValue(generator = Generators.CURRENT_TIME)
@Schema(
description = "创建时间(只读)"
, accessMode = Schema.AccessMode.READ_ONLY
)
private Long createTime;
@Column
@ColumnType(jdbcType = JDBCType.LONGVARCHAR, javaType = String.class)
@JsonCodec
@Schema(description = "变量定义")
private List<VariableDefinition> variableDefinitions;
//绑定通知配置ID,表示模版必须使用指定的配置进行发送
@Column(length = 64)
@Schema(description = "通知配置ID")
private String configId;
@Column
@Schema(description = "说明")
private String description;
public TemplateProperties toTemplateProperties() {<FILL_FUNCTION_BODY>}
}
|
TemplateProperties properties = new TemplateProperties();
properties.setId(getId());
properties.setProvider(provider);
properties.setType(type);
properties.setConfigId(configId);
properties.setName(name);
properties.setTemplate(template);
properties.setVariableDefinitions(variableDefinitions);
properties.setDescription(description);
return properties;
| 607
| 98
| 705
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/notify-manager/src/main/java/org/jetlinks/community/notify/manager/message/NotificationsPublishProvider.java
|
NotificationsPublishProvider
|
subscribe
|
class NotificationsPublishProvider implements SubscriptionProvider {
private final EventBus eventBus;
@Override
public String id() {
return "notifications-publisher";
}
@Override
public String name() {
return "通知推送器";
}
@Override
public String[] getTopicPattern() {
return new String[]{"/notifications"};
}
@Override
public Flux<Message> subscribe(SubscribeRequest request) {<FILL_FUNCTION_BODY>}
}
|
return eventBus
.subscribe(Subscription.of(
"notifications-publisher",
"/notifications/user/" + request.getAuthentication().getUser().getId() + "/*/*",
Subscription.Feature.local, Subscription.Feature.broker
))
.map(msg -> Message.success(request.getId(), msg.getTopic(), msg.bodyToJson(true)));
| 136
| 102
| 238
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/notify-manager/src/main/java/org/jetlinks/community/notify/manager/service/DefaultTemplateManager.java
|
DefaultTemplateManager
|
postProcessAfterInitialization
|
class DefaultTemplateManager extends AbstractTemplateManager implements BeanPostProcessor {
private final NotifyTemplateService templateService;
public DefaultTemplateManager(NotifyTemplateService templateService) {
this.templateService = templateService;
}
@Override
protected Mono<TemplateProperties> getProperties(NotifyType type, String id) {
return templateService
.findById(Mono.just(id))
.map(NotifyTemplateEntity::toTemplateProperties);
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {<FILL_FUNCTION_BODY>}
}
|
if (bean instanceof TemplateProvider) {
register(((TemplateProvider) bean));
}
return bean;
| 158
| 31
| 189
|
<methods>public non-sealed void <init>() ,public Mono<? extends org.jetlinks.community.notify.template.Template> createTemplate(org.jetlinks.community.notify.NotifyType, org.jetlinks.community.notify.template.TemplateProperties) ,public Mono<? extends org.jetlinks.community.notify.template.Template> getTemplate(org.jetlinks.community.notify.NotifyType, java.lang.String) ,public Mono<java.lang.Void> reload(java.lang.String) <variables>protected final Map<java.lang.String,Map<java.lang.String,org.jetlinks.community.notify.template.TemplateProvider>> providers,protected final Map<java.lang.String,org.jetlinks.community.notify.template.Template> templates
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/notify-manager/src/main/java/org/jetlinks/community/notify/manager/service/ElasticSearchNotifyHistoryRepository.java
|
ElasticSearchNotifyHistoryRepository
|
queryPager
|
class ElasticSearchNotifyHistoryRepository implements NotifyHistoryRepository {
public static final String INDEX_NAME = "notify_history";
private final ElasticSearchService elasticSearchService;
private final ElasticSearchIndexManager indexManager;
@PostConstruct
public void init() {
indexManager
.putIndex(
new DefaultElasticSearchIndexMetadata(INDEX_NAME)
.addProperty("id", StringType.GLOBAL)
.addProperty("notifyTime", DateTimeType.GLOBAL)
//其他字段默认都是string
)
.block(Duration.ofSeconds(10));
}
@Subscribe("/notify/**")
@Transactional(propagation = Propagation.NEVER)
public Mono<Void> handleNotify(SerializableNotifierEvent event) {
return elasticSearchService
.commit(INDEX_NAME, NotifyHistory.of(event).toJson());
}
@Override
public Mono<PagerResult<NotifyHistory>> queryPager(QueryParamEntity param) {<FILL_FUNCTION_BODY>}
}
|
return elasticSearchService
.queryPager(INDEX_NAME, param, map -> {
NotifyHistory history = FastBeanCopier.copy(map, new NotifyHistory(),"context");
history.setContext(JSON.parseObject((String) map.getOrDefault("context", "{}")));
return history;
});
| 275
| 85
| 360
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/notify-manager/src/main/java/org/jetlinks/community/notify/manager/service/NotificationService.java
|
NotificationService
|
findAndMarkRead
|
class NotificationService extends GenericReactiveCrudService<NotificationEntity, String> {
@Getter
@Setter
private BufferProperties buffer = new BufferProperties();
private PersistenceBuffer<NotificationEntity> writer;
public NotificationService() {
buffer.setFilePath("./data/notification-buffer");
buffer.setSize(1000);
buffer.setTimeout(Duration.ofSeconds(1));
}
@PostConstruct
public void init() {
writer = new PersistenceBuffer<>(
BufferSettings.create(buffer),
NotificationEntity::new,
flux -> this.save(flux).then(Reactors.ALWAYS_FALSE))
.retryWhenError(err -> ErrorUtils.hasException(
err,
CannotCreateTransactionException.class,
NonTransientDataAccessException.class,
TimeoutException.class,
IOException.class))
.name("notification");
writer.start();
}
@PreDestroy
public void dispose() {
writer.dispose();
}
@Subscribe("/notifications/**")
public Mono<Void> subscribeNotifications(Notification notification) {
writer.write(NotificationEntity.from(notification));
return Mono.empty();
}
public Flux<NotificationEntity> findAndMarkRead(QueryParamEntity query) {<FILL_FUNCTION_BODY>}
}
|
return this
.query(query)
.collectList()
.filter(CollectionUtils::isNotEmpty)
.flatMapMany(list -> this
.createUpdate()
.set(NotificationEntity::getState, NotificationState.read)
.where()
.in(NotificationEntity::getId, list
.stream()
.map(NotificationEntity::getId)
.collect(Collectors.toList()))
.and(NotificationEntity::getState, NotificationState.unread)
.execute()
.thenMany(Flux.fromIterable(list))
.doOnNext(e -> e.setState(NotificationState.read)));
| 367
| 166
| 533
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/notify-manager/src/main/java/org/jetlinks/community/notify/manager/service/NotifierCacheManager.java
|
NotifierCacheManager
|
reloadConfig
|
class NotifierCacheManager {
private final TemplateManager templateManager;
private final NotifierManager notifierManager;
public NotifierCacheManager(TemplateManager templateManager, NotifierManager notifierManager) {
this.templateManager = templateManager;
this.notifierManager = notifierManager;
}
@EventListener
public void handleTemplateSave(EntitySavedEvent<NotifyTemplateEntity> event) {
event.async(
reloadTemplate(event.getEntity())
);
}
@EventListener
public void handleTemplateModify(EntityModifyEvent<NotifyTemplateEntity> event) {
event.async(
reloadTemplate(event.getBefore())
);
}
@EventListener
public void handleTemplateDelete(EntityDeletedEvent<NotifyTemplateEntity> event) {
event.async(
reloadTemplate(event.getEntity())
);
}
@EventListener
public void handleConfigSave(EntitySavedEvent<NotifyConfigEntity> event) {
event.async(
reloadConfig(event.getEntity())
);
}
@EventListener
public void handleConfigModify(EntityModifyEvent<NotifyConfigEntity> event) {
event.async(
reloadConfig(event.getBefore())
);
}
@EventListener
public void handleConfigDelete(EntityDeletedEvent<NotifyConfigEntity> event) {
event.async(
reloadConfig(event.getEntity())
);
}
protected Mono<Void> reloadConfig(List<NotifyConfigEntity> entities) {<FILL_FUNCTION_BODY>}
protected Mono<Void> reloadTemplate(List<NotifyTemplateEntity> entities) {
return Flux.fromIterable(entities)
.map(NotifyTemplateEntity::getId)
.doOnNext(id -> log.info("clear template [{}] cache", id))
.flatMap(templateManager::reload)
.then();
}
}
|
return Flux.fromIterable(entities)
.map(NotifyConfigEntity::getId)
.doOnNext(id -> log.info("clear notifier config [{}] cache", id))
.flatMap(notifierManager::reload)
.then();
| 502
| 71
| 573
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/notify-manager/src/main/java/org/jetlinks/community/notify/manager/service/NotifyHistory.java
|
NotifyHistory
|
of
|
class NotifyHistory {
@Schema(description = "ID")
private String id;
@Schema(description = "通知ID")
private String notifierId;
@Schema(description = "状态")
private NotifyState state;
@Schema(description = "错误类型")
private String errorType;
@Schema(description = "异常栈")
private String errorStack;
@Schema(description = "模版ID")
private String templateId;
@Schema(description = "模版内容")
private String template;
@Schema(description = "上下文")
private Map<String, Object> context;
@Schema(description = "服务商")
private String provider;
@Schema(description = "通知类型")
private String notifyType;
@Schema(description = "通知时间")
private Long notifyTime;
public static NotifyHistory of(SerializableNotifierEvent event) {<FILL_FUNCTION_BODY>}
public JSONObject toJson() {
JSONObject obj = FastBeanCopier.copy(this,new JSONObject());
obj.put("state",state.getValue());
obj.put("context", JSON.toJSONString(context));
return obj;
}
}
|
NotifyHistory history = FastBeanCopier.copy(event, new NotifyHistory());
history.setId(IDGenerator.SNOW_FLAKE_STRING.generate());
history.setNotifyTime(System.currentTimeMillis());
if (null != event.getTemplate()) {
history.setTemplate(JSON.toJSONString(event.getTemplate()));
}
if (event.isSuccess()) {
history.setState(NotifyState.success);
} else {
history.setErrorStack(event.getCause());
history.setState(NotifyState.error);
}
return history;
| 317
| 158
| 475
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/notify-manager/src/main/java/org/jetlinks/community/notify/manager/service/NotifyValidationHandler.java
|
NotifyValidationHandler
|
getNotifierProvider
|
class NotifyValidationHandler {
private final List<NotifierProvider> notifierProviders;
private final List<TemplateProvider> templateProviders;
@EventListener
public void handleConfigEvent(EntityCreatedEvent<NotifyConfigEntity> event){
event.async(
Flux.fromIterable(event.getEntity())
.flatMap(this::validateConfig)
);
}
@EventListener
public void handleConfigEvent(EntitySavedEvent<NotifyConfigEntity> event){
event.async(
Flux.fromIterable(event.getEntity())
.flatMap(this::validateConfig)
);
}
@EventListener
public void handleConfigEvent(EntityModifyEvent<NotifyConfigEntity> event){
event.async(
Flux.fromIterable(event.getAfter())
.flatMap(this::validateConfig)
);
}
@EventListener
public void handleTemplateEvent(EntityCreatedEvent<NotifyTemplateEntity> event){
event.async(
Flux.fromIterable(event.getEntity())
.flatMap(this::validateTemplate)
);
}
@EventListener
public void handleTemplateEvent(EntitySavedEvent<NotifyTemplateEntity> event){
event.async(
Flux.fromIterable(event.getEntity())
.flatMap(this::validateTemplate)
);
}
@EventListener
public void handleTemplateEvent(EntityModifyEvent<NotifyTemplateEntity> event){
event.async(
Flux.fromIterable(event.getAfter())
.flatMap(this::validateTemplate)
);
}
public Mono<Void> validateTemplate(NotifyTemplateEntity entity) {
return this
.getTemplateProvider(entity.getType(), entity.getProvider())
.createTemplate(entity.toTemplateProperties())
.then();
}
public Mono<Void> validateConfig(NotifyConfigEntity entity) {
return this
.getNotifierProvider(entity.getType(), entity.getProvider())
.createNotifier(entity.toProperties())
.flatMapMany(Notifier::close)
.then();
}
public NotifierProvider getNotifierProvider(String type, String provider) {<FILL_FUNCTION_BODY>}
public TemplateProvider getTemplateProvider(String type, String provider) {
for (TemplateProvider prov : templateProviders) {
if (prov.getType().getId().equalsIgnoreCase(type) && prov
.getProvider()
.getId()
.equalsIgnoreCase(provider)) {
return prov;
}
}
throw new ValidationException("error.unsupported_notify_provider");
}
}
|
for (NotifierProvider prov : notifierProviders) {
if (prov.getType().getId().equalsIgnoreCase(type) && prov
.getProvider()
.getId()
.equalsIgnoreCase(provider)) {
return prov;
}
}
throw new ValidationException("error.unsupported_notify_provider");
| 677
| 86
| 763
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/notify-manager/src/main/java/org/jetlinks/community/notify/manager/subscriber/channel/NotificationDispatcher.java
|
NotificationDispatcher
|
register
|
class NotificationDispatcher implements CommandLineRunner {
private final EventBus eventBus;
private final ReactiveCacheContainer<String, NotifyChannel> channels = ReactiveCacheContainer.create();
private final Map<String, NotifyChannelProvider> providers = new HashMap<>();
private final ReactiveRepository<NotifySubscriberChannelEntity, String> channelRepository;
public NotificationDispatcher(EventBus eventBus,
ObjectProvider<NotifyChannelProvider> providers,
ReactiveRepository<NotifySubscriberChannelEntity, String> channelRepository) {
this.eventBus = eventBus;
this.channelRepository = channelRepository;
//默认支持站内信
this.channels.put(InsideMailChannelProvider.provider, new InsideMailChannelProvider(eventBus));
for (NotifyChannelProvider provider : providers) {
this.providers.put(provider.getId(), provider);
}
}
@EventListener
public void handleNotifications(Notification notification) {
List<String> channelIdList = notification.getNotifyChannels();
//默认站内信
if (channelIdList == null) {
channelIdList = Collections.singletonList(InsideMailChannelProvider.provider);
}
//发送通知
for (String notifyChannel : channelIdList) {
NotifyChannel dispatcher = channels.getNow(notifyChannel);
if (dispatcher != null) {
dispatcher
.sendNotify(notification)
.subscribe();
}
}
}
@EventListener
public void handleEvent(EntityCreatedEvent<NotifySubscriberChannelEntity> event) {
event.async(
register(event.getEntity())
);
}
@EventListener
public void handleEvent(EntitySavedEvent<NotifySubscriberChannelEntity> event) {
event.async(
register(event.getEntity())
);
}
@EventListener
public void handleEvent(EntityModifyEvent<NotifySubscriberChannelEntity> event) {
event.async(
register(event.getAfter())
);
}
@EventListener
public void handleEvent(EntityDeletedEvent<NotifySubscriberChannelEntity> event) {
event.async(
unregister(event.getEntity())
);
}
@Subscribe(value = "/_sys/notify-channel/unregister", features = Subscription.Feature.broker)
public void unregister(NotifySubscriberChannelEntity entity) {
channels.remove(entity.getId());
}
@Subscribe(value = "/_sys/notify-channel/register", features = Subscription.Feature.broker)
public Mono<Void> register(NotifySubscriberChannelEntity entity) {<FILL_FUNCTION_BODY>}
private Mono<NotifyChannel> createChannel(NotifySubscriberChannelEntity entity) {
NotifyChannelProvider provider = providers.get(entity.getChannelProvider());
if (null == provider) {
return Mono.empty();
}
return provider.createChannel(entity.getChannelConfiguration());
}
private Mono<Void> unregister(List<NotifySubscriberChannelEntity> entities) {
for (NotifySubscriberChannelEntity entity : entities) {
unregister(entity);
}
return Flux.fromIterable(entities)
.flatMap(e -> eventBus.publish("/_sys/notify-channel/unregister", e))
.then();
}
private Mono<Void> register(List<NotifySubscriberChannelEntity> entities) {
return Flux.fromIterable(entities)
.flatMap(e -> register(e)
.then(eventBus.publish("/_sys/notify-channel/register", e)))
.then();
}
@Override
public void run(String... args) throws Exception {
channelRepository
.createQuery()
.where(NotifySubscriberChannelEntity::getState, NotifyChannelState.enabled)
.fetch()
.flatMap(e -> this
.register(e)
.onErrorResume(er -> {
log.warn("register notify channel error", er);
return Mono.empty();
}))
.subscribe();
}
}
|
if (entity.getState() == NotifyChannelState.disabled) {
channels.remove(entity.getId());
} else {
return channels
.compute(entity.getId(), (ignore, old) -> {
if (null != old) {
old.dispose();
}
return createChannel(entity);
})
.then();
}
return Mono.empty();
| 1,081
| 104
| 1,185
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/notify-manager/src/main/java/org/jetlinks/community/notify/manager/subscriber/channel/notifiers/NotifierChannelProvider.java
|
NotifierChannel
|
createVariable
|
class NotifierChannel implements NotifyChannel {
private final NotifyChannelConfig config;
private Map<String, Object> createVariable(Notification notification) {<FILL_FUNCTION_BODY>}
@Override
public Mono<Void> sendNotify(Notification notification) {
return notifierManager
.getNotifier(getNotifyType(), config.notifierId)
.flatMap(notifier -> notifier.send(config.templateId, Values.of(createVariable(notification))));
}
@Override
public void dispose() {
}
}
|
Map<String, Object> vars = Maps.newHashMapWithExpectedSize(32);
//消息内容
vars.put("message", notification.getMessage());
//通知详情数据
vars.put("detail", notification.getDetail());
//通知详情数据-json
vars.put("detailJson", JSON.toJSONString(notification.getDetail()));
//编码
vars.put("code", notification.getCode());
//订阅者ID
vars.put("subscriber", notification.getSubscriber());
//订阅主题名称
vars.put("topic", notification.getTopicName());
//通知时间
vars.put("notifyTime", notification.getNotifyTime());
if (MapUtils.isNotEmpty(config.variables)) {
vars.putAll(config.variables);
}
return vars;
| 151
| 230
| 381
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/notify-manager/src/main/java/org/jetlinks/community/notify/manager/subscriber/providers/AlarmDeviceProvider.java
|
AlarmDeviceProvider
|
createSubscriber
|
class AlarmDeviceProvider extends AlarmProvider {
public AlarmDeviceProvider(EventBus eventBus) {
super(eventBus);
}
@Override
public String getId() {
return "alarm-device";
}
@Override
public String getName() {
return "设备告警";
}
@Override
public Mono<Subscriber> createSubscriber(String id, Authentication authentication, Map<String, Object> config) {<FILL_FUNCTION_BODY>}
@Override
public Flux<PropertyMetadata> getDetailProperties(Map<String, Object> config) {
return super.getDetailProperties(config)
.concatWith(Flux.just(
SimplePropertyMetadata.of("targetId", "设备ID", StringType.GLOBAL),
SimplePropertyMetadata.of("targetName", "设备名称", StringType.GLOBAL)
));
}
}
|
String topic = Topics.alarm(TargetType.device.name(), "*", getAlarmId(config));
return doCreateSubscriber(id, authentication, topic);
| 237
| 46
| 283
|
<methods>public void <init>(org.jetlinks.core.event.EventBus) ,public Mono<org.jetlinks.community.notify.manager.subscriber.Subscriber> createSubscriber(java.lang.String, Authentication, Map<java.lang.String,java.lang.Object>) ,public org.jetlinks.core.metadata.ConfigMetadata getConfigMetadata() ,public Flux<org.jetlinks.core.metadata.PropertyMetadata> getDetailProperties(Map<java.lang.String,java.lang.Object>) ,public java.lang.String getId() ,public java.lang.String getName() <variables>private final non-sealed org.jetlinks.core.event.EventBus eventBus
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/notify-manager/src/main/java/org/jetlinks/community/notify/manager/subscriber/providers/AlarmOtherProvider.java
|
AlarmOtherProvider
|
createSubscriber
|
class AlarmOtherProvider extends AlarmProvider {
public AlarmOtherProvider(EventBus eventBus) {
super(eventBus);
}
@Override
public String getId() {
return "alarm-other";
}
@Override
public String getName() {
return "其他告警";
}
@Override
public Mono<Subscriber> createSubscriber(String id, Authentication authentication, Map<String, Object> config) {<FILL_FUNCTION_BODY>}
}
|
String topic = Topics.alarm(TargetType.other.name(), "*", getAlarmId(config));
return doCreateSubscriber(id, authentication, topic);
| 136
| 46
| 182
|
<methods>public void <init>(org.jetlinks.core.event.EventBus) ,public Mono<org.jetlinks.community.notify.manager.subscriber.Subscriber> createSubscriber(java.lang.String, Authentication, Map<java.lang.String,java.lang.Object>) ,public org.jetlinks.core.metadata.ConfigMetadata getConfigMetadata() ,public Flux<org.jetlinks.core.metadata.PropertyMetadata> getDetailProperties(Map<java.lang.String,java.lang.Object>) ,public java.lang.String getId() ,public java.lang.String getName() <variables>private final non-sealed org.jetlinks.core.event.EventBus eventBus
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/notify-manager/src/main/java/org/jetlinks/community/notify/manager/subscriber/providers/AlarmProductProvider.java
|
AlarmProductProvider
|
getDetailProperties
|
class AlarmProductProvider extends AlarmProvider {
public AlarmProductProvider(EventBus eventBus) {
super(eventBus);
}
@Override
public String getId() {
return "alarm-product";
}
@Override
public String getName() {
return "产品告警";
}
@Override
public Mono<Subscriber> createSubscriber(String id, Authentication authentication, Map<String, Object> config) {
String topic = Topics.alarm(TargetType.product.name(), "*", getAlarmId(config));
return doCreateSubscriber(id, authentication, topic);
}
@Override
public Flux<PropertyMetadata> getDetailProperties(Map<String, Object> config) {<FILL_FUNCTION_BODY>}
}
|
return super.getDetailProperties(config)
.concatWith(Flux.just(
SimplePropertyMetadata.of("targetId", "产品ID", StringType.GLOBAL),
SimplePropertyMetadata.of("targetName", "产品名称", StringType.GLOBAL)
));
| 208
| 74
| 282
|
<methods>public void <init>(org.jetlinks.core.event.EventBus) ,public Mono<org.jetlinks.community.notify.manager.subscriber.Subscriber> createSubscriber(java.lang.String, Authentication, Map<java.lang.String,java.lang.Object>) ,public org.jetlinks.core.metadata.ConfigMetadata getConfigMetadata() ,public Flux<org.jetlinks.core.metadata.PropertyMetadata> getDetailProperties(Map<java.lang.String,java.lang.Object>) ,public java.lang.String getId() ,public java.lang.String getName() <variables>private final non-sealed org.jetlinks.core.event.EventBus eventBus
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/notify-manager/src/main/java/org/jetlinks/community/notify/manager/subscriber/providers/AlarmProvider.java
|
AlarmProvider
|
doCreateSubscriber
|
class AlarmProvider implements SubscriberProvider {
private final EventBus eventBus;
public AlarmProvider(EventBus eventBus) {
this.eventBus = eventBus;
}
@Override
public String getId() {
return "alarm";
}
@Override
public String getName() {
return "告警";
}
@Override
public ConfigMetadata getConfigMetadata() {
return new DefaultConfigMetadata()
.add("alarmConfigId", "告警规则", "告警规则,支持通配符:*", StringType.GLOBAL);
}
@Override
public Mono<Subscriber> createSubscriber(String id, Authentication authentication, Map<String, Object> config) {
String topic = Topics.alarm("*", "*", getAlarmId(config));
return Mono.just(locale -> createSubscribe(locale, id, new String[]{topic})
//有效期内去重,防止同一个用户所在多个部门推送同一个告警
.as(FluxUtils.distinct(Notify::getDataId, Duration.ofSeconds(10))));
}
protected Mono<Subscriber> doCreateSubscriber(String id,
Authentication authentication,
String topic) {<FILL_FUNCTION_BODY>}
protected String getAlarmId( Map<String, Object> config) {
ValueObject configs = ValueObject.of(config);
return configs.getString("alarmConfigId").orElse("*");
}
private Flux<Notify> createSubscribe(Locale locale,
String id,
String[] topics) {
Subscription.Feature[] features = new Subscription.Feature[]{Subscription.Feature.local};
return Flux
.defer(() -> this
.eventBus
.subscribe(Subscription.of("alarm:" + id, topics, features))
.map(msg -> {
JSONObject json = msg.bodyToJson();
return Notify.of(
getNotifyMessage(locale, json),
//告警记录ID
json.getString("id"),
System.currentTimeMillis(),
"alarm",
json
);
}));
}
private static String getNotifyMessage(Locale locale, JSONObject json) {
String message;
TargetType targetType = TargetType.of(json.getString("targetType"));
String targetName = json.getString("targetName");
String alarmName = json.getString("alarmConfigName");
if (targetType == TargetType.other) {
message = String.format("[%s]发生告警:[%s]!", targetName, alarmName);
} else {
message = String.format("%s[%s]发生告警:[%s]!", targetType.getText(), targetName, alarmName);
}
return LocaleUtils.resolveMessage("message.alarm.notify." + targetType.name(), locale, message, targetName, alarmName);
}
@Override
public Flux<PropertyMetadata> getDetailProperties(Map<String, Object> config) {
//todo 根据配置来获取输出数据
return Flux.just(
SimplePropertyMetadata.of("targetType", "告警类型", StringType.GLOBAL),
SimplePropertyMetadata.of("alarmName", "告警名称", StringType.GLOBAL),
SimplePropertyMetadata.of("targetName", "目标名称", StringType.GLOBAL)
);
}
@AllArgsConstructor
@Getter
enum TargetType {
device("设备"),
product("产品"),
other("其它");
private final String text;
public static TargetType of(String name) {
for (TargetType value : TargetType.values()) {
if (Objects.equals(value.name(), name)) {
return value;
}
}
return TargetType.other;
}
}
}
|
return Mono.just(locale -> createSubscribe(locale, id, new String[]{topic})
//有效期内去重,防止同一个用户所在多个部门推送同一个告警
.as(FluxUtils.distinct(Notify::getDataId, Duration.ofSeconds(10))));
| 999
| 79
| 1,078
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/notify-manager/src/main/java/org/jetlinks/community/notify/manager/web/NotifierConfigController.java
|
NotifierConfigController
|
getAllTypes
|
class NotifierConfigController implements ReactiveServiceCrudController<NotifyConfigEntity, String> {
private final NotifyConfigService notifyConfigService;
private final List<NotifierProvider> providers;
public NotifierConfigController(NotifyConfigService notifyConfigService,
List<NotifierProvider> providers) {
this.notifyConfigService = notifyConfigService;
this.providers = providers;
}
@Override
public NotifyConfigService getService() {
return notifyConfigService;
}
@GetMapping("/{type}/{provider}/metadata")
@QueryAction
@Operation(summary = "获取指定类型和服务商所需配置定义")
public Mono<ConfigMetadata> getAllTypes(@PathVariable @Parameter(description = "通知类型ID") String type,
@PathVariable @Parameter(description = "服务商ID") String provider) {<FILL_FUNCTION_BODY>}
@GetMapping("/types")
@QueryAction
@Operation(summary = "获取平台支持的通知类型")
public Flux<NotifyTypeInfo> getAllTypes() {
return Flux.fromIterable(providers)
.collect(Collectors.groupingBy(NotifierProvider::getType))
.flatMapIterable(Map::entrySet)
.map(en -> {
NotifyTypeInfo typeInfo = new NotifyTypeInfo();
typeInfo.setId(en.getKey().getId());
typeInfo.setName(en.getKey().getName());
typeInfo.setProviderInfos(en.getValue().stream().map(ProviderInfo::of).collect(Collectors.toList()));
return typeInfo;
});
}
/**
* 根据类型获取服务商信息
*
* @param type 类型标识 {@link NotifyType#getId()}
* @return 服务商信息
*/
@GetMapping("/type/{type}/providers")
@QueryAction
@Operation(summary = "获取支持的服务商")
public Flux<ProviderInfo> getTypeProviders(@PathVariable
@Parameter(description = "通知类型ID") String type) {
return Flux
.fromIterable(providers)
.filter(provider -> provider.getType().getId().equals(type))
.map(ProviderInfo::of);
}
@Getter
@Setter
@EqualsAndHashCode(of = "id")
public static class NotifyTypeInfo {
@Parameter(description = "通知类型ID")
private String id;
@Parameter(description = "通知类型名称")
private String name;
@Parameter(description = "服务商信息")
private List<ProviderInfo> providerInfos;
}
@AllArgsConstructor
@Getter
public static class ProviderInfo {
@Parameter(description = "通知类型")
private final String type;
@Parameter(description = "服务商ID")
private final String id;
@Parameter(description = "服务商名称")
private final String name;
public static ProviderInfo of(NotifierProvider provider) {
return new ProviderInfo(provider.getType().getId(), provider.getProvider().getId(), provider.getProvider().getName());
}
}
}
|
return Flux.fromIterable(providers)
.filter(prov -> prov.getType().getId().equalsIgnoreCase(type) && prov.getProvider().getId().equalsIgnoreCase(provider))
.flatMap(prov -> Mono.justOrEmpty(prov.getNotifierConfigMetadata()))
.next();
| 812
| 80
| 892
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/notify-manager/src/main/java/org/jetlinks/community/notify/manager/web/NotifierController.java
|
NotifierController
|
sendNotify
|
class NotifierController {
private final NotifyConfigService configService;
private final NotifierManager notifierManager;
private final TemplateManager templateManager;
/**
* 指定通知器以及模版.发送通知.
*
* @param notifierId 通知器ID
* @param mono 发送请求
* @return 发送结果
*/
@PostMapping("/{notifierId}/_send")
@ResourceAction(id = "send", name = "发送通知")
@Operation(summary = "发送消息通知")
public Mono<Void> sendNotify(@PathVariable @Parameter(description = "通知配置ID") String notifierId,
@RequestBody Mono<SendNotifyRequest> mono) {<FILL_FUNCTION_BODY>}
@PostMapping("/{notifierId}/{templateId}/_send")
@ResourceAction(id = "send", name = "发送通知")
@Operation(summary = "根据配置和模版ID发送消息通知")
public Mono<Void> sendNotify(@PathVariable @Parameter(description = "通知配置ID") String notifierId,
@PathVariable @Parameter(description = "通知模版ID") String templateId,
@RequestBody Mono<Map<String, Object>> contextMono) {
return configService
.findById(notifierId)
.flatMap(conf -> Mono
.zip(
notifierManager
.getNotifier(NotifyType.of(conf.getType()), notifierId)
.switchIfEmpty(Mono.error(() -> new NotFoundException("error.notifier_does_not_exist", notifierId))),
contextMono,
(notifier, contextMap) -> notifier.send(templateId, Values.of(contextMap))
)
.flatMap(Function.identity()));
}
@Getter
@Setter
public static class SendNotifyRequest {
@NotNull
@Schema(description = "通知模版")
private NotifyTemplateEntity template;
@Schema(description = "上下文数据")
private Map<String, Object> context = new HashMap<>();
}
}
|
return mono.flatMap(tem -> {
NotifyType type = NotifyType.of(tem.getTemplate().getType());
return Mono
.zip(
notifierManager
.getNotifier(type, notifierId)
.switchIfEmpty(Mono.error(() -> new NotFoundException("error.notifier_does_not_exist", notifierId))),
templateManager.createTemplate(type, tem.getTemplate().toTemplateProperties()),
(notifier, template) -> notifier.send(template, Values.of(tem.getContext())))
.flatMap(Function.identity());
});
| 553
| 163
| 716
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/notify-manager/src/main/java/org/jetlinks/community/notify/manager/web/NotifierHistoryController.java
|
NotifierHistoryController
|
queryPagerByTemplateId
|
class NotifierHistoryController {
private final NotifyHistoryRepository repository;
public NotifierHistoryController(NotifyHistoryRepository repository) {
this.repository = repository;
}
@PostMapping("/config/{configId}/_query")
@Operation(summary = "根据通知配置ID查询通知记录")
public Mono<PagerResult<NotifyHistory>> queryPagerByConfigId(@PathVariable String configId,
@RequestBody Mono<QueryParamEntity> queryParam) {
return queryParam
.flatMap(param -> param
.toNestQuery(q -> q.is(NotifyHistory::getNotifierId, configId))
.execute(repository::queryPager));
}
@PostMapping("/template/{templateId}/_query")
@Operation(summary = "根据通知模版ID查询通知记录")
public Mono<PagerResult<NotifyHistory>> queryPagerByTemplateId(@PathVariable String templateId,
@RequestBody Mono<QueryParamEntity> queryParam) {<FILL_FUNCTION_BODY>}
}
|
return queryParam
.flatMap(param -> param
.toNestQuery(q -> q.is(NotifyHistory::getTemplateId, templateId))
.execute(repository::queryPager));
| 269
| 55
| 324
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/notify-manager/src/main/java/org/jetlinks/community/notify/manager/web/NotifierTemplateController.java
|
NotifierTemplateController
|
queryTemplatesByConfigId
|
class NotifierTemplateController implements ReactiveServiceCrudController<NotifyTemplateEntity, String> {
private final NotifyTemplateService templateService;
private final List<TemplateProvider> providers;
private final NotifyConfigService configService;
public NotifierTemplateController(NotifyTemplateService templateService,
NotifyConfigService configService,
List<TemplateProvider> providers) {
this.templateService = templateService;
this.providers = providers;
this.configService = configService;
}
@Override
public ReactiveCrudService<NotifyTemplateEntity, String> getService() {
return templateService;
}
@PostMapping("/{configId}/_query")
@QueryAction
@Operation(summary = "根据配置ID查询通知模版列表")
public Flux<NotifyTemplateEntity> queryTemplatesByConfigId(@PathVariable
@Parameter(description = "配置ID") String configId,
@RequestBody Mono<QueryParamEntity> query) {<FILL_FUNCTION_BODY>}
@PostMapping("/{configId}/detail/_query")
@QueryAction
@Operation(summary = "根据配置ID查询通知模版详情列表")
public Flux<NotifyTemplateEntity> queryTemplatesDetailByConfigId(@PathVariable
@Parameter(description = "配置ID") String configId,
@RequestBody Mono<QueryParamEntity> query) {
return configService
.findById(configId)
.flatMapMany(conf -> query
.flatMapMany(param -> param
.toNestQuery(nest -> nest
//where type = ? and provider = ? and (config_id = ? or config_id is null or config_id = '')
.is(NotifyTemplateEntity::getType, conf.getType())
.is(NotifyTemplateEntity::getProvider, conf.getProvider())
.nest()
/**/.is(NotifyTemplateEntity::getConfigId, configId)
/* */.or()
/**/.isNull(NotifyTemplateEntity::getConfigId)
.isEmpty(NotifyTemplateEntity::getConfigId)
)
.noPaging()
.execute(templateService::query)))
.flatMap(e -> this
.convertVariableDefinitions(e)
.doOnNext(e::setVariableDefinitions)
.thenReturn(e));
}
@GetMapping("/{templateId}/detail")
@QueryAction
@Operation(summary = "获取模版详情信息")
public Mono<TemplateInfo> getTemplateDetail(@PathVariable
@Parameter(description = "模版ID") String templateId) {
return templateService
.findById(templateId)
.flatMap(e -> {
TemplateInfo info = new TemplateInfo();
info.setId(e.getId());
info.setName(e.getName());
return this
.getProvider(e.getType(), e.getProvider())
.createTemplate(e.toTemplateProperties())
.doOnNext(t -> info.setVariableDefinitions(new ArrayList<>(t.getVariables().values())))
.thenReturn(info);
});
}
@GetMapping("/{type}/{provider}/config/metadata")
@QueryAction
@Operation(summary = "获取指定类型和服务商所需模版配置定义")
public Mono<ConfigMetadata> getConfigMetadata(@PathVariable @Parameter(description = "通知类型ID") String type,
@PathVariable @Parameter(description = "服务商ID") String provider) {
return Mono.justOrEmpty(getProvider(type, provider).getTemplateConfigMetadata());
}
public TemplateProvider getProvider(String type, String provider) {
for (TemplateProvider prov : providers) {
if (prov.getType().getId().equalsIgnoreCase(type) && prov
.getProvider()
.getId()
.equalsIgnoreCase(provider)) {
return prov;
}
}
throw new ValidationException("error.unsupported_notify_provider");
}
private Mono<List<VariableDefinition>> convertVariableDefinitions(NotifyTemplateEntity templateEntity) {
return this
.getProvider(templateEntity.getType(), templateEntity.getProvider())
.createTemplate(templateEntity.toTemplateProperties())
.map(t -> new ArrayList<>(t.getVariables().values()));
}
}
|
return configService
.findById(configId)
.flatMapMany(conf -> query
.flatMapMany(param -> param
.toNestQuery(nest -> nest
//where type = ? and provider = ? and (config_id = ? or config_id is null or config_id = '')
.is(NotifyTemplateEntity::getType, conf.getType())
.is(NotifyTemplateEntity::getProvider, conf.getProvider())
.nest()
/**/.is(NotifyTemplateEntity::getConfigId, configId)
/* */.or()
/**/.isNull(NotifyTemplateEntity::getConfigId)
.isEmpty(NotifyTemplateEntity::getConfigId)
)
.noPaging()
.execute(templateService::query)));
| 1,100
| 200
| 1,300
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/notify-manager/src/main/java/org/jetlinks/community/notify/manager/web/NotifyChannelController.java
|
SubscriberProviderInfo
|
copyToProvidedUser
|
class SubscriberProviderInfo {
private String id;
private String name;
private String provider;
private Map<String, Object> configuration;
private AuthenticationSpec grant;
private NotifyChannelState state;
private List<NotifySubscriberChannelEntity> channels = new ArrayList<>();
public SubscriberProviderInfo copyToProvidedUser(Authentication auth, NotifySubscriberProperties properties) {<FILL_FUNCTION_BODY>}
public static SubscriberProviderInfo of(SubscriberProvider info) {
return new SubscriberProviderInfo(
IDGenerator.RANDOM.generate(),
info.getName(),
info.getId(),
null,
null,
NotifyChannelState.disabled,
new ArrayList<>());
}
public SubscriberProviderInfo with(List<NotifyChannelProvider> provider) {
for (NotifyChannelProvider notifyChannelProvider : provider) {
NotifySubscriberChannelEntity entity = new NotifySubscriberChannelEntity();
entity.setChannelProvider(notifyChannelProvider.getId());
entity.setName(notifyChannelProvider.getName());
channels.add(entity);
}
return this;
}
public SubscriberProviderInfo with(NotifySubscriberChannelEntity channel) {
boolean matched = false;
for (NotifySubscriberChannelEntity entity : channels) {
if (Objects.equals(entity.getChannelProvider(), channel.getChannelProvider())
&& entity.getId() == null) {
matched = true;
channel.copyTo(entity);
}
}
if (!matched) {
channels.add(channel);
}
return this;
}
public SubscriberProviderInfo with(NotifySubscriberProviderEntity provider) {
this.id = provider.getId();
this.name = provider.getName();
this.provider = provider.getProvider();
this.grant = provider.getGrant();
this.configuration = provider.getConfiguration();
this.state = provider.getState();
return this;
}
public NotifySubscriberProviderEntity toProviderEntity() {
return new NotifySubscriberProviderEntity().copyFrom(this);
}
public List<NotifySubscriberChannelEntity> toChannelEntities() {
if (CollectionUtils.isEmpty(channels)) {
return Collections.emptyList();
}
for (NotifySubscriberChannelEntity channel : channels) {
channel.setProviderId(this.id);
}
return channels;
}
}
|
SubscriberProviderInfo info = new SubscriberProviderInfo();
info.setId(id);
info.setName(name);
info.setProvider(provider);
info.setChannels(
channels
.stream()
.filter(e -> e.getId() != null &&
(properties.isAllowAllNotify(auth) || e.getGrant() == null || e.getGrant().isGranted(auth)))
.collect(Collectors.toList())
);
return info;
| 642
| 133
| 775
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/rule-engine-manager/src/main/java/org/jetlinks/community/rule/engine/alarm/AbstractAlarmTarget.java
|
AbstractAlarmTarget
|
convert
|
class AbstractAlarmTarget implements AlarmTarget {
@Override
public final Flux<AlarmTargetInfo> convert(AlarmData data) {<FILL_FUNCTION_BODY>}
protected abstract Flux<AlarmTargetInfo> doConvert(AlarmData data);
static Optional<Object> getFromOutput(String key, Map<String, Object> output) {
//优先从场景输出中获取
Object sceneOutput = output.get(SceneRule.CONTEXT_KEY_SCENE_OUTPUT);
if (sceneOutput instanceof Map) {
return Optional.ofNullable(((Map<?, ?>) sceneOutput).get(key));
}
return Optional.ofNullable(output.get(key));
}
}
|
return this
.doConvert(data)
.doOnNext(info -> {
String sourceType = AbstractAlarmTarget
.getFromOutput(SceneRule.SOURCE_TYPE_KEY, data.getOutput())
.map(String::valueOf)
.orElse(null);
String sourceId = AbstractAlarmTarget
.getFromOutput(SceneRule.SOURCE_ID_KEY, data.getOutput())
.map(String::valueOf)
.orElse(null);
String sourceName = AbstractAlarmTarget
.getFromOutput(SceneRule.SOURCE_NAME_KEY, data.getOutput())
.map(String::valueOf)
.orElse(sourceId);
if (sourceType != null && sourceId != null) {
info.withSource(sourceType, sourceId, sourceName);
}
});
| 184
| 225
| 409
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/rule-engine-manager/src/main/java/org/jetlinks/community/rule/engine/alarm/AlarmTargetInfo.java
|
AlarmTargetInfo
|
withSource
|
class AlarmTargetInfo {
private String targetId;
private String targetName;
private String targetType;
private String sourceType;
private String sourceId;
private String sourceName;
public static AlarmTargetInfo of(String targetId, String targetName, String targetType) {
return AlarmTargetInfo.of(targetId, targetName, targetType, null, null, null);
}
public AlarmTargetInfo withTarget(String type, String id, String name) {
this.targetType = type;
this.targetId = id;
this.targetName = name;
return this;
}
public AlarmTargetInfo withSource(String type, String id, String name) {<FILL_FUNCTION_BODY>}
}
|
this.sourceType = type;
this.sourceId = id;
this.sourceName = name;
return this;
| 198
| 35
| 233
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/rule-engine-manager/src/main/java/org/jetlinks/community/rule/engine/alarm/AlarmTaskExecutorProvider.java
|
AlarmTaskExecutor
|
reload
|
class AlarmTaskExecutor extends FunctionTaskExecutor {
private final AlarmRuleHandler handler;
private Function<RuleData, Flux<AlarmRuleHandler.Result>> executor;
private Config config;
public AlarmTaskExecutor(ExecutionContext context, AlarmRuleHandler handler) {
super("告警", context);
this.handler = handler;
reload();
}
@Override
public String getName() {
return config.getMode() == AlarmMode.relieve
? "解除告警" : "触发告警";
}
@Override
protected Publisher<RuleData> apply(RuleData input) {
return executor
.apply(input)
.doOnError(err -> log.warn("{} alarm error,rule:{}", config.mode, context.getInstanceId(), err))
.map(result -> context.newRuleData(input.newData(result.toMap())));
}
@Override
public void reload() {<FILL_FUNCTION_BODY>}
}
|
config = FastBeanCopier.copy(context.getJob().getConfiguration(), new Config());
ValidatorUtils.tryValidate(config);
if (config.mode == AlarmMode.relieve) {
executor = input -> handler.relieved(context, input);
} else {
executor = input -> handler.triggered(context, input);
}
| 264
| 97
| 361
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/rule-engine-manager/src/main/java/org/jetlinks/community/rule/engine/alarm/DeviceAlarmTarget.java
|
DeviceAlarmTarget
|
doConvert
|
class DeviceAlarmTarget extends AbstractAlarmTarget {
@Override
public String getType() {
return "device";
}
@Override
public String getName() {
return "设备";
}
@Override
public Flux<AlarmTargetInfo> doConvert(AlarmData data) {<FILL_FUNCTION_BODY>}
}
|
Map<String, Object> output = data.getOutput();
String deviceId = AbstractAlarmTarget.getFromOutput("deviceId", output).map(String::valueOf).orElse(null);
String deviceName = AbstractAlarmTarget.getFromOutput("deviceName", output).map(String::valueOf).orElse(deviceId);
if (deviceId == null) {
return Flux.empty();
}
return Flux.just(AlarmTargetInfo.of(deviceId, deviceName, getType()));
| 96
| 132
| 228
|
<methods>public non-sealed void <init>() ,public final Flux<org.jetlinks.community.rule.engine.alarm.AlarmTargetInfo> convert(org.jetlinks.community.rule.engine.alarm.AlarmData) <variables>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/rule-engine-manager/src/main/java/org/jetlinks/community/rule/engine/alarm/ProductAlarmTarget.java
|
ProductAlarmTarget
|
doConvert
|
class ProductAlarmTarget extends AbstractAlarmTarget {
@Override
public String getType() {
return "product";
}
@Override
public String getName() {
return "产品";
}
@Override
public Flux<AlarmTargetInfo> doConvert(AlarmData data) {<FILL_FUNCTION_BODY>}
}
|
Map<String, Object> output = data.getOutput();
String productId = AbstractAlarmTarget.getFromOutput("productId", output).map(String::valueOf).orElse(null);
String productName = AbstractAlarmTarget.getFromOutput("productName", output).map(String::valueOf).orElse(productId);
return Flux.just(AlarmTargetInfo.of(productId, productName, getType()));
| 97
| 110
| 207
|
<methods>public non-sealed void <init>() ,public final Flux<org.jetlinks.community.rule.engine.alarm.AlarmTargetInfo> convert(org.jetlinks.community.rule.engine.alarm.AlarmData) <variables>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/rule-engine-manager/src/main/java/org/jetlinks/community/rule/engine/entity/AlarmConfigDetail.java
|
AlarmConfigDetail
|
withScene
|
class AlarmConfigDetail {
@Schema(description = "告警配置ID")
private String id;
@Schema(description = "名称")
private String name;
@Schema(description = "告警目标类型")
private String targetType;
@Schema(description = "告警级别")
private Integer level;
@Schema(description = "关联场景")
private List<SceneInfo> scene;
@Schema(description = "状态")
private AlarmState state;
@Schema(description = "场景触发类型")
private String sceneTriggerType;
@Schema(description = "说明")
private String description;
@Schema(
description = "创建者ID(只读)"
, accessMode = Schema.AccessMode.READ_ONLY
)
private String creatorId;
@Schema(
description = "创建时间(只读)"
, accessMode = Schema.AccessMode.READ_ONLY
)
private Long createTime;
@Schema(description = "更新者ID", accessMode = Schema.AccessMode.READ_ONLY)
private String modifierId;
@Schema(description = "更新时间")
private Long modifyTime;
public static AlarmConfigDetail of(AlarmConfigEntity entity) {
return FastBeanCopier.copy(entity, new AlarmConfigDetail(), "sceneTriggerType");
}
public AlarmConfigDetail withScene(List<SceneEntity> sceneEntityList) {<FILL_FUNCTION_BODY>}
/**
* 场景联动信息
*/
@Getter
@Setter
public static class SceneInfo {
@Schema(description = "场景联动ID")
private String id;
@Column(nullable = false)
@Schema(description = "场景联动名称")
@NotBlank
private String name;
@Schema(description = "触发器类型")
private String triggerType;
@Schema(description = "状态")
private RuleInstanceState state;
public static SceneInfo of(SceneEntity entity) {
return FastBeanCopier.copy(entity, new SceneInfo());
}
}
}
|
List<SceneInfo> sceneList = new ArrayList<>();
for (SceneEntity sceneEntity : sceneEntityList) {
sceneList.add(SceneInfo.of(sceneEntity));
String triggerType = sceneEntity.getTriggerType();
// 存在一个手动触发场景，则将告警配置视为手动触发类型
if (this.sceneTriggerType == null || ManualTriggerProvider.PROVIDER.equals(triggerType)) {
this.sceneTriggerType = triggerType;
}
}
this.scene = sceneList;
return this;
| 564
| 151
| 715
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/rule-engine-manager/src/main/java/org/jetlinks/community/rule/engine/entity/AlarmConfigEntity.java
|
AlarmConfigEntity
|
toConfigMap
|
class AlarmConfigEntity extends GenericEntity<String> implements RecordCreationEntity, RecordModifierEntity {
@Column(length = 64, nullable = false)
@Schema(description = "名称")
private String name;
@Column(length = 64, nullable = false)
@Schema(description = "告警目标类型")
private String targetType;
@Column(nullable = false)
@Schema(description = "告警级别")
private Integer level;
@Column(length = 128)
@Schema(description = "关联场景名称")
@Deprecated
private String sceneName;
@Column(length = 64)
@Schema(description = "关联场景Id")
@Deprecated
private String sceneId;
@Column(length = 32, nullable = false)
@EnumCodec
@ColumnType(javaType = String.class)
@DefaultValue("enabled")
@Schema(description = "状态")
private AlarmState state;
@Column(length = 32)
@EnumCodec
@ColumnType(javaType = String.class)
@Schema(description = "场景触发类型")
@Deprecated
private TriggerType sceneTriggerType;
@Column(length = 256)
@Schema(description = "说明")
private String description;
@Column(length = 64, updatable = false)
@Schema(
description = "创建者ID(只读)"
, accessMode = Schema.AccessMode.READ_ONLY
)
private String creatorId;
@Column(updatable = false)
@DefaultValue(generator = Generators.CURRENT_TIME)
@Schema(
description = "创建时间(只读)"
, accessMode = Schema.AccessMode.READ_ONLY
)
private Long createTime;
@Column(length = 64)
@Schema(description = "更新者ID", accessMode = Schema.AccessMode.READ_ONLY)
private String modifierId;
@Column
@DefaultValue(generator = Generators.CURRENT_TIME)
@Schema(description = "更新时间")
private Long modifyTime;
public Map<String, Object> toConfigMap() {<FILL_FUNCTION_BODY>}
}
|
Map<String, Object> configs = new HashMap<>();
configs.put(AlarmConstants.ConfigKey.alarmConfigId, getId());
configs.put(AlarmConstants.ConfigKey.alarmName, getName());
configs.put(AlarmConstants.ConfigKey.level, getLevel());
configs.put(AlarmConstants.ConfigKey.ownerId, getModifierId() == null ? getCreatorId() : getModifierId());
configs.put(AlarmConstants.ConfigKey.targetType, getTargetType());
configs.put(AlarmConstants.ConfigKey.state, getState().name());
configs.put(AlarmConstants.ConfigKey.description, getDescription());
return configs;
| 588
| 185
| 773
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/rule-engine-manager/src/main/java/org/jetlinks/community/rule/engine/entity/AlarmHandleHistoryEntity.java
|
AlarmHandleHistoryEntity
|
of
|
class AlarmHandleHistoryEntity extends GenericEntity<String> implements RecordCreationEntity {
@Column(length = 64, nullable = false, updatable = false)
@Schema(description = "告警配置ID")
private String alarmId;
@Column(length = 64, nullable = false, updatable = false)
@Schema(description = "告警记录Id")
private String alarmRecordId;
@Column(length = 64, nullable = false, updatable = false)
@Schema(description = "告警处理类型")
@EnumCodec
@ColumnType(javaType = String.class)
private AlarmHandleType handleType;
@Column(length = 256, nullable = false, updatable = false)
@Schema(description = "说明")
private String description;
@Column(updatable = false)
@Schema(description = "处理时间")
private Long handleTime;
@Column(updatable = false)
@Schema(description = "告警时间")
private Long alarmTime;
@Column(updatable = false)
@Schema(
description = "创建者ID(只读)"
, accessMode = Schema.AccessMode.READ_ONLY
)
private String creatorId;
@Column(updatable = false)
@DefaultValue(generator = Generators.CURRENT_TIME)
@Schema(
description = "创建时间(只读)"
, accessMode = Schema.AccessMode.READ_ONLY
)
private Long createTime;
public static AlarmHandleHistoryEntity of(AlarmHandleInfo handleInfo) {<FILL_FUNCTION_BODY>}
}
|
AlarmHandleHistoryEntity entity = new AlarmHandleHistoryEntity();
entity.setAlarmId(handleInfo.getAlarmConfigId());
entity.setAlarmRecordId(handleInfo.getAlarmRecordId());
entity.setAlarmTime(handleInfo.getAlarmTime());
entity.setHandleType(handleInfo.getType());
entity.setDescription(handleInfo.getDescribe());
entity.setHandleTime(handleInfo.getHandleTime() == null ? System.currentTimeMillis() : handleInfo.getHandleTime());
return entity;
| 426
| 139
| 565
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/rule-engine-manager/src/main/java/org/jetlinks/community/rule/engine/entity/AlarmHistoryInfo.java
|
AlarmHistoryInfo
|
of
|
class AlarmHistoryInfo implements Serializable {
private static final long serialVersionUID = 1L;
@Schema(description = "告警数据ID")
private String id;
@Schema(description = "告警配置ID")
private String alarmConfigId;
@Schema(description = "告警配置名称")
private String alarmConfigName;
@Schema(description = "告警记录ID")
private String alarmRecordId;
@Schema(description = "告警级别")
private int level;
@Schema(description = "说明")
private String description;
@Schema(description = "告警时间")
private long alarmTime;
@Schema(description = "告警目标类型")
private String targetType;
@Schema(description = "告警目标名称")
private String targetName;
@Schema(description = "告警目标Id")
private String targetId;
@Schema(description = "告警源类型")
private String sourceType;
@Schema(description = "告警源Id")
private String sourceId;
@Schema(description = "告警源名称")
private String sourceName;
@Schema(description = "告警信息")
private String alarmInfo;
@Schema(description = "绑定信息")
private List<Map<String, Object>> bindings;
@Deprecated
public static AlarmHistoryInfo of(String alarmRecordId,
AlarmTargetInfo targetInfo,
SceneData data,
AlarmConfigEntity alarmConfig) {<FILL_FUNCTION_BODY>}
@SuppressWarnings("all")
@Deprecated
static List<Map<String, Object>> convertBindings(AlarmTargetInfo targetInfo,
SceneData data,
AlarmConfigEntity alarmConfig) {
List<Map<String, Object>> bindings = new ArrayList<>();
bindings.addAll((List) data.getOutput().getOrDefault("_bindings", Collections.emptyList()));
//添加告警配置创建人到bindings中。作为用户维度信息
Map<String, Object> userDimension = new HashMap<>(2);
userDimension.put("type", "user");
userDimension.put("id", alarmConfig.getCreatorId());
bindings.add(userDimension);
//添加组织纬度信息
if ("org".equals(alarmConfig.getTargetType())) {
Map<String, Object> orgDimension = new HashMap<>(2);
userDimension.put("type", targetInfo.getTargetType());
userDimension.put("id", targetInfo.getTargetId());
bindings.add(userDimension);
}
return bindings;
}
}
|
AlarmHistoryInfo info = new AlarmHistoryInfo();
info.setAlarmConfigId(alarmConfig.getId());
info.setAlarmConfigName(alarmConfig.getName());
info.setAlarmRecordId(alarmRecordId);
info.setLevel(alarmConfig.getLevel());
info.setId(data.getId());
info.setAlarmTime(System.currentTimeMillis());
info.setTargetName(targetInfo.getTargetName());
info.setTargetId(targetInfo.getTargetId());
info.setTargetType(targetInfo.getTargetType());
info.setSourceName(targetInfo.getSourceName());
info.setSourceType(targetInfo.getSourceType());
info.setSourceId(targetInfo.getSourceId());
info.setAlarmInfo(JSON.toJSONString(data.getOutput()));
info.setDescription(alarmConfig.getDescription());
info.setBindings(convertBindings(targetInfo, data, alarmConfig));
return info;
| 693
| 257
| 950
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/rule-engine-manager/src/main/java/org/jetlinks/community/rule/engine/entity/AlarmLevelEntity.java
|
AlarmLevelEntity
|
defaultOf
|
class AlarmLevelEntity extends GenericEntity<String> {
@Column(length = 64)
@Schema(description = "名称")
private String name;
@Column(name = "config")
@ColumnType(jdbcType = JDBCType.LONGVARCHAR)
@JsonCodec
@Schema(description = "配置信息")
private List<AlarmLevelInfo> levels;
@Column(length = 256)
@Schema(description = "说明")
private String description;
public static AlarmLevelEntity of(List<AlarmLevelInfo> levels){
AlarmLevelEntity entity = new AlarmLevelEntity();
entity.setLevels(levels);
return entity;
}
public static AlarmLevelEntity defaultOf(List<AlarmLevelInfo> levels){<FILL_FUNCTION_BODY>}
}
|
AlarmLevelEntity entity = new AlarmLevelEntity();
entity.setId(AlarmLevelService.DEFAULT_ALARM_ID);
entity.setName("default");
entity.setDescription("default");
entity.setLevels(levels);
return entity;
| 219
| 71
| 290
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/rule-engine-manager/src/main/java/org/jetlinks/community/rule/engine/entity/AlarmRecordEntity.java
|
AlarmRecordEntity
|
getTargetKey
|
class AlarmRecordEntity extends GenericEntity<String> {
@Column(length = 64, nullable = false, updatable = false)
@Schema(description = "告警配置ID")
private String alarmConfigId;
@Column(length = 64, nullable = false)
@Schema(description = "告警配置名称")
private String alarmName;
@Column(length = 32, updatable = false)
@Schema(description = "告警目标类型")
private String targetType;
@Column(length = 64, updatable = false)
@Schema(description = "告警目标Id")
private String targetId;
@Column(length = 64, updatable = false)
@Schema(description = "告警目标Key")
private String targetKey;
@Column
@Schema(description = "告警目标名称")
private String targetName;
@Column(length = 32)
@Schema(description = "告警源类型")
private String sourceType;
@Column(length = 64)
@Schema(description = "告警源Id")
private String sourceId;
@Column
@Schema(description = "告警源名称")
private String sourceName;
@Column
@Schema(description = "最近一次告警时间")
private Long alarmTime;
@Column
@Schema(description = "处理时间")
private Long handleTime;
@Column
@Schema(description = "告警级别")
private Integer level;
@Column(length = 32)
@Schema(description = "告警记录状态")
@EnumCodec
@ColumnType(javaType = String.class)
@DefaultValue("normal")
private AlarmRecordState state;
@Column
@Schema(description = "说明")
private String description;
public String getTargetKey() {<FILL_FUNCTION_BODY>}
public void generateTargetKey() {
setTargetKey(generateId(targetId, targetType));
}
public void generateId() {
setId(generateId(targetId, targetType, alarmConfigId));
}
public static String generateId(String... args) {
return DigestUtils.md5Hex(String.join("-", args));
}
}
|
if (targetKey == null) {
generateTargetKey();
}
return targetKey;
| 591
| 28
| 619
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/rule-engine-manager/src/main/java/org/jetlinks/community/rule/engine/entity/AlarmRuleBindEntity.java
|
AlarmRuleBindEntity
|
getId
|
class AlarmRuleBindEntity extends GenericEntity<String> {
public static final int ANY_BRANCH_INDEX = -1;
@Column(nullable = false, updatable = false, length = 64)
@NotBlank
@Schema(description = "告警配置ID")
private String alarmId;
@Column(nullable = false, updatable = false, length = 64)
@NotBlank
@Schema(description = "场景规则ID")
private String ruleId;
@Column(nullable = false, updatable = false)
@Schema(description = "规则条件分支ID")
@DefaultValue("-1")
private Integer branchIndex;
@Override
public String getId() {<FILL_FUNCTION_BODY>}
}
|
if (StringUtils.hasText(super.getId())) {
return super.getId();
}
setId(DigestUtils.md5Hex(String.join("|", alarmId, ruleId, String.valueOf(branchIndex))));
return super.getId();
| 199
| 70
| 269
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/rule-engine-manager/src/main/java/org/jetlinks/community/rule/engine/entity/RuleInstanceEntity.java
|
RuleInstanceEntity
|
toRuleInstance
|
class RuleInstanceEntity extends GenericEntity<String> implements RecordCreationEntity {
@Override
@GeneratedValue(generator = "snow_flake")
@Pattern(regexp = "^[0-9a-zA-Z_\\-]+$", message = "ID只能由数字,字母,下划线和中划线组成", groups = CreateGroup.class)
@Schema(description = "ID")
public String getId() {
return super.getId();
}
@Column(name = "model_id", length = 64)
@Schema(description = "模型ID")
private String modelId;
@Column(name = "name")
@Schema(description = "名称")
private String name;
@Column(name = "description")
@Schema(description = "说明")
private String description;
@Column(name = "model_type")
@Schema(description = "规则类型")
private String modelType;
@Column(name = "model_meta")
@ColumnType(jdbcType = JDBCType.LONGVARCHAR)
@Schema(description = "规则模型配置,不同的类型配置不同.")
private String modelMeta;
@Column(name = "model_version", nullable = false)
@Schema(description = "版本")
@DefaultValue("1")
private Integer modelVersion;
@Column(name = "create_time")
@Schema(description = "创建时间")
@DefaultValue(generator = Generators.CURRENT_TIME)
private Long createTime;
@Column(name = "creator_id")
@Schema(description = "创建者ID")
private String creatorId;
@Column(name = "state", length = 16)
@EnumCodec
@ColumnType(javaType = String.class)
@DefaultValue("disable")
@Schema(description = "状态")
private RuleInstanceState state;
@Comment("设备详情信息")
@Column(name = "instance_detail_json")
@ColumnType(jdbcType = JDBCType.CLOB)
@Hidden
private String instanceDetailJson;
public RuleModel toRule(RuleEngineModelParser parser) {
RuleModel model = parser.parse(modelType, modelMeta);
model.setId(StringUtils.hasText(modelId) ? modelId : getId());
model.setName(name);
model.addConfiguration(RuleEngineConstants.ruleCreatorIdKey, creatorId);
return model;
}
public RuleInstance toRuleInstance(RuleEngineModelParser parser) {<FILL_FUNCTION_BODY>}
}
|
RuleModel model = toRule(parser);
RuleInstance instance = new RuleInstance();
instance.setId(getId());
instance.setModel(model);
return instance;
| 665
| 47
| 712
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/rule-engine-manager/src/main/java/org/jetlinks/community/rule/engine/entity/SceneEntity.java
|
SceneEntity
|
toRule
|
class SceneEntity extends GenericEntity<String> implements RecordCreationEntity, RecordModifierEntity {
@Column(nullable = false)
@Schema(description = "告警名称")
@NotBlank
private String name;
@Schema(description = "触发器类型")
@Column(length = 32, nullable = false, updatable = false)
// @EnumCodec
// @ColumnType(javaType = String.class)
@NotNull
private String triggerType;
@Column
@JsonCodec
@ColumnType(javaType = String.class, jdbcType = JDBCType.LONGVARCHAR)
@Schema(description = "触发器")
@NotNull
private Trigger trigger;
@Column
@JsonCodec
@ColumnType(javaType = String.class, jdbcType = JDBCType.LONGVARCHAR)
@Schema(description = "触发条件")
private List<Term> terms;
@Column
@Schema(description = "是否并行执行动作")
@DefaultValue("false")
private Boolean parallel;
@Column
@JsonCodec
@ColumnType(javaType = String.class, jdbcType = JDBCType.LONGVARCHAR)
@Schema(description = "执行动作")
private List<SceneAction> actions;
@Column
@JsonCodec
@ColumnType(javaType = String.class, jdbcType = JDBCType.LONGVARCHAR)
@Schema(description = "动作分支")
private List<SceneConditionAction> branches;
@Column(length = 64, updatable = false)
@Schema(description = "创建人")
private String creatorId;
@Column(updatable = false)
@Schema(description = "创建时间")
@DefaultValue(generator = Generators.CURRENT_TIME)
private Long createTime;
@Column(length = 64)
@Schema(description = "修改人")
private String modifierId;
@Column
@Schema(description = "修改时间")
@DefaultValue(generator = Generators.CURRENT_TIME)
private Long modifyTime;
@Column
@Schema(description = "启动时间")
private Long startTime;
@Schema(description = "状态")
@Column(length = 32, nullable = false)
@EnumCodec
@ColumnType(javaType = String.class)
@NotBlank
@DefaultValue("disable")
private RuleInstanceState state;
@Schema(description = "扩展配置")
@Column(name = "options")
@JsonCodec
@ColumnType(jdbcType = JDBCType.LONGVARCHAR)
private Map<String, Object> options;
@Column
@Schema(description = "说明")
private String description;
public RuleInstance toRule() {<FILL_FUNCTION_BODY>}
public SceneEntity with(SceneRule rule) {
SceneEntity entity = copyFrom(rule);
entity.setTriggerType(rule.getTrigger().getType());
return entity;
}
public void validate() {
getTrigger().validate();
if (CollectionUtils.isEmpty(getActions()) && CollectionUtils.isEmpty(getBranches())){
throw new BusinessException("error.scene_action_rule_cannot_be_null");
}
}
}
|
SceneRule rule = copyTo(new SceneRule());
RuleInstance instance = new RuleInstance();
instance.setId(getId());
RuleModel model = rule.toModel();
model.addConfiguration(RuleEngineConstants.ruleCreatorIdKey, modifierId);
model.addConfiguration(RuleEngineConstants.ruleName, getName());
instance.setModel(model);
return instance;
| 869
| 101
| 970
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/rule-engine-manager/src/main/java/org/jetlinks/community/rule/engine/measurement/AlarmRecordMeasurementProvider.java
|
AlarmRecordMeasurementProvider
|
getTags
|
class AlarmRecordMeasurementProvider extends StaticMeasurementProvider {
MeterRegistry registry;
public AlarmRecordMeasurementProvider(MeterRegistryManager registryManager,
TimeSeriesManager timeSeriesManager) {
super(AlarmDashboardDefinition.alarm, AlarmObjectDefinition.record);
registry = registryManager.getMeterRegister(AlarmTimeSeriesMetric.alarmStreamMetrics().getId());
addMeasurement(new AlarmRecordTrendMeasurement(timeSeriesManager));
addMeasurement(new AlarmRecordRankMeasurement(timeSeriesManager));
}
@EventListener
public void aggAlarmRecord(AlarmHistoryInfo info) {
registry
.counter("record-agg", getTags(info))
.increment();
}
public String[] getTags(AlarmHistoryInfo info) {<FILL_FUNCTION_BODY>}
}
|
Map<String, Object> tagMap = Maps.newLinkedHashMap();
tagMap.put(AlarmConstants.ConfigKey.targetId, info.getTargetId());
tagMap.put(AlarmConstants.ConfigKey.targetType, info.getTargetType());
tagMap.put(AlarmConstants.ConfigKey.targetName, info.getTargetName());
tagMap.put(AlarmConstants.ConfigKey.alarmConfigId, info.getAlarmConfigId());
return ConverterUtils.convertMapToTags(tagMap);
| 221
| 136
| 357
|
<methods>public void <init>(org.jetlinks.community.dashboard.DashboardDefinition, org.jetlinks.community.dashboard.ObjectDefinition) ,public Mono<org.jetlinks.community.dashboard.Measurement> getMeasurement(java.lang.String) ,public Flux<org.jetlinks.community.dashboard.Measurement> getMeasurements() <variables>private org.jetlinks.community.dashboard.DashboardDefinition dashboardDefinition,private Map<java.lang.String,org.jetlinks.community.dashboard.Measurement> measurements,private org.jetlinks.community.dashboard.ObjectDefinition objectDefinition
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/rule-engine-manager/src/main/java/org/jetlinks/community/rule/engine/measurement/AlarmRecordRankMeasurement.java
|
AggRecordRankDimension
|
createQueryParam
|
class AggRecordRankDimension implements MeasurementDimension {
@Override
public DimensionDefinition getDefinition() {
return CommonDimensionDefinition.agg;
}
@Override
public DataType getValueType() {
return IntType.GLOBAL;
}
@Override
public ConfigMetadata getParams() {
return aggConfigMetadata;
}
@Override
public boolean isRealTime() {
return false;
}
public AggregationQueryParam createQueryParam(MeasurementParameter parameter) {<FILL_FUNCTION_BODY>}
@Override
public Flux<SimpleMeasurementValue> getValue(MeasurementParameter parameter) {
Comparator<AggregationData> comparator;
if (Objects.equals(parameter.getString("order",""), "asc")){
comparator = Comparator.comparingLong(d-> d.getLong("count", 0L));
}else {
comparator = Comparator.<AggregationData>comparingLong(d-> d.getLong("count", 0L)).reversed();
}
AggregationQueryParam param = createQueryParam(parameter);
return Flux.defer(() -> param
.execute(timeSeriesManager.getService(AlarmTimeSeriesMetric.alarmStreamMetrics())::aggregation)
.groupBy(a -> a.getString("targetId", null))
.flatMap(fluxGroup -> fluxGroup.reduce(AggregationData::merge))
.sort(comparator)
.map(data -> SimpleMeasurementValue.of(new SimpleResult(data), 0))
)
.take(param.getLimit());
}
@Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor
class SimpleResult {
private String targetId;
private String targetName;
private long count;
public SimpleResult(AggregationData data) {
String targetId = data.getString("targetId", "");
this.setCount(data.getLong("count", 0L));
this.setTargetName(data.getString("targetName", targetId));
this.setTargetId(data.getString("targetId", ""));
}
}
}
|
return AggregationQueryParam
.of()
.groupBy(parameter.getString("group", "targetId"))
.sum("count", "count")
.agg("targetId", Aggregation.TOP)
.filter(query -> query
.where("name", "record-agg")
.where("targetType", parameter.getString("targetType", null))
)
.limit(parameter.getInt("limit").orElse(1))
.from(parameter
.getDate("from")
.orElseGet(() -> Date
.from(LocalDateTime
.now()
.plusDays(-1)
.atZone(ZoneId.systemDefault())
.toInstant())))
.to(parameter.getDate("to").orElse(new Date()));
| 570
| 201
| 771
|
<methods>public void <init>(org.jetlinks.community.dashboard.MeasurementDefinition) ,public org.jetlinks.community.dashboard.supports.StaticMeasurement addDimension(org.jetlinks.community.dashboard.MeasurementDimension) ,public Mono<org.jetlinks.community.dashboard.MeasurementDimension> getDimension(java.lang.String) ,public Flux<org.jetlinks.community.dashboard.MeasurementDimension> getDimensions() <variables>private org.jetlinks.community.dashboard.MeasurementDefinition definition,private Map<java.lang.String,org.jetlinks.community.dashboard.MeasurementDimension> dimensions
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/rule-engine-manager/src/main/java/org/jetlinks/community/rule/engine/measurement/AlarmRecordTrendMeasurement.java
|
AggRecordTrendDimension
|
createQueryParam
|
class AggRecordTrendDimension implements MeasurementDimension{
@Override
public DimensionDefinition getDefinition() {
return CommonDimensionDefinition.agg;
}
@Override
public DataType getValueType() {
return IntType.GLOBAL;
}
@Override
public ConfigMetadata getParams() {
return aggConfigMetadata;
}
@Override
public boolean isRealTime() {
return false;
}
public AggregationQueryParam createQueryParam(MeasurementParameter parameter) {<FILL_FUNCTION_BODY>}
@Override
public Flux<SimpleMeasurementValue> getValue(MeasurementParameter parameter) {
AggregationQueryParam param = createQueryParam(parameter);
return Flux.defer(()-> param
.execute(timeSeriesManager.getService(AlarmTimeSeriesMetric.alarmStreamMetrics())::aggregation)
.index((index, data) -> SimpleMeasurementValue.of(
data.getLong("count",0),
data.getString("time",""),
index)))
.take(param.getLimit());
}
}
|
return AggregationQueryParam
.of()
.groupBy(parameter.getInterval("time", null),
parameter.getString("format").orElse("MM月dd日 HH时"))
.sum("count", "count")
.filter(query -> query
.where("name", "record-agg")
.and("targetType",parameter.getString("targetType").orElse(null))
.and("targetId",parameter.getString("targetId").orElse(null))
.is("alarmConfigId", parameter.getString("alarmConfigId").orElse(null))
)
.limit(parameter.getInt("limit").orElse(1))
.from(parameter
.getDate("from")
.orElseGet(() -> Date
.from(LocalDateTime
.now()
.plusDays(-1)
.atZone(ZoneId.systemDefault())
.toInstant())))
.to(parameter.getDate("to").orElse(new Date()));
| 290
| 255
| 545
|
<methods>public void <init>(org.jetlinks.community.dashboard.MeasurementDefinition) ,public org.jetlinks.community.dashboard.supports.StaticMeasurement addDimension(org.jetlinks.community.dashboard.MeasurementDimension) ,public Mono<org.jetlinks.community.dashboard.MeasurementDimension> getDimension(java.lang.String) ,public Flux<org.jetlinks.community.dashboard.MeasurementDimension> getDimensions() <variables>private org.jetlinks.community.dashboard.MeasurementDefinition definition,private Map<java.lang.String,org.jetlinks.community.dashboard.MeasurementDimension> dimensions
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/rule-engine-manager/src/main/java/org/jetlinks/community/rule/engine/model/SqlRuleModelParser.java
|
SqlRuleModelParser
|
parse
|
class SqlRuleModelParser implements RuleModelParserStrategy {
@Override
public String getFormat() {
return "sql_rule";
}
@Override
public RuleModel parse(String modelDefineString) {<FILL_FUNCTION_BODY>}
}
|
SqlRule sqlRule = JSON.parseObject(modelDefineString, SqlRule.class);
sqlRule.validate();
RuleModel model = new RuleModel();
model.setId(sqlRule.getId());
model.setName(sqlRule.getName());
RuleNodeModel sqlNode = new RuleNodeModel();
sqlNode.setId("sql");
sqlNode.setExecutor("reactor-ql");
sqlNode.setConfiguration(Collections.singletonMap("sql", sqlRule.getSql()));
sqlNode.setName("SQL");
model.getNodes().add(sqlNode);
//错误处理
List<RuleLink> errorHandler = new ArrayList<>();
if (!CollectionUtils.isEmpty(sqlRule.getWhenErrorThen())) {
int index = 0;
for (Action act : sqlRule.getWhenErrorThen()) {
if (!StringUtils.hasText(act.getExecutor())) {
continue;
}
index++;
RuleNodeModel action = new RuleNodeModel();
action.setId("error:action:" + index);
action.setName("错误处理:" + index);
action.setExecutor(act.getExecutor());
action.setConfiguration(act.getConfiguration());
RuleLink link = new RuleLink();
link.setId(action.getId().concat(":").concat(action.getId()));
link.setName("错误处理:" + index);
link.setSource(sqlNode);
link.setType(RuleConstants.Event.error);
link.setTarget(action);
errorHandler.add(link);
model.getNodes().add(action);
}
}
sqlNode.getEvents().addAll(errorHandler);
//定时触发
if (sqlRule.getType() == SqlRuleType.timer) {
RuleNodeModel timerNode = new RuleNodeModel();
timerNode.setId("timer");
timerNode.setExecutor("timer");
timerNode.setName("定时触发");
timerNode.setConfiguration(Collections.singletonMap("cron", sqlRule.getCron()));
timerNode.setRuleId(model.getId());
RuleLink link = new RuleLink();
link.setId("sql:timer");
link.setName("定时触发SQL");
link.setSource(timerNode);
link.setTarget(sqlNode);
timerNode.getOutputs().add(link);
sqlNode.getInputs().add(link);
model.getNodes().add(timerNode);
}
if (!CollectionUtils.isEmpty(sqlRule.getActions())) {
int index = 0;
for (Action operation : sqlRule.getActions()) {
if (!StringUtils.hasText(operation.getExecutor())) {
continue;
}
index++;
RuleNodeModel action = new RuleNodeModel();
action.setId("action:" + index);
action.setName("执行动作:" + index);
action.setExecutor(operation.getExecutor());
action.setConfiguration(operation.getConfiguration());
RuleLink link = new RuleLink();
link.setId(action.getId().concat(":").concat(action.getId()));
link.setName("执行动作:" + index);
link.setSource(sqlNode);
link.setTarget(action);
model.getNodes().add(action);
action.getInputs().add(link);
sqlNode.getOutputs().add(link);
action.getEvents().addAll(errorHandler);
}
}
return model;
| 68
| 878
| 946
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/rule-engine-manager/src/main/java/org/jetlinks/community/rule/engine/scene/CompositeSceneFilter.java
|
CompositeSceneFilter
|
filter
|
class CompositeSceneFilter implements SceneFilter {
private final List<SceneFilter> filters;
@Override
public Mono<Boolean> filter(SceneData data) {<FILL_FUNCTION_BODY>}
}
|
if (CollectionUtils.isEmpty(filters)) {
return Reactors.ALWAYS_TRUE;
}
Mono<Boolean> handler = null;
for (SceneFilter filter : filters) {
if (handler == null) {
handler = filter.filter(data);
} else {
handler = BooleanUtils.and(handler, handler.filter(Boolean::booleanValue));
}
}
return handler;
| 60
| 111
| 171
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/rule-engine-manager/src/main/java/org/jetlinks/community/rule/engine/scene/SceneAction.java
|
SceneAction
|
toVariable
|
class SceneAction implements Serializable {
@Schema(description = "执行器类型")
@NotNull
private String executor;
@Schema(description = "执行器类型为[notify]时不能为空")
private NotifyAction notify;
@Schema(description = "执行器类型为[delay]时不能为空")
private DelayAction delay;
@Schema(description = "执行器类型为[device]时不能为空")
private DeviceAction device;
@Schema(description = "执行器类型为[alarm]时不能为空")
private AlarmAction alarm;
@Schema(description = "输出过滤条件,串行执行动作时,满足条件才会进入下一个节点")
private List<Term> terms;
@Schema(description = "其他执行器配置")
private Map<String, Object> configuration;
@Schema(description = "拓展信息")
private Map<String, Object> options;
/**
* 从拓展信息中获取需要查询的列,用于在设备触发等场景需要在sql中获取对应的数据.
*
* @param options 拓展信息
* @return terms
*/
public static List<String> parseColumnFromOptions(Map<String, Object> options) {
Object columns;
if (MapUtils.isEmpty(options) || (columns = options.get("columns")) == null) {
return Collections.emptyList();
}
//获取前端设置的columns
return ConverterUtils.convertToList(columns, String::valueOf);
}
/**
* 尝试从动作的变量中提取出需要动态获取的列信息
* @return 条件
*/
private List<String> parseActionTerms() {
return SceneProviders
.getActionProviderNow(executor)
.parseColumns(actionConfig());
}
public List<String> createContextColumns() {
List<String> termList = new ArrayList<>();
termList.addAll(parseColumnFromOptions(options));
termList.addAll(parseActionTerms());
return termList;
}
public Object actionConfig() {
switch (executor) {
case Executor.device:
return device;
case Executor.notify:
return notify;
case Executor.delay:
return delay;
case Executor.alarm:
return alarm;
default:
Object conf = SceneProviders.getActionProviderNow(executor).newConfig();
return configuration == null ? conf : FastBeanCopier.copy(configuration, conf);
}
}
public Flux<Variable> createVariables(Integer branchIndex,
Integer group,
int index) {
return SceneProviders
.getActionProviderNow(executor)
.createVariable(actionConfig())
.collectList()
.filter(CollectionUtils::isNotEmpty)
.map(list -> SceneAction.createVariable(branchIndex, group, index, list))
.flux()
.as(LocaleUtils::transform);
}
private static Variable createVariable(Integer branchIndex, Integer group, int actionIndex, List<Variable> children) {
String varId = "action_" + actionIndex;
if (branchIndex != null) {
varId = createBranchActionId(branchIndex, group, actionIndex);
}
String name = resolveMessage(
"message.action_var_index",
String.format("动作[%s]", actionIndex),
actionIndex
);
String fullName = resolveMessage(
"message.action_var_index_full",
String.format("动作[%s]输出", actionIndex),
actionIndex
);
String description = resolveMessage(
"message.action_var_output_description",
String.format("动作[%s]执行的输出结果", actionIndex),
actionIndex
);
Variable variable = Variable.of(varId, name);
variable.setFullName(fullName);
variable.setDescription(description);
variable.setChildren(children);
return variable;
}
public static SceneAction notify(String notifyType,
String notifierId,
String templateId,
Consumer<NotifyAction> consumer) {
SceneAction action = new SceneAction();
action.executor = Executor.notify;
action.notify = new NotifyAction();
action.notify.setNotifierId(notifierId);
action.notify.setNotifyType(notifyType);
action.notify.setTemplateId(templateId);
consumer.accept(action.notify);
return action;
}
public void applyNode(RuleNodeModel node) {
SceneProviders
.getActionProviderNow(executor)
.applyRuleNode(actionConfig(), node);
}
public static Variable toVariable(String prefix,
PropertyMetadata metadata,
String i18nKey,
String msgPattern) {
return toVariable(prefix.concat(".").concat(metadata.getId()),
metadata.getName(),
metadata.getValueType(),
i18nKey,
msgPattern,
null);
}
public static Variable toVariable(String id,
String metadataName,
DataType dataType,
String i18nKey,
String msgPattern,
String parentName) {<FILL_FUNCTION_BODY>}
public interface Executor {
String notify = NotifyActionProvider.PROVIDER;
String delay = DelayActionProvider.PROVIDER;
String device = DeviceActionProvider.PROVIDER;
String alarm = AlarmActionProvider.PROVIDER;
}
}
|
String fullName = parentName == null ? metadataName : parentName + "." + metadataName;
Variable variable = Variable.of(id, LocaleUtils.resolveMessage(i18nKey,
String.format(msgPattern, fullName),
fullName));
variable.setType(dataType.getType());
variable.setTermTypes(TermTypes.lookup(dataType));
variable.setColumn(id);
if (dataType instanceof ObjectType) {
List<Variable> children = new ArrayList<>();
for (PropertyMetadata property : ((ObjectType) dataType).getProperties()) {
children.add(
toVariable(id + "." + property.getId(),
property.getName(),
property.getValueType(),
i18nKey,
msgPattern,
fullName)
);
}
variable.setChildren(children);
}
return variable;
| 1,437
| 229
| 1,666
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/rule-engine-manager/src/main/java/org/jetlinks/community/rule/engine/scene/SceneActions.java
|
SceneActions
|
createContextColumns
|
class SceneActions implements Serializable {
@Schema(description = "是否并行执行动作")
private boolean parallel;
@Schema(description = "执行动作")
private List<SceneAction> actions;
//仅用于设置到reactQl sql的column中
public List<String> createContextColumns(){<FILL_FUNCTION_BODY>}
}
|
List<String> contextTerm = new ArrayList<>();
if (CollectionUtils.isNotEmpty(actions)){
for (SceneAction action : actions) {
contextTerm.addAll(action.createContextColumns());
}
}
return contextTerm;
| 95
| 68
| 163
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/rule-engine-manager/src/main/java/org/jetlinks/community/rule/engine/scene/SceneConditionAction.java
|
SceneConditionAction
|
createContextTerm
|
class SceneConditionAction implements Serializable {
/**
* @see org.jetlinks.community.rule.engine.scene.term.TermColumn
* @see org.jetlinks.community.reactorql.term.TermType
* @see org.jetlinks.community.rule.engine.scene.value.TermValue
*/
@Schema(description = "条件")
private List<Term> when;
@Schema(description = "防抖配置")
private ShakeLimit shakeLimit;
@Schema(description = "满足条件时执行的动作")
private List<SceneActions> then;
//仅用于设置到reactQl sql的column中
public List<Term> createContextTerm() {<FILL_FUNCTION_BODY>}
}
|
List<Term> contextTerm = new ArrayList<>();
if (CollectionUtils.isNotEmpty(then)) {
for (SceneActions sceneActions : then) {
contextTerm.addAll(sceneActions
.createContextColumns()
.stream()
.map(column -> {
Term term = new Term();
term.setColumn(column);
return term;
})
.collect(Collectors.toList()));
}
}
if (CollectionUtils.isNotEmpty(when)) {
contextTerm.addAll(when);
}
return contextTerm;
| 193
| 153
| 346
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/rule-engine-manager/src/main/java/org/jetlinks/community/rule/engine/scene/SceneProviders.java
|
SceneProviders
|
getTriggerProviderNow
|
class SceneProviders {
private static final Map<String, SceneActionProvider<?>> actionProviders = new ConcurrentHashMap<>();
private static final Map<String, SceneTriggerProvider<?>> triggerProviders = new ConcurrentHashMap<>();
public static void register(SceneActionProvider<?> provider) {
actionProviders.put(provider.getProvider(), provider);
}
public static void register(SceneTriggerProvider<?> provider) {
triggerProviders.put(provider.getProvider(), provider);
}
@SuppressWarnings("all")
public static <C> Optional<SceneActionProvider<C>> getActionProvider(String provider) {
return Optional.ofNullable((SceneActionProvider<C>) actionProviders.get(provider));
}
public static <C> SceneActionProvider<C> getActionProviderNow(String provider) {
return SceneProviders
.<C>getActionProvider(provider)
.orElseThrow(() -> new UnsupportedOperationException("unsupported SceneActionProvider:" + provider));
}
@SuppressWarnings("all")
public static <C extends SceneTriggerProvider.TriggerConfig> Optional<SceneTriggerProvider<C>> getTriggerProvider(String provider) {
return Optional.ofNullable((SceneTriggerProvider<C>) triggerProviders.get(provider));
}
public static <C extends SceneTriggerProvider.TriggerConfig> SceneTriggerProvider<C> getTriggerProviderNow(String provider) {<FILL_FUNCTION_BODY>}
@SuppressWarnings("all")
public static List<SceneTriggerProvider<SceneTriggerProvider.TriggerConfig>> triggerProviders() {
return (List) new ArrayList<>(triggerProviders.values());
}
public static List<SceneActionProvider<?>> actionProviders() {
return new ArrayList<>(actionProviders.values());
}
}
|
return SceneProviders
.<C>getTriggerProvider(provider)
.orElseThrow(() -> new UnsupportedOperationException("unsupported SceneTriggerProvider:" + provider));
| 490
| 50
| 540
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/rule-engine-manager/src/main/java/org/jetlinks/community/rule/engine/scene/SceneUtils.java
|
SceneUtils
|
columnToVariable
|
class SceneUtils {
public static String createColumnAlias(String prefix,String column, boolean wrapColumn) {
if (!column.contains(".")) {
return wrapColumn ? wrapColumnName(column) : column;
}
String[] arr = column.split("[.]");
String alias;
//prefix.temp.current
if (prefix.equals(arr[0])) {
String property = arr[1];
alias = property + "_" + arr[arr.length - 1];
} else {
if (arr.length > 1) {
alias = String.join("_", Arrays.copyOfRange(arr, 1, arr.length));
} else {
alias = column.replace(".", "_");
}
}
return wrapColumn ? wrapColumnName(alias) : alias;
}
public static String wrapColumnName(String column) {
if (column.startsWith("\"") && column.endsWith("\"")) {
return column;
}
return "\"" + (column.replace("\"", "\\\"")) + "\"";
}
/**
* 根据条件和可选的条件列解析出将要输出的变量信息
*
* @param terms 条件
* @param columns 列信息
* @return 变量信息
*/
public static List<Variable> parseVariable(List<Term> terms,
List<TermColumn> columns) {
//平铺条件
Map<String, Term> termCache = expandTerm(terms);
//解析变量
List<Variable> variables = new ArrayList<>(termCache.size());
for (TermColumn column : columns) {
variables.addAll(columnToVariable(null, column, termCache::get));
}
return variables;
}
public static Map<String, Term> expandTerm(List<Term> terms) {
Map<String, Term> termCache = new LinkedHashMap<>();
expandTerm(terms, termCache);
return termCache;
}
private static void expandTerm(List<Term> terms, Map<String, Term> container) {
if (terms == null) {
return;
}
for (Term term : terms) {
if (StringUtils.hasText(term.getColumn())) {
container.put(term.getColumn(), term);
}
if (term.getTerms() != null) {
expandTerm(term.getTerms(), container);
}
}
}
private static List<Variable> columnToVariable(String prefixName,
TermColumn column,
Function<String, Term> termSupplier) {<FILL_FUNCTION_BODY>}
}
|
List<Variable> variables = new ArrayList<>(1);
String variableName = column.getName(); //prefixName == null ? column.getName() : prefixName + "/" + column.getName();
if (CollectionUtils.isEmpty(column.getChildren())) {
Term term = termSupplier.apply(column.getColumn());
variables.add(Variable.of(column.getVariable("_"), variableName)
.with(column)
);
if (term != null) {
List<TermValue> termValues = TermValue.of(term);
String property = column.getPropertyOrNull();
for (TermValue termValue : termValues) {
PropertyMetric metric = column.getMetricOrNull(termValue.getMetric());
if (property != null && metric != null && termValue.getSource() == TermValue.Source.metric) {
// temp_metric
variables.add(Variable.of(
property + "_metric_" + termValue.getMetric(),
(prefixName == null ? column.getName() : prefixName) + "_指标_" + metric.getName())
.withTermType(column.getTermTypes())
.withColumn(column.getColumn())
.withMetadata(column.isMetadata())
);
}
}
}
} else {
Variable variable = Variable.of(column.getColumn(), column.getName());
List<Variable> children = new ArrayList<>();
variable.setChildren(children);
variable.with(column);
variables.add(variable);
for (TermColumn child : column.getChildren()) {
children.addAll(columnToVariable(column.getName(), child, termSupplier));
}
}
return variables;
| 678
| 431
| 1,109
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/rule-engine-manager/src/main/java/org/jetlinks/community/rule/engine/scene/Trigger.java
|
Trigger
|
triggerConfig
|
class Trigger implements Serializable {
private static final long serialVersionUID = 1L;
@Schema(description = "触发方式")
@NotNull(message = "error.scene_rule_trigger_cannot_be_null")
private String type;
@Schema(description = "防抖配置")
private GroupShakeLimit shakeLimit;
@Schema(description = "[type]为[device]时不能为空")
private DeviceTrigger device;
@Schema(description = "[type]为[timer]时不能为空")
private TimerTrigger timer;
@Schema(description = "[type]不为[device,timer,collector]时不能为控")
private Map<String, Object> configuration;
public String getTypeName(){
return provider().getName();
}
/**
* 重构查询条件,替换为实际将要输出的变量.
*
* @param terms 条件
* @return 重构后的条件
* @see DeviceTrigger#refactorTermValue(String, Term)
*/
public List<Term> refactorTerm(String tableName, List<Term> terms) {
if (CollectionUtils.isEmpty(terms)) {
return terms;
}
List<Term> target = new ArrayList<>(terms.size());
for (Term term : terms) {
Term copy = term.clone();
target.add(DeviceTrigger.refactorTermValue(tableName, copy));
if (org.apache.commons.collections4.CollectionUtils.isNotEmpty(copy.getTerms())) {
copy.setTerms(refactorTerm(tableName, copy.getTerms()));
}
}
return target;
}
public SqlRequest createSql(List<Term> terms, boolean hasWhere) {
SceneTriggerProvider.TriggerConfig config = triggerConfig();
return config == null ? EmptySqlRequest.INSTANCE : provider().createSql(config, terms, hasWhere);
}
public SqlFragments createFilter(List<Term> terms) {
SceneTriggerProvider.TriggerConfig config = triggerConfig();
return config == null ? EmptySqlFragments.INSTANCE : provider().createFilter(config, terms);
}
public Flux<TermColumn> parseTermColumns() {
SceneTriggerProvider.TriggerConfig config = triggerConfig();
return config == null ? Flux.empty() : provider().parseTermColumns(config);
}
public SceneTriggerProvider.TriggerConfig triggerConfig() {<FILL_FUNCTION_BODY>}
private SceneTriggerProvider<SceneTriggerProvider.TriggerConfig> provider() {
return SceneProviders.getTriggerProviderNow(type);
}
public void validate() {
Assert.notNull(type, "error.scene_rule_trigger_cannot_be_null");
triggerConfig().validate();
}
public List<Variable> createDefaultVariable() {
return provider().createDefaultVariable(triggerConfig());
}
public static Trigger device(DeviceTrigger device) {
Trigger trigger = new Trigger();
trigger.setType(DeviceTriggerProvider.PROVIDER);
trigger.setDevice(device);
return trigger;
}
public static Trigger manual() {
Trigger trigger = new Trigger();
trigger.setType(ManualTriggerProvider.PROVIDER);
return trigger;
}
@Getter
@Setter
public static class GroupShakeLimit extends ShakeLimit {
//暂时没有实现其他方式
@Schema(description = "分组类型:device,product,org...")
@Hidden
private String groupType;
public ShakeLimitGrouping<Map<String, Object>> createGrouping() {
//todo 其他分组方式实现
return flux -> flux
.groupBy(map -> map.getOrDefault("deviceId", "null"), Integer.MAX_VALUE);
}
}
void applyModel(RuleModel model, RuleNodeModel sceneNode) {
provider().applyRuleNode(triggerConfig(), model, sceneNode);
}
}
|
switch (type) {
case DeviceTriggerProvider.PROVIDER:
return device;
case TimerTriggerProvider.PROVIDER:
return timer;
default:
SceneTriggerProvider.TriggerConfig config = provider().newConfig();
if (configuration != null) {
config.with(configuration);
}
return config;
}
| 1,039
| 96
| 1,135
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/rule-engine-manager/src/main/java/org/jetlinks/community/rule/engine/scene/Variable.java
|
Variable
|
safeOptions
|
class Variable {
public static final String OPTION_PRODUCT_ID = "productId";
@Schema(description = "变量ID")
private String id;
@Schema(description = "变量名")
private String name;
@Schema(description = "变量全名")
private String fullName;
@Schema(description = "列")
private String column;
@Schema(description = "说明")
private String description;
@Schema(description = "类型")
private String type;
/**
* @see Term#getTermType()
*/
@Schema(description = "支持的条件类型")
private List<TermType> termTypes;
@Schema(description = "子级变量")
private List<Variable> children;
@Schema(description = "是否为物模型变量")
private boolean metadata;
@Schema(description = "其他配置")
private Map<String, Object> options;
public String getFullName() {
return fullName == null ? name : fullName;
}
public Variable withDescription(String description) {
this.description = description;
return this;
}
public Variable withMetadata(boolean metadata) {
this.metadata = metadata;
return this;
}
public synchronized Map<String, Object> safeOptions() {<FILL_FUNCTION_BODY>}
public Variable withOption(String key, Object value) {
safeOptions().put(key, value);
return this;
}
public Variable withOptions(Map<String, Object> options) {
safeOptions().putAll(options);
return this;
}
public Variable withType(String type) {
this.type = type;
return this;
}
public Variable withType(DataType type) {
withType(type.getId())
.withTermType(TermTypes.lookup(type));
return this;
}
public Variable withTermType(List<TermType> termTypes) {
this.termTypes = termTypes;
return this;
}
public Variable withColumn(String column) {
this.column = column;
return this;
}
public String getColumn() {
if (StringUtils.hasText(column)) {
return column;
}
return id;
}
public Variable with(TermColumn column) {
this.name = column.getName();
this.column = column.getColumn();
this.metadata = column.isMetadata();
this.description = column.getDescription();
this.fullName = column.getFullName();
this.type = column.getDataType();
this.termTypes = column.getTermTypes();
return this;
}
public void refactorPrefix() {
refactorPrefix(this);
}
public void refactorPrefix(Variable main) {
if (CollectionUtils.isNotEmpty(children)) {
for (Variable child : children) {
if (!child.getId().startsWith(main.id + ".")) {
child.setId(main.id + "." + child.getId());
}
if (StringUtils.hasText(child.getFullName())
&& StringUtils.hasText(main.getFullName())) {
child.setFullName(main.getFullName() + "/" + child.getFullName());
}
child.refactorPrefix(main);
}
}
}
private Variable(String id, String name) {
this.id = id;
this.name = name;
this.description = name;
this.type = StringType.ID;
}
public Variable() {
}
public static Variable of(String id, String name) {
return new Variable(id, name);
}
}
|
return options == null ? options = new HashMap<>() : options;
| 985
| 20
| 1,005
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/rule-engine-manager/src/main/java/org/jetlinks/community/rule/engine/scene/internal/actions/AlarmAction.java
|
AlarmAction
|
createVariables
|
class AlarmAction extends AlarmTaskExecutorProvider.Config {
public List<Variable> createVariables() {<FILL_FUNCTION_BODY>}
}
|
List<Variable> variables = new ArrayList<>();
variables.add(
Variable.of(AlarmConstants.ConfigKey.alarmName,
LocaleUtils.resolveMessage("message.alarm_config_name", "告警配置名称"))
.withType(StringType.GLOBAL)
);
variables.add(
Variable.of(AlarmConstants.ConfigKey.level,
LocaleUtils.resolveMessage("message.alarm_level", "告警级别"))
.withType(IntType.GLOBAL)
);
// variables.add(
// Variable.of(AlarmConstants.ConfigKey.alarming,
// LocaleUtils.resolveMessage("message.is_alarming", "是否重复告警"))
// .withDescription(LocaleUtils.resolveMessage("message.is_alarming_description", "是否已存在告警中的记录"))
// .withType(BooleanType.GLOBAL)
// );
variables.add(
Variable.of(AlarmConstants.ConfigKey.firstAlarm,
LocaleUtils.resolveMessage("message.first_alarm", "是否首次告警"))
.withDescription(LocaleUtils.resolveMessage("message.first_alarm_description", "是否为首次告警或者解除后的第一次告警"))
.withType(BooleanType.GLOBAL)
.withOption("bool", BooleanType.GLOBAL)
);
variables.add(
Variable.of(AlarmConstants.ConfigKey.alarmTime,
LocaleUtils.resolveMessage("message.alarm_time", "首次告警时间"))
.withDescription(LocaleUtils.resolveMessage("message.alarm_time_description", "首次告警或者解除告警后的第一次告警时间"))
.withType(DateTimeType.GLOBAL)
);
variables.add(
Variable.of(AlarmConstants.ConfigKey.lastAlarmTime,
LocaleUtils.resolveMessage("message.last_alarm_time", "上一次告警时间"))
.withDescription(LocaleUtils.resolveMessage("message.last_alarm_time_description", "上一次触发告警的时间"))
.withType(DateTimeType.GLOBAL)
);
return variables;
| 41
| 561
| 602
|
<methods>public non-sealed void <init>() <variables>private @NotNull AlarmMode mode
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/rule-engine-manager/src/main/java/org/jetlinks/community/rule/engine/scene/internal/actions/DelayActionProvider.java
|
DelayActionProvider
|
applyRuleNode
|
class DelayActionProvider implements SceneActionProvider<DelayAction> {
public static final String PROVIDER = "delay";
@Override
public String getProvider() {
return PROVIDER;
}
@Override
public DelayAction newConfig() {
return new DelayAction();
}
@Override
public List<String> parseColumns(DelayAction config) {
return Collections.emptyList();
}
@Override
public Flux<Variable> createVariable(DelayAction config) {
return Flux.empty();
}
@Override
public void applyRuleNode(DelayAction delay, RuleNodeModel model) {<FILL_FUNCTION_BODY>}
}
|
DelayTaskExecutorProvider.DelayTaskExecutorConfig config = new DelayTaskExecutorProvider.DelayTaskExecutorConfig();
config.setPauseType(DelayTaskExecutorProvider.PauseType.delay);
config.setTimeout(delay.getTime());
config.setTimeoutUnits(delay.getUnit().chronoUnit);
model.setExecutor(DelayTaskExecutorProvider.EXECUTOR);
model.setConfiguration(FastBeanCopier.copy(config, new HashMap<>()));
| 180
| 119
| 299
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/rule-engine-manager/src/main/java/org/jetlinks/community/rule/engine/scene/internal/actions/DeviceAction.java
|
DeviceAction
|
createVariables
|
class DeviceAction extends DeviceSelectorSpec {
@Schema(description = "产品ID")
private String productId;
/**
* @see FunctionInvokeMessage
* @see ReadPropertyMessage
* @see WritePropertyMessage
*/
@Schema(description = "设备指令")
private Map<String, Object> message;
public List<Variable> createVariables(ThingMetadata metadata) {<FILL_FUNCTION_BODY>}
public List<String> parseColumns() {
if (MapUtils.isEmpty(message)) {
return Collections.emptyList();
}
DeviceMessage msg = (DeviceMessage) MessageType.convertMessage(message).orElse(null);
Collection<Object> readyToParse;
if (msg instanceof WritePropertyMessage) {
readyToParse = ((WritePropertyMessage) msg).getProperties().values();
} else if (msg instanceof FunctionInvokeMessage) {
readyToParse = Lists.transform(((FunctionInvokeMessage) msg).getInputs(), FunctionParameter::getValue);
} else {
return Collections.emptyList();
}
return readyToParse
.stream()
.flatMap(val -> parseColumnFromOptions(VariableSource.of(val).getOptions()).stream())
.collect(Collectors.toList());
}
}
|
DeviceMessage message = MessageType
.convertMessage(this.message)
.filter(DeviceMessage.class::isInstance)
.map(DeviceMessage.class::cast)
.orElse(null);
if (message == null) {
return Collections.emptyList();
}
List<Variable> variables = new ArrayList<>();
//下发指令是否成功
variables.add(Variable
.of("success",
resolveMessage(
"message.action_execute_success",
"执行是否成功"
))
.withType(BooleanType.ID)
.withOption("bool", BooleanType.GLOBAL)
.withTermType(TermTypes.lookup(BooleanType.GLOBAL))
);
//设备ID
variables.add(Variable
.of("deviceId",
resolveMessage(
"message.device_id",
"设备ID"
))
.withType(StringType.ID)
//标识变量属于哪个产品
.withOption(Variable.OPTION_PRODUCT_ID, productId)
.withTermType(TermTypes.lookup(StringType.GLOBAL))
);
if (message instanceof ReadPropertyMessage) {
List<String> properties = ((ReadPropertyMessage) message).getProperties();
for (String property : properties) {
PropertyMetadata metadata_ = metadata.getPropertyOrNull(property);
if (null != metadata_) {
variables.add(toVariable("properties",
metadata_,
"message.action_var_read_property",
"读取属性[%s]返回值"));
}
}
} else if (message instanceof WritePropertyMessage) {
Map<String, Object> properties = ((WritePropertyMessage) message).getProperties();
for (String property : properties.keySet()) {
PropertyMetadata metadata_ = metadata
.getPropertyOrNull(property);
if (null != metadata_) {
variables.add(toVariable("properties",
metadata_,
"message.action_var_write_property",
"设置属性[%s]返回值"));
}
}
} else if (message instanceof FunctionInvokeMessage) {
String functionId = ((FunctionInvokeMessage) message).getFunctionId();
FunctionMetadata metadata_ = metadata
.getFunctionOrNull(functionId);
if (null != metadata_
&& metadata_.getOutput() != null
&& !(metadata_.getOutput() instanceof UnknownType)
&& !metadata_.isAsync()) {
variables.add(toVariable("output",
metadata_.getName(),
metadata_.getOutput(),
"message.action_var_function",
"功能调用[%s]返回值",
null));
}
}
return variables;
| 328
| 695
| 1,023
|
<methods>public void <init>() ,public Mono<org.jetlinks.core.things.ThingMetadata> getDeviceMetadata(org.jetlinks.core.things.ThingsRegistry, java.lang.String) ,public java.lang.Object getValue() ,public Flux<java.lang.Object> resolveSelectorValues(Map<java.lang.String,java.lang.Object>) ,public static org.jetlinks.community.rule.engine.executor.device.DeviceSelectorSpec selector(@NotNull String, List<org.jetlinks.community.rule.engine.executor.device.SelectorValue>) ,public void validate() <variables>private @NotBlank String selector,private List<org.jetlinks.community.rule.engine.executor.device.SelectorValue> selectorValues
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/rule-engine-manager/src/main/java/org/jetlinks/community/rule/engine/scene/internal/actions/DeviceActionProvider.java
|
DeviceActionProvider
|
applyRuleNode
|
class DeviceActionProvider implements SceneActionProvider<DeviceAction> {
public static final String PROVIDER = "device";
private final ThingsRegistry registry;
@Override
public String getProvider() {
return DeviceActionProvider.PROVIDER;
}
@Override
public DeviceAction newConfig() {
return new DeviceAction();
}
@Override
public List<String> parseColumns(DeviceAction config) {
return config.parseColumns();
}
@Override
public Flux<Variable> createVariable(DeviceAction config) {
return config
.getDeviceMetadata(registry, config.getProductId())
.as(LocaleUtils::transform)
.flatMapIterable(config::createVariables);
}
@Override
public void applyRuleNode(DeviceAction device, RuleNodeModel model) {<FILL_FUNCTION_BODY>}
}
|
DeviceMessageSendTaskExecutorProvider.DeviceMessageSendConfig config = new DeviceMessageSendTaskExecutorProvider.DeviceMessageSendConfig();
config.setMessage(device.getMessage());
if (DeviceSelectorProviders.isFixed(device)) {
config.setSelectorSpec(FastBeanCopier.copy(device, new DeviceSelectorSpec()));
} else {
config.setSelectorSpec(
DeviceSelectorProviders.composite(
//先选择产品下的设备
DeviceSelectorProviders.product(device.getProductId()),
FastBeanCopier.copy(device, new DeviceSelectorSpec())
));
}
config.setFrom("fixed");
config.setStateOperator("direct");
config.setProductId(device.getProductId());
model.setExecutor(DeviceMessageSendTaskExecutorProvider.EXECUTOR);
model.setConfiguration(config.toMap());
| 226
| 218
| 444
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/rule-engine-manager/src/main/java/org/jetlinks/community/rule/engine/scene/internal/actions/NotifyAction.java
|
NotifyAction
|
parseColumns
|
class NotifyAction implements Serializable {
@Schema(description = "通知类型")
@NotBlank(message = "error.scene_rule_actions_notify_type_cannot_be_empty")
private String notifyType;
@Schema(description = "通知配置ID")
@NotBlank(message = "error.scene_rule_actions_notify_id_cannot_be_empty")
private String notifierId;
@Schema(description = "通知模版ID")
@NotBlank(message = "error.scene_rule_actions_notify_template_cannot_be_blank")
private String templateId;
/**
* 变量值的格式可以为{@link VariableSource}
*/
@Schema(description = "通知变量")
@NotBlank(message = "error.scene_rule_actions_notify_variables_cannot_be_blank")
private Map<String, Object> variables;
public List<String> parseColumns() {<FILL_FUNCTION_BODY>}
}
|
if (MapUtils.isEmpty(variables)) {
return Collections.emptyList();
}
return variables
.values()
.stream()
.flatMap(val -> parseColumnFromOptions(VariableSource.of(val).getOptions()).stream())
.collect(Collectors.toList());
| 262
| 79
| 341
|
<no_super_class>
|
jetlinks_jetlinks-community
|
jetlinks-community/jetlinks-manager/rule-engine-manager/src/main/java/org/jetlinks/community/rule/engine/scene/internal/actions/NotifyActionProvider.java
|
NotifyActionProvider
|
applyRuleNode
|
class NotifyActionProvider implements SceneActionProvider<NotifyAction> {
public static final String PROVIDER = "notify";
@Override
public String getProvider() {
return PROVIDER;
}
@Override
public NotifyAction newConfig() {
return new NotifyAction();
}
@Override
public List<String> parseColumns(NotifyAction config) {
return config.parseColumns();
}
@Override
public Flux<Variable> createVariable(NotifyAction config) {
return Flux.empty();
}
@Override
public void applyRuleNode(NotifyAction notify, RuleNodeModel model) {<FILL_FUNCTION_BODY>}
}
|
model.setExecutor("notifier");
Map<String, Object> config = new HashMap<>();
config.put("notifyType", notify.getNotifyType());
config.put("notifierId", notify.getNotifierId());
config.put("templateId", notify.getTemplateId());
config.put("variables", notify.getVariables());
model.setConfiguration(config);
| 181
| 100
| 281
|
<no_super_class>
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.