code
stringlengths 1
1.05M
| repo_name
stringlengths 6
83
| path
stringlengths 3
242
| language
stringclasses 222
values | license
stringclasses 20
values | size
int64 1
1.05M
|
|---|---|---|---|---|---|
package com.zmops.iot.web.event.applicationEvent;
import org.springframework.context.ApplicationEvent;
/**
* @author yefei
**/
public abstract class BaseEvent<T> extends ApplicationEvent {
private T eventData;
public BaseEvent(Object source, T eventData) {
super(source);
this.eventData = eventData;
}
public T getEventData() {
return eventData;
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/event/applicationEvent/BaseEvent.java
|
Java
|
gpl-3.0
| 401
|
package com.zmops.iot.web.event.applicationEvent;
import com.zmops.iot.web.event.applicationEvent.dto.DeviceDeleteEventData;
/**
* @author yefei
**/
public class DeviceDeleteEvent extends BaseEvent<DeviceDeleteEventData> {
public DeviceDeleteEvent(Object source, DeviceDeleteEventData eventData) {
super(source, eventData);
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/event/applicationEvent/DeviceDeleteEvent.java
|
Java
|
gpl-3.0
| 348
|
package com.zmops.iot.web.event.applicationEvent;
import com.zmops.iot.web.device.dto.DeviceDto;
/**
* @author yefei
**/
public class DeviceSaveEvent extends BaseEvent<DeviceDto> {
public DeviceSaveEvent(Object source, DeviceDto eventData) {
super(source, eventData);
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/event/applicationEvent/DeviceSaveEvent.java
|
Java
|
gpl-3.0
| 292
|
package com.zmops.iot.web.event.applicationEvent;
import com.zmops.iot.web.event.applicationEvent.dto.LogEventData;
/**
* @author yefei
**/
public class DeviceSceneLogEvent extends BaseEvent<LogEventData> {
public DeviceSceneLogEvent(Object source, LogEventData eventData) {
super(source, eventData);
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/event/applicationEvent/DeviceSceneLogEvent.java
|
Java
|
gpl-3.0
| 325
|
package com.zmops.iot.web.event.applicationEvent;
import com.zmops.iot.web.event.applicationEvent.dto.LogEventData;
/**
* @author yefei
**/
public class DeviceServiceLogEvent extends BaseEvent<LogEventData> {
public DeviceServiceLogEvent(Object source, LogEventData eventData) {
super(source, eventData);
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/event/applicationEvent/DeviceServiceLogEvent.java
|
Java
|
gpl-3.0
| 329
|
package com.zmops.iot.web.event.applicationEvent;
import com.zmops.iot.web.product.dto.ProductAttr;
/**
* @author yefei
**/
public class ProductAttrCreateEvent extends BaseEvent<ProductAttr> {
public ProductAttrCreateEvent(Object source, ProductAttr eventData) {
super(source, eventData);
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/event/applicationEvent/ProductAttrCreateEvent.java
|
Java
|
gpl-3.0
| 313
|
package com.zmops.iot.web.event.applicationEvent;
import com.zmops.iot.web.product.dto.ProductAttr;
/**
* @author yefei
**/
public class ProductAttrUpdateEvent extends BaseEvent<ProductAttr> {
public ProductAttrUpdateEvent(Object source, ProductAttr eventData) {
super(source, eventData);
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/event/applicationEvent/ProductAttrUpdateEvent.java
|
Java
|
gpl-3.0
| 313
|
package com.zmops.iot.web.event.applicationEvent;
import com.zmops.iot.web.product.dto.ProductEventRule;
/**
* @author yefei
**/
public class ProductEventTriggerCreateEvent extends BaseEvent<ProductEventRule> {
public ProductEventTriggerCreateEvent(Object source, ProductEventRule eventData) {
super(source, eventData);
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/event/applicationEvent/ProductEventTriggerCreateEvent.java
|
Java
|
gpl-3.0
| 344
|
package com.zmops.iot.web.event.applicationEvent;
import com.zmops.iot.web.product.dto.ProductEventRule;
/**
* @author yefei
**/
public class ProductEventTriggerUpdateEvent extends BaseEvent<ProductEventRule> {
public ProductEventTriggerUpdateEvent(Object source, ProductEventRule eventData) {
super(source, eventData);
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/event/applicationEvent/ProductEventTriggerUpdateEvent.java
|
Java
|
gpl-3.0
| 344
|
package com.zmops.iot.web.event.applicationEvent;
import com.zmops.iot.web.product.dto.ProductAttr;
/**
* @author yefei
**/
public class ProductModelCreateEvent extends BaseEvent<ProductAttr> {
public ProductModelCreateEvent(Object source, ProductAttr eventData) {
super(source, eventData);
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/event/applicationEvent/ProductModelCreateEvent.java
|
Java
|
gpl-3.0
| 315
|
package com.zmops.iot.web.event.applicationEvent;
import com.zmops.iot.web.product.dto.ProductAttr;
/**
* @author yefei
**/
public class ProductModelUpdateEvent extends BaseEvent<ProductAttr> {
public ProductModelUpdateEvent(Object source, ProductAttr eventData) {
super(source, eventData);
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/event/applicationEvent/ProductModelUpdateEvent.java
|
Java
|
gpl-3.0
| 315
|
package com.zmops.iot.web.event.applicationEvent;
import com.zmops.iot.web.product.dto.ProductServiceDto;
/**
* @author yefei
**/
public class ProductServiceCreateEvent extends BaseEvent<ProductServiceDto> {
public ProductServiceCreateEvent(Object source, ProductServiceDto eventData) {
super(source, eventData);
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/event/applicationEvent/ProductServiceCreateEvent.java
|
Java
|
gpl-3.0
| 337
|
package com.zmops.iot.web.event.applicationEvent;
import com.zmops.iot.web.product.dto.ProductServiceDto;
/**
* @author yefei
**/
public class ProductServiceUpdateEvent extends BaseEvent<ProductServiceDto> {
public ProductServiceUpdateEvent(Object source, ProductServiceDto eventData) {
super(source, eventData);
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/event/applicationEvent/ProductServiceUpdateEvent.java
|
Java
|
gpl-3.0
| 337
|
package com.zmops.iot.web.event.applicationEvent;
import com.zmops.iot.web.event.applicationEvent.dto.SceneEventData;
/**
* @author yefei
**/
public class SceneEvent extends BaseEvent<SceneEventData> {
public SceneEvent(Object source, SceneEventData eventData) {
super(source, eventData);
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/event/applicationEvent/SceneEvent.java
|
Java
|
gpl-3.0
| 313
|
package com.zmops.iot.web.event.applicationEvent.dto;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class DeviceDeleteEventData {
private String deviceId;
private String zbxId;
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/event/applicationEvent/dto/DeviceDeleteEventData.java
|
Java
|
gpl-3.0
| 314
|
package com.zmops.iot.web.event.applicationEvent.dto;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* @author yefei
**/
@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
public class LogEventData {
private Long eventRuleId;
private String relationId;
private String triggerType;
private Long triggerUser;
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/event/applicationEvent/dto/LogEventData.java
|
Java
|
gpl-3.0
| 401
|
package com.zmops.iot.web.event.applicationEvent.dto;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* @author yefei
**/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class SceneEventData {
private String executeParam;
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/event/applicationEvent/dto/SceneEventData.java
|
Java
|
gpl-3.0
| 281
|
package com.zmops.iot.web.event.pgEvent;
import com.alibaba.fastjson.JSONObject;
import com.zmops.iot.web.event.pgEvent.dto.EventDataDto;
import lombok.extern.slf4j.Slf4j;
import org.apache.camel.Exchange;
import org.apache.camel.Processor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.Collection;
/**
* @author yefei
**/
@Slf4j
@Component(value = "EventDataProcess")
public class EventDataProcess implements Processor {
@Autowired
Collection<EventProcess> eventProcessList;
@Override
public void process(Exchange exchange) throws Exception {
String inputContext = exchange.getIn().getBody().toString();
String[] split = inputContext.split("\\$\\$");
if (split.length != 2) {
return;
}
EventDataDto eventData = JSONObject.parseObject(split[1], EventDataDto.class);
eventProcessList.forEach(eventProcess -> {
if(eventProcess.checkTag(eventData.getTag())){
eventProcess.process(eventData);
}
});
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/event/pgEvent/EventDataProcess.java
|
Java
|
gpl-3.0
| 1,121
|
package com.zmops.iot.web.event.pgEvent;
import com.zmops.iot.web.event.pgEvent.dto.EventDataDto;
/**
* @author yefei
**/
public interface EventProcess {
void process(EventDataDto eventData);
boolean checkTag(String tag);
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/event/pgEvent/EventProcess.java
|
Java
|
gpl-3.0
| 238
|
package com.zmops.iot.web.event.pgEvent;
import com.zmops.iot.util.SpringUtils;
import org.apache.camel.LoggingLevel;
import org.apache.camel.builder.RouteBuilder;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import java.util.Optional;
/**
* @author yefei
**/
@Component
public class SyncZbxEvent extends RouteBuilder {
@Value("${spring.datasource.druid.url}")
private String url;
@Value("${spring.datasource.druid.username}")
private String username;
@Value("${spring.datasource.druid.password}")
private String password;
@Override
public void configure() throws Exception {
url = url.substring(url.indexOf("//") + 2);
String host = url.substring(0, url.indexOf(":"));
int port = Optional.of(url.substring(url.indexOf(":") + 1, url.indexOf("/"))).map(Integer::parseInt).orElse(5432);
fromF("pgevent:%s:%d/zabbix/zabbix_pg_event?pass=%s&user=%s", host, port, password, username)
.process(SpringUtils.getBean(EventDataProcess.class))
.log(LoggingLevel.DEBUG, log, ">>> PgEvent received from Zabbix Events : ${body}");
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/event/pgEvent/SyncZbxEvent.java
|
Java
|
gpl-3.0
| 1,194
|
package com.zmops.iot.web.event.pgEvent.dto;
import lombok.Data;
/**
* @author yefei
**/
@Data
public class EventDataDto {
private String eventid;
private String objectid;
private String name;
private String tag;
private String tagValue;
private String recoveryValue;
private Integer acknowledged;
private Integer clock;
private Integer rClock;
private Integer severity;
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/event/pgEvent/dto/EventDataDto.java
|
Java
|
gpl-3.0
| 426
|
package com.zmops.iot.web.event.pgEvent.service;
import com.zmops.iot.domain.alarm.Problem;
import com.zmops.iot.domain.device.query.QDevice;
import com.zmops.iot.domain.messages.MessageBody;
import com.zmops.iot.domain.messages.NoticeRecord;
import com.zmops.iot.domain.messages.NoticeResult;
import com.zmops.iot.domain.product.ProductEvent;
import com.zmops.iot.domain.product.query.QProductEvent;
import com.zmops.iot.domain.product.query.QProductEventRelation;
import com.zmops.iot.domain.sys.SysUser;
import com.zmops.iot.domain.sys.query.QSysUser;
import com.zmops.iot.media.NoticeService;
import com.zmops.iot.util.DefinitionsUtil;
import com.zmops.iot.util.LocalDateTimeUtils;
import com.zmops.iot.util.ToolUtil;
import com.zmops.iot.web.alarm.service.AlarmService;
import com.zmops.iot.web.alarm.service.MessageService;
import com.zmops.iot.web.event.pgEvent.EventProcess;
import com.zmops.iot.web.event.pgEvent.dto.EventDataDto;
import com.zmops.iot.web.sys.dto.UserGroupDto;
import io.ebean.DB;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Collectors;
/**
* @author yefei
**/
@Slf4j
@Component
public class AlarmEventProcess implements EventProcess {
@Autowired
MessageService messageService;
@Autowired
AlarmService alarmService;
@Autowired
NoticeService noticeService;
@Override
public void process(EventDataDto eventData) {
String triggerId = eventData.getObjectid();
String triggerName = eventData.getName();
log.debug("--------alarm event----------{}", triggerId);
//step 1:插入problem
boolean isNew = true;
Problem problem = new Problem();
problem.setEventId(Long.parseLong(eventData.getEventid()));
problem.setObjectId(Long.parseLong(eventData.getObjectid()));
problem.setAcknowledged(eventData.getAcknowledged());
problem.setSeverity(eventData.getSeverity());
problem.setName(DefinitionsUtil.getTriggerName(Long.parseLong(eventData.getName())));
problem.setDeviceId(eventData.getTagValue());
problem.setClock(LocalDateTimeUtils.getLDTBySeconds(eventData.getClock()));
problem.setRClock(eventData.getRClock() == 0 ? null : LocalDateTimeUtils.getLDTBySeconds(eventData.getRClock()));
if (eventData.getRClock() == 0 && eventData.getAcknowledged() == 0) {
DB.insert(problem);
} else {
DB.update(problem);
isNew = false;
}
//step 2:找出需要通知的用户ID 推送通知
List<String> deviceIds = new QProductEventRelation().select(QProductEventRelation.alias().relationId).zbxId.eq(triggerId).findSingleAttributeList();
if (ToolUtil.isEmpty(deviceIds)) {
return;
}
Map<String, Object> params = new ConcurrentHashMap<>(2);
params.put("hostname", deviceIds);
params.put("triggerName", triggerName);
List<Long> tenantIds = new QDevice().select(QDevice.alias().tenantId).deviceId.in(deviceIds).tenantId.isNotNull().findSingleAttributeList();
String sql = "select user_group_id from sys_usrgrp_devicegrp where device_group_id in (select device_group_id from devices_groups where device_id in (:deviceIds))";
List<UserGroupDto> userGroups = DB.findDto(UserGroupDto.class, sql).setParameter("deviceIds", deviceIds).findList();
QSysUser qSysUser = new QSysUser();
if (ToolUtil.isNotEmpty(userGroups)) {
qSysUser.userGroupId.in(userGroups.parallelStream().map(UserGroupDto::getUserGroupId).collect(Collectors.toList()));
}
if (!CollectionUtils.isEmpty(tenantIds)) {
qSysUser.tenantId.in(tenantIds);
}
List<SysUser> sysUserList = qSysUser.findList();
List<Long> userIds = sysUserList.parallelStream().map(SysUser::getUserId).collect(Collectors.toList());
alarmService.alarm(params);
//发送Email消息
ProductEvent productEvent = new QProductEvent().eventRuleId.eq(Long.parseLong(triggerName)).findOne();
Map<String, String> macros = createMacroMap(triggerId, eventData.getRClock() + "", eventData.getAcknowledged() + "", productEvent);
messageService.push(buildMessage(macros, userIds, isNew));
List<NoticeRecord> noticeRecords = new ArrayList<>();
sysUserList.forEach(sysUser -> {
Map<Integer, NoticeResult> notice = noticeService.notice(sysUser, macros, triggerId);
for (Map.Entry<Integer, NoticeResult> en : notice.entrySet()) {
noticeRecords.add(NoticeRecord.builder()
.userId(sysUser.getUserId())
.problemId(triggerId)
.noticeType(en.getKey())
.noticeStatus(en.getValue().getStatus().name())
.noticeMsg(en.getValue().getMsg())
.creatTime(LocalDateTime.now())
.alarmInfo(en.getValue().getAlarmInfo())
.receiveAccount(en.getValue().getReceiveAccount())
.build());
}
});
DB.saveAll(noticeRecords);
}
private Map<String, String> createMacroMap(String triggerId, String rclock, String acknowledged, ProductEvent productEvent) {
boolean isnew = "0".equals(rclock);
Map<String, String> macroMap = new HashMap<String, String>();
macroMap.put("${time}", LocalDateTimeUtils.formatTime(LocalDateTime.now()));
macroMap.put("${level}", DefinitionsUtil.getNameByVal("EVENT_LEVEL", productEvent.getEventLevel()));
macroMap.put("${severity}", productEvent.getEventLevel());
macroMap.put("${metricName}", productEvent.getEventRuleName());
macroMap.put("${context}", productEvent.getEventRuleName());
macroMap.put("${alarmStatus}", isnew ? "告警触发" : "撤销告警");
macroMap.put("${confirmStatus}", "1".equals(acknowledged) ? "已确认" : "未确认");
macroMap.put("${problemId}", triggerId);
return macroMap;
}
private MessageBody buildMessage(Map<String, String> alarmInfo, List<Long> userIds, boolean isNew) {
Map<String, Object> params = new HashMap<>(alarmInfo);
String title = isNew ? "告警触发:" : "告警恢复:";
return MessageBody.builder().msg(title + alarmInfo.get("${metricName}")).persist(true).to(userIds).body(params).build();
}
@Override
public boolean checkTag(String tag) {
return "__alarm__".equals(tag);
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/event/pgEvent/service/AlarmEventProcess.java
|
Java
|
gpl-3.0
| 6,889
|
package com.zmops.iot.web.event.pgEvent.service;
import com.zmops.iot.domain.device.Device;
import com.zmops.iot.domain.device.EventTriggerRecord;
import com.zmops.iot.domain.device.query.QDevice;
import com.zmops.iot.domain.product.ProductAttributeEvent;
import com.zmops.iot.domain.product.query.QProductAttributeEvent;
import com.zmops.iot.web.analyse.dto.LatestDto;
import com.zmops.iot.web.analyse.service.LatestService;
import com.zmops.iot.web.event.pgEvent.EventProcess;
import com.zmops.iot.web.event.pgEvent.dto.EventDataDto;
import io.ebean.DB;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.time.LocalDateTime;
import java.util.Collections;
import java.util.List;
/**
* @author yefei
*
* 事件处理
**/
@Slf4j
@Component
public class IncidentEventProcess implements EventProcess {
@Autowired
LatestService latestService;
@Override
public void process(EventDataDto eventData) {
String triggerId = eventData.getObjectid();
String tagValue = eventData.getTagValue();
log.debug("-------- event----------triggerId:{},tagValue:{}", triggerId, tagValue);
String[] split = tagValue.split("##");
if (split.length != 2) {
return;
}
String deviceId = split[0];
String key = split[1];
Device device = new QDevice().deviceId.eq(deviceId).findOne();
ProductAttributeEvent productAttributeEvent = new QProductAttributeEvent().productId.eq(deviceId).key.eq(key).findOne();
//取事件属性最新值
List<LatestDto> latestDtos = latestService.queryEventLatest(device.getZbxId(), Collections.singletonList(productAttributeEvent.getZbxId()),
Integer.parseInt(productAttributeEvent.getValueType()));
EventTriggerRecord eventTriggerRecord = new EventTriggerRecord();
eventTriggerRecord.setCreateTime(LocalDateTime.now());
eventTriggerRecord.setDeviceId(deviceId);
eventTriggerRecord.setEventName(productAttributeEvent.getName());
eventTriggerRecord.setEventValue(latestDtos.get(0).getOriginalValue());
eventTriggerRecord.setTenantId(device.getTenantId());
eventTriggerRecord.setKey(productAttributeEvent.getKey());
DB.insert(eventTriggerRecord);
}
@Override
public boolean checkTag(String tag) {
return "__event__".equals(tag);
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/event/pgEvent/service/IncidentEventProcess.java
|
Java
|
gpl-3.0
| 2,481
|
package com.zmops.iot.web.event.pgEvent.service;
import com.zmops.iot.domain.device.Device;
import com.zmops.iot.domain.device.query.QDevice;
import com.zmops.iot.domain.product.ProductStatusFunctionRelation;
import com.zmops.iot.domain.product.query.QProductStatusFunctionRelation;
import com.zmops.iot.util.ToolUtil;
import com.zmops.iot.web.event.pgEvent.EventProcess;
import com.zmops.iot.web.event.pgEvent.dto.EventDataDto;
import io.ebean.DB;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import java.time.LocalDateTime;
/**
* @author yefei
* <p>
* 设备离线处理
**/
@Slf4j
@Component
public class OfflineEventProcess implements EventProcess {
@Override
public void process(EventDataDto eventData) {
log.debug("update device offline status…………");
ProductStatusFunctionRelation relation = new QProductStatusFunctionRelation().zbxId.eq(eventData.getObjectid()).findOne();
if (null == relation) {
return;
}
String deviceId = relation.getRelationId();
if (ToolUtil.isEmpty(deviceId)) {
return;
}
Device device = new QDevice().deviceId.eq(deviceId).findOne();
if (null == device) {
return;
}
DB.update(Device.class).where().eq("deviceId", device.getDeviceId()).asUpdate()
.set("online", 0).set("latestOnline", LocalDateTime.now()).update();
}
@Override
public boolean checkTag(String tag) {
return "__offline__".equals(tag);
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/event/pgEvent/service/OfflineEventProcess.java
|
Java
|
gpl-3.0
| 1,563
|
package com.zmops.iot.web.event.pgEvent.service;
import com.zmops.iot.domain.device.Device;
import com.zmops.iot.domain.device.query.QDevice;
import com.zmops.iot.domain.product.ProductStatusFunctionRelation;
import com.zmops.iot.domain.product.query.QProductStatusFunctionRelation;
import com.zmops.iot.util.ToolUtil;
import com.zmops.iot.web.event.pgEvent.EventProcess;
import com.zmops.iot.web.event.pgEvent.dto.EventDataDto;
import io.ebean.DB;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import java.time.LocalDateTime;
/**
* @author yefei
* <p>
* 设备上线处理
**/
@Slf4j
@Component
public class OnlineEventProcess implements EventProcess {
@Override
public void process(EventDataDto eventData) {
log.debug("update device online status…………");
ProductStatusFunctionRelation relation = new QProductStatusFunctionRelation().zbxIdRecovery.eq(eventData.getObjectid()).findOne();
if (null == relation) {
return;
}
String deviceId = relation.getRelationId();
if (ToolUtil.isEmpty(deviceId)) {
return;
}
Device device = new QDevice().deviceId.eq(deviceId).findOne();
if (null == device) {
return;
}
DB.update(Device.class).where().eq("deviceId", device.getDeviceId()).asUpdate()
.set("online", 1).set("latestOnline", LocalDateTime.now()).update();
}
@Override
public boolean checkTag(String tag) {
return "__online__".equals(tag);
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/event/pgEvent/service/OnlineEventProcess.java
|
Java
|
gpl-3.0
| 1,569
|
package com.zmops.iot.web.event.pgEvent.service;
import com.zmops.iot.util.ToolUtil;
import com.zmops.iot.web.device.service.MultipleDeviceEventRuleService;
import com.zmops.iot.web.event.pgEvent.EventProcess;
import com.zmops.iot.web.event.pgEvent.dto.EventDataDto;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
/**
* @author yefei
*
* 场景触发
**/
@Slf4j
@Component
public class SceneEventProcess implements EventProcess {
@Autowired
MultipleDeviceEventRuleService eventRuleService;
@Override
public void process(EventDataDto eventData) {
log.debug("--------scene event----------ruleId:{}", eventData.getName());
if (ToolUtil.isEmpty(eventData.getName())) {
return;
}
eventRuleService.execute(Long.parseLong(eventData.getName()), "自动", null);
}
@Override
public boolean checkTag(String tag) {
return "__scene__".equals(tag);
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/event/pgEvent/service/SceneEventProcess.java
|
Java
|
gpl-3.0
| 1,035
|
package com.zmops.iot.web.event.pgEvent.service;
import com.alibaba.fastjson.JSON;
import com.dtflys.forest.Forest;
import com.zmops.iot.domain.product.ProductEventRelation;
import com.zmops.iot.domain.product.ProductEventService;
import com.zmops.iot.domain.product.ProductServiceParam;
import com.zmops.iot.domain.product.query.QProductEventRelation;
import com.zmops.iot.domain.product.query.QProductEventService;
import com.zmops.iot.util.DefinitionsUtil;
import com.zmops.iot.util.ToolUtil;
import com.zmops.iot.web.event.applicationEvent.DeviceServiceLogEvent;
import com.zmops.iot.web.event.applicationEvent.dto.LogEventData;
import com.zmops.iot.web.event.pgEvent.EventProcess;
import com.zmops.iot.web.event.pgEvent.dto.EventDataDto;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.stereotype.Component;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Collectors;
/**
* @author yefei
* <p>
* 告警执行服务
**/
@Slf4j
@Component
public class ServiceEventProcess implements EventProcess {
@Autowired
ApplicationEventPublisher publisher;
@Override
public void process(EventDataDto eventData) {
log.debug("--------service event----------{}", eventData.getObjectid());
Map<String, Object> alarmInfo = new ConcurrentHashMap<>(3);
//查询 告警规则
List<ProductEventRelation> productEventRelationList = new QProductEventRelation().zbxId.eq(eventData.getObjectid()).findList();
if (ToolUtil.isEmpty(productEventRelationList)) {
return;
}
//记录服务日志
publisher.publishEvent(new DeviceServiceLogEvent(this, LogEventData.builder().eventRuleId(productEventRelationList.get(0).getEventRuleId())
.relationId(productEventRelationList.get(0).getRelationId()).triggerType("自动").build()));
//查询 告警规则 关联的 服务
List<ProductEventService> productEventServiceList = new QProductEventService()
.eventRuleId.eq(productEventRelationList.get(0).getEventRuleId())
.or()
.deviceId.isNull()
.deviceId.eq(productEventRelationList.get(0).getRelationId())
.endOr()
.findList();
List<Map<String, Object>> list = new ArrayList<>();
Map<String, List<ProductEventService>> collect = productEventServiceList.parallelStream()
.collect(Collectors.groupingBy(ProductEventService::getExecuteDeviceId));
collect.forEach((key, value) -> {
Map<String, Object> map = new ConcurrentHashMap<>();
map.put("device", key);
List<Map<String, Object>> serviceList = new ArrayList<>();
value.forEach(val -> {
Map<String, Object> serviceMap = new ConcurrentHashMap<>();
serviceMap.put("name", DefinitionsUtil.getServiceName(val.getServiceId()));
List<ProductServiceParam> paramList = DefinitionsUtil.getServiceParam(val.getServiceId());
if (ToolUtil.isNotEmpty(paramList)) {
serviceMap.put("param", paramList.parallelStream().filter(o -> key.equals(o.getDeviceId()))
.collect(Collectors.toMap(ProductServiceParam::getKey, ProductServiceParam::getValue, (a, b) -> a)));
}
serviceList.add(serviceMap);
});
map.put("service", serviceList);
list.add(map);
});
Forest.post("/device/action/exec").host("127.0.0.1").port(12800).contentTypeJson().addBody(JSON.toJSON(list)).execute();
}
@Override
public boolean checkTag(String tag) {
return "__execute__".equals(tag);
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/event/pgEvent/service/ServiceEventProcess.java
|
Java
|
gpl-3.0
| 3,941
|
/**
* Copyright 2018-2020 stylefeng & fengshuonan (https://gitee.com/stylefeng)
* <p>
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* <p>
* http://www.apache.org/licenses/LICENSE-2.0
* <p>
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.zmops.iot.web.exception.aop;
import com.zmops.iot.core.auth.context.LoginContextHolder;
import com.zmops.iot.core.auth.exception.AuthException;
import com.zmops.iot.core.auth.exception.PermissionException;
import com.zmops.iot.core.auth.exception.enums.AuthExceptionEnum;
import com.zmops.iot.core.auth.model.LoginUser;
import com.zmops.iot.model.exception.InvalidKaptchaException;
import com.zmops.iot.model.exception.ServiceException;
import com.zmops.iot.model.exception.ZbxApiException;
import com.zmops.iot.model.response.ErrorResponseData;
import com.zmops.iot.web.exception.enums.BizExceptionEnum;
import com.zmops.iot.web.log.LogManager;
import com.zmops.iot.web.log.factory.LogTaskFactory;
import lombok.extern.slf4j.Slf4j;
import org.hibernate.validator.internal.engine.path.PathImpl;
import org.springframework.core.annotation.Order;
import org.springframework.http.HttpStatus;
import org.springframework.http.converter.HttpMessageNotReadableException;
import org.springframework.validation.BindException;
import org.springframework.validation.BindingResult;
import org.springframework.validation.FieldError;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.MissingServletRequestParameterException;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.method.annotation.MethodArgumentTypeMismatchException;
import javax.validation.ConstraintViolation;
import javax.validation.ConstraintViolationException;
import java.util.Set;
import static com.zmops.iot.core.util.HttpContext.getIp;
import static com.zmops.iot.core.util.HttpContext.getRequest;
/**
* 全局的的异常拦截器（拦截所有的控制器）
* （带有@RequestMapping注解的方法上都会拦截）
*
* @author fengshuonan
*/
@ControllerAdvice
@Order(-100)
@Slf4j
public class GlobalExceptionHandler {
/**
* 参数校验错误
*/
@ExceptionHandler(MissingServletRequestParameterException.class)
@ResponseStatus(HttpStatus.OK)
@ResponseBody
public ErrorResponseData handleError(MissingServletRequestParameterException e) {
log.warn("Missing Request Parameter", e);
String message = String.format("%s: 不能为空", e.getParameterName());
return new ErrorResponseData(400, message);
}
/**
* 参数校验错误
*/
@ExceptionHandler(MethodArgumentTypeMismatchException.class)
@ResponseStatus(HttpStatus.OK)
@ResponseBody
public ErrorResponseData handleError(MethodArgumentTypeMismatchException e) {
log.warn("Method Argument Type Mismatch", e);
String message = String.format("Method Argument Type Mismatch: %s", e.getName());
return new ErrorResponseData(400, message);
}
/**
* 参数校验错误
*/
@ExceptionHandler(MethodArgumentNotValidException.class)
@ResponseStatus(HttpStatus.OK)
@ResponseBody
public ErrorResponseData handleError(MethodArgumentNotValidException e) {
log.warn("Method Argument Not Valid", e);
BindingResult result = e.getBindingResult();
FieldError error = result.getFieldError();
String message = String.format("%s:%s", error.getField(), error.getDefaultMessage());
return new ErrorResponseData(400, message);
}
/**
* 参数校验错误异常
*/
@ExceptionHandler(BindException.class)
@ResponseStatus(HttpStatus.OK)
@ResponseBody
public ErrorResponseData handleError(BindException e) {
log.warn("Bind Exception", e);
FieldError error = e.getFieldError();
String message = String.format("%s:不能为空", error.getField(), error.getDefaultMessage());
return new ErrorResponseData(400, message);
}
/**
* 参数校验错误异常
*/
@ExceptionHandler(ConstraintViolationException.class)
@ResponseStatus(HttpStatus.OK)
@ResponseBody
public ErrorResponseData handleError(ConstraintViolationException e) {
log.warn("Constraint Violation", e);
Set<ConstraintViolation<?>> violations = e.getConstraintViolations();
ConstraintViolation<?> violation = violations.iterator().next();
String path = ((PathImpl) violation.getPropertyPath()).getLeafNode().getName();
String message = String.format("%s:%s", path, violation.getMessage());
return new ErrorResponseData(400, message);
}
/**
* 参数校验错误异常
*/
@ExceptionHandler(HttpMessageNotReadableException.class)
@ResponseStatus(HttpStatus.OK)
@ResponseBody
public ErrorResponseData handleError(HttpMessageNotReadableException e) {
log.warn("HttpMessageNotReadableException ", e);
String message = String.format("HttpMessageNotReadableException:%s", e.getMessage());
return new ErrorResponseData(400, message);
}
/**
* 认证异常--认证失败（账号密码错误，账号被冻结，token过期等）
*/
@ExceptionHandler(AuthException.class)
@ResponseStatus(HttpStatus.OK)
@ResponseBody
public ErrorResponseData unAuth(AuthException e) {
return new ErrorResponseData(e.getCode(), e.getMessage());
}
/**
* 认证异常--没有访问权限
*/
@ExceptionHandler(PermissionException.class)
@ResponseStatus(HttpStatus.OK)
@ResponseBody
public ErrorResponseData permissionExpection(PermissionException e) {
LogManager.me().executeLog(LogTaskFactory.loginLog("username", "验证码错误", getIp(), null));
return new ErrorResponseData(e.getCode(), e.getMessage());
}
/**
* 验证码错误异常
*/
@ExceptionHandler(InvalidKaptchaException.class)
@ResponseStatus(HttpStatus.OK)
@ResponseBody
public ErrorResponseData credentials(InvalidKaptchaException e) {
String username = getRequest().getParameter("username");
LogManager.me().executeLog(LogTaskFactory.loginLog(username, "验证码错误", getIp(), null));
return new ErrorResponseData(AuthExceptionEnum.VALID_CODE_ERROR.getCode(), AuthExceptionEnum.VALID_CODE_ERROR.getMessage());
}
/**
* 拦截业务异常
*/
@ExceptionHandler(ServiceException.class)
@ResponseStatus(HttpStatus.OK)
@ResponseBody
public ErrorResponseData bussiness(ServiceException e) {
log.error("业务异常:", e);
if (LoginContextHolder.getContext().hasLogin()) {
LoginUser user = LoginContextHolder.getContext().getUser();
LogManager.me().executeLog(LogTaskFactory.exceptionLog(user.getId(), e, user.getTenantId()));
}
getRequest().setAttribute("tip", e.getMessage());
return new ErrorResponseData(e.getCode(), e.getMessage());
}
/**
* 拦截 Zabbix 接口异常
*/
@ExceptionHandler(ZbxApiException.class)
@ResponseStatus(HttpStatus.OK)
@ResponseBody
public ErrorResponseData bussiness(ZbxApiException e) {
log.error("Zabbix接口调用出错:", e);
if (LoginContextHolder.getContext().hasLogin()) {
LoginUser user = LoginContextHolder.getContext().getUser();
LogManager.me().executeLog(LogTaskFactory.exceptionLog(user.getId(), e, user.getTenantId()));
}
getRequest().setAttribute("tip", e.getMessage());
return new ErrorResponseData(e.getCode(), e.getMessage());
}
/**
* 拦截未知的运行时异常
*/
@ExceptionHandler(Throwable.class)
@ResponseStatus(HttpStatus.OK)
@ResponseBody
public ErrorResponseData notFount(Throwable e) {
log.error("运行时异常:", e);
if (LoginContextHolder.getContext().hasLogin()) {
LoginUser user = LoginContextHolder.getContext().getUser();
LogManager.me().executeLog(LogTaskFactory.exceptionLog(user.getId(), e, user.getTenantId()));
}
String message = String.format("服务器未知运行时异常: %s", e.getMessage());
getRequest().setAttribute("tip", message);
return new ErrorResponseData(BizExceptionEnum.SERVER_ERROR.getCode(), message);
}
/**
* 拦截运行时异常
*/
@ExceptionHandler(RuntimeException.class)
@ResponseStatus(HttpStatus.OK)
@ResponseBody
public ErrorResponseData runtime(RuntimeException e) {
log.error("运行时异常:", e);
if (LoginContextHolder.getContext().hasLogin()) {
LoginUser user = LoginContextHolder.getContext().getUser();
LogManager.me().executeLog(LogTaskFactory.exceptionLog(user.getId(), e, user.getTenantId()));
}
String message = String.format("服务器运行异常请联系管理员");
getRequest().setAttribute("tip", message);
return new ErrorResponseData(BizExceptionEnum.SERVER_ERROR.getCode(), message);
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/exception/aop/GlobalExceptionHandler.java
|
Java
|
gpl-3.0
| 9,716
|
/**
* Copyright 2018-2020 stylefeng & fengshuonan (https://gitee.com/stylefeng)
* <p>
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* <p>
* http://www.apache.org/licenses/LICENSE-2.0
* <p>
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.zmops.iot.web.exception.enums;
import com.zmops.iot.model.exception.AbstractBaseExceptionEnum;
/**
* @author nantian
* @Description 所有业务异常的枚举
*/
public enum BizExceptionEnum implements AbstractBaseExceptionEnum {
/**
* 字典
*/
DICT_EXISTED(400, "字典已经存在"),
ERROR_CREATE_DICT(500, "创建字典失败"),
ERROR_WRAPPER_FIELD(500, "包装字典属性失败"),
ERROR_CODE_EMPTY(500, "字典类型不存在"),
DICT_NOT_EXIST(400, "字典项不存在"),
SYSTEM_DICT_CANNOT_DELETE(400, "系统字典不能删除"),
/**
* 文件上传
*/
FILE_READING_ERROR(400, "FILE_READING_ERROR!"),
FILE_NOT_FOUND(400, "FILE_NOT_FOUND!"),
UPLOAD_ERROR(500, "上传图片出错"),
/**
* 权限和数据问题
*/
USER_NOT_BIND_ROLE(400, "用户没有绑定角色"),
DB_RESOURCE_NULL(400, "数据库中没有该资源"),
NO_PERMITION(405, "权限异常"),
REQUEST_INVALIDATE(400, "请求数据格式不正确"),
INVALID_KAPTCHA(400, "验证码不正确"),
CANT_DELETE_ADMIN(600, "不能删除超级管理员"),
CANT_FREEZE_ADMIN(600, "不能冻结超级管理员"),
CANT_CHANGE_ADMIN(600, "不能修改超级管理员角色"),
CANT_CHANGE_ADMIN_PWD(600, "不能修改超级管理员密码"),
ROLE_HAS_EXIST(601, "角色已存在"),
ROLE_HAS_BIND_USER(602, "角色绑定了用户,请先解除绑定!"),
MENU_NOT_EXIST_OR_NO_PRERMISSION(603, "菜单不存在或无权授权此菜单"),
ROLE_NOT_EXIST(604, "角色不存在"),
CANNOT_MODIFY_OWNER_MENUS(605, "不能修改自己所在角色的菜单"),
/**
* 账户问题
*/
NOT_LOGIN(401, "当前用户未登录"),
USER_ALREADY_REG(401, "该用户已经注册"),
NO_THIS_USER(400, "没有此用户"),
USER_NOT_EXISTED(400, "没有此用户"),
ACCOUNT_FREEZED(401, "账号被冻结"),
OLD_PWD_NOT_RIGHT(402, "原密码不正确"),
TWO_PWD_NOT_MATCH(405, "两次输入密码不一致"),
PWD_DECRYPT_ERR(406, "密码解密出错"),
/**
* 错误的请求
*/
MENU_PCODE_COINCIDENCE(400, "菜单编号和副编号不能一致"),
EXISTED_THE_MENU(400, "菜单编号重复，不能添加"),
DICT_MUST_BE_NUMBER(400, "字典的值必须为数字"),
REQUEST_NULL(400, "请求有错误"),
SESSION_TIMEOUT(400, "会话超时"),
SERVER_ERROR(500, "服务器异常"),
/**
* token异常
*/
TOKEN_EXPIRED(700, "token过期"),
TOKEN_ERROR(700, "token验证失败"),
/**
* 签名异常
*/
SIGN_ERROR(700, "签名验证失败"),
/**
* 系统常量
*/
ALREADY_CONSTANTS_ERROR(400, "已经存在该编码的系统参数"),
SYSTEM_CONSTANT_ERROR(400, "不能删除系统常量"),
/**
* zabbix 相关
*/
ZBX_TOKEN_SAVE_ERROR(800, "Zabbix登陆token保存失败"),
ZBX_CALL_ERR(801, "ZABBIX接口请求失败"),
/**
* 用户组相关
*/
USERGROUP_HAS_EXIST(1001, "用户组已存在"),
USERGROUP_NOT_EXIST(1003, "用户组不存在"),
USERGROUP_HAS_BIND_USER(1002, "用户组绑定了用户,请先解除绑定!"),
/**
* 用户相关
*/
USER_NOT_EXIST(1101, "用户不存在"),
/**
* 设备组相关
*/
DEVICEGROUP_HAS_EXIST(1201, "设备组已存在"),
DEVICEGROUP_NOT_EXIST(1203, "设备组不存在"),
DEVICEGROUP_HAS_BIND_USERGRP(1202, "设备组绑定了用户组,请先解除绑定!"),
DEVICEGROUP_HAS_BIND_DEVICE(1203, "设备组绑定了设备,请先解除绑定!"),
/**
* 产品相关
*/
PRODUCT_HAS_EXIST(1301, "该产品ID已存在"),
PRODUCT_NOT_EXISTS(1302, "该产品不存在"),
PRODUCT_TYPE_EXIST(1303, "产品分类已存在"),
PRODUCT_TYPE_NOT_EXIST(1303, "产品分类不存在"),
PRODUCT_TYPE_HAS_BIND(1304, "产品分类已绑定产品"),
PRODUCT_TYPE_PID_NOT_EXIST(1305, "父节点不存在"),
PRODUCT_TYPE_PID_ERR(1306, "父节点不可以是自已或子节点"),
PRODUCT_HAS_BIND_DEVICE(1307, "产品已绑定设备"),
/**
* 属性相关
*/
PRODUCT_ATTR_KEY_EXISTS(1401, "该属性Key已存在"),
PRODUCT_ATTR_KEY_NOT_EXISTS(1404, "该属性Key不存在"),
PRODUCT_ATTR_DEPTED_NULL(1402, "依赖的属性不能为空"),
PRODUCT_ATTR_DEPTED_NOT_EXIST(1403, "依赖的属性不能为空"),
PRODUCT_ATTR_DEPTED(1404, "属性被依赖不能删除"),
PRODUCT_EVENT_HASDEPTED(1405, "属性已用于告警规则,不能删除"),
/**
* 设备相关
*/
DEVICE_EXISTS(1501, "设备名称已存在"),
DEVICE_ID_EXISTS(1503, "设备ID已存在"),
DEVICE_NOT_EXISTS(1502, "设备不存在"),
DEVICE_NAME_HAS_INCOREECT_CHARACTER(1504, "设备名称不能包含\\或\\/字符"),
/**
* 服务相关
*/
SERVICE_EXISTS(1601, "服务已存在"),
SERVICE_NOT_EXISTS(1602, "服务不存在"),
PRODUCT_EVENT_HAS_DEPTED(1605, "服务已用于告警规则或场景联动,不能删除"),
SERVICE_HAS_DUPLICATE(1606, "存在相同的动作服务"),
SERVICE_PARAM_NOT_EXISTS(1607, "服务未配置参数"),
/**
* 触发规则相关
*/
RULE_NOT_EXISTS(1701, "上下线规则不存在"),
RULE_EXISTS(1702, "上下线规则已存在"),
EVENT_HAS_NOT_DEVICE(1703, "告警规则缺少关联产品或设备"),
EVENT_NOT_EXISTS(1704, "告警规则不存在"),
EVENT_EXPRESSION_NOT_EXISTS(1705, "告警表达式关联关系不存在"),
EVENT_PRODUCT_CANNOT_DELETE(1706, "来自产品的触发器不能删除"),
SCENE_NOT_EXISTS(1707, "场景不存在"),
SCENE_EXPRESSION_NOT_EXISTS(1708, "场景触发条件不能为空"),
SCENE_EXISTED(1709, "场景名称已存在"),
/**
* 任务相关
*
* @param code
* @param message
*/
TASK_NOT_SCHEDULE_CONF(2201, "任务调度配置不能为空"),
TASK_SCHEDULE_CONF_NOT_MATCH(2202, "任务调度配置不正确"),
/**
* 租户相关的异常
*/
TENANT_NAME_EXISTS(1801, "租户名称已存在"),
TENANT_ACCOUNT_EXISTS(1802, "租户账号已存在"),
TENANT_NOT_EXISTS(1803, "租户不存在"),
TENANT_HAS_RELATION_INFO(1804, "租户已关联用户组、设备组、产品类型"),
/**
* 设备调试相关
*/
ZBX_DEVICE_API_HASNOT_KEY(1901, "属性KEY和值不能为空"),
/**
* 代理服务相关
*/
PROXY_EXISTS(2001, "代理服务已存在"),
PROXY_NOT_EXISTS(2002, "代理服务不存在"),
/**
* 协议相关
*/
PROTOCOL_COMPONENT_EXISTS(2301, "协议组件名称已存在"),
PROTOCOL_COMPONENT_NOT_EXISTS(2302, "协议组件不存在"),
PROTOCOL_COMPONENT_HAS_BIND_GATEWAY(2303, "协议组件已绑定协议网关,不能删除"),
PROTOCOL_SERVICE_EXISTS(2304, "通信服务名称已存在"),
PROTOCOL_SERVICE_NOT_EXISTS(2305, "通信服务不存在"),
PROTOCOL_SERVICE_PORT_EXISTS(2310, "端口已存在"),
PROTOCOL_SERVICE_HAS_BIND_GATEWAY(2306, "通信服务已绑定协议网关,不能删除"),
PROTOCOL_GATEWAY_NOT_EXISTS(2307, "协议网关不存在"),
PROTOCOL_SERVICE_HAS_BIND_COMPONENT(2308, "通信服务已绑定协议协议组件"),
PROTOCOL_GATEWAY_HAS_NOT_COMPONENT(2309, "未选择协议组件"),
/**
* 数据转换相关
*/
ZBX_SERBER_NOT_CONFIG(2101, "Zabbix配置信息获取失败"),
ZBX_SERBER_EXPORT_PATH_NOT_CONFIG(2102, "Zabbix日志输出路径未配置"),
AUTH_REQUEST_ERROR(400, "账号密码错误");
BizExceptionEnum(int code, String message) {
this.code = code;
this.message = message;
}
private Integer code;
private String message;
@Override
public Integer getCode() {
return code;
}
public void setCode(Integer code) {
this.code = code;
}
@Override
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/exception/enums/BizExceptionEnum.java
|
Java
|
gpl-3.0
| 8,731
|
package com.zmops.iot.web.exception.page;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
/**
* 全局的控制器
*
* @author fengshuonan
*/
@Controller
@RequestMapping("/global")
public class GlobalController {
/**
* 跳转到404页面
*/
@RequestMapping(path = "/error")
public String errorPage() {
return "/404";
}
/**
* 跳转到session超时页面
*/
@RequestMapping(path = "/sessionError")
public String errorPageInfo(Model model) {
return "/index";
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/exception/page/GlobalController.java
|
Java
|
gpl-3.0
| 639
|
package com.zmops.iot.web.init;
import com.alibaba.fastjson.JSON;
import com.dtflys.forest.config.ForestConfiguration;
import com.zmops.zeus.driver.service.ZbxHostGroup;
import com.zmops.zeus.driver.service.ZbxInitService;
import lombok.Data;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import javax.annotation.PostConstruct;
import java.util.List;
import java.util.Map;
/**
* @author nantian created at 2021/8/7 22:52
*/
@Service
public class BasicSettingsInit {
@Autowired
private ForestConfiguration configuration;
@Autowired
private ZbxHostGroup zbxHostGroup;
@Autowired
private ZbxInitService zbxInitService;
public static String zbxApiToken;
@PostConstruct
public void init() {
zbxApiToken = configuration.getVariableValue("zbxApiToken").toString();
}
/**
* 查询全局主机组
*
* @return String
*/
public String getGlobalHostGroup() {
String response = zbxHostGroup.getGlobalHostGroup(zbxApiToken);
List<Map<String, String>> ids = JSON.parseObject(response, List.class);
if (null != ids && ids.size() > 0) {
return ids.get(0).get("groupid");
}
return null;
}
/**
* 创建默认全局主机组
*
* @return Integer
*/
public String createGlobalHostGroup() {
String response = zbxHostGroup.createGlobalHostGroup(zbxApiToken);
return JSON.parseObject(response, ZbxResponseIds.class).getGroupids()[0];
}
/**
* 查询只读权限用户组
*
* @return String
*/
public String getCookieUserGroup() {
String response = zbxInitService.getCookieUserGroup(zbxApiToken);
List<Map<String, String>> ids = JSON.parseObject(response, List.class);
if (null != ids && ids.size() > 0) {
return ids.get(0).get("usrgrpid");
}
return null;
}
/**
* 创建 只读权限用户组
*
* @param globalHostGroupId 全局主机组ID
* @return String
*/
public String createCookieUserGroup(String globalHostGroupId) {
String response = zbxInitService.createCookieUserGroup(globalHostGroupId, zbxApiToken);
return JSON.parseObject(response, ZbxResponseIds.class).getUsrgrpids()[0];
}
/**
* 查询 只读权限用户
*
* @return String
*/
public String getCookieUser() {
String response = zbxInitService.getCookieUser(zbxApiToken);
List<Map<String, String>> ids = JSON.parseObject(response, List.class);
if (null != ids && ids.size() > 0) {
return ids.get(0).get("userid");
}
return null;
}
/**
* 创建 只读权限用户
*
* @param groupId 只读用户组ID
* @return String
*/
public String createCookieUser(String groupId, String roleId) {
String response = zbxInitService.createCookieUser(groupId, zbxApiToken, roleId);
return JSON.parseObject(response, ZbxResponseIds.class).getUserids()[0];
}
/**
* 查询 管理员用户角色
*
* @return String
*/
public String getAdminRoleId() {
String response = zbxInitService.getAdminRole(zbxApiToken);
List<Map<String, String>> ids = JSON.parseObject(response, List.class);
if (null != ids && ids.size() > 0) {
return ids.get(0).get("roleid");
}
return null;
}
/**
* 查询 访客用户角色
*
* @return String
*/
public String getGuestRoleId() {
String response = zbxInitService.getGuestRole(zbxApiToken);
List<Map<String, String>> ids = JSON.parseObject(response, List.class);
if (null != ids && ids.size() > 0) {
return ids.get(0).get("roleid");
}
return null;
}
@Data
static class ZbxResponseIds {
String[] groupids;
String[] userids;
String[] usrgrpids;
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/init/BasicSettingsInit.java
|
Java
|
gpl-3.0
| 4,032
|
package com.zmops.iot.web.init;
import com.zmops.iot.domain.sys.SysConfig;
import io.ebean.DB;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
/**
* @author nantian created at 2021/8/7 20:25
*/
@Slf4j
@Component
public class DeviceSatusScriptInit implements CommandLineRunner {
public static final String GLOBAL_HOST_GROUP_CODE = "ZEUS_HOST_GROUP_ID";
public static final String GLOBAL_ADMIN_ROLE_CODE = "ZEUS_ADMIN_ROLE_ID";
@Autowired
private BasicSettingsInit basicSettingsInit;
@Override
public void run(String... args) throws Exception {
// 第一步：判断系统参数是否存在 全局主机组 ID
String groupId = basicSettingsInit.getGlobalHostGroup();
if (groupId == null) {
groupId = basicSettingsInit.createGlobalHostGroup();
}
DB.update(SysConfig.class).where().eq("code", GLOBAL_HOST_GROUP_CODE).asUpdate().set("value", groupId).update();
//判断系统参数是否存在 zbx管理员ID
String roleId = basicSettingsInit.getAdminRoleId();
DB.update(SysConfig.class).where().eq("code", GLOBAL_ADMIN_ROLE_CODE).asUpdate().set("value", roleId).update();
//判断只读用户是否存在 不存在就创建一个
String userId = basicSettingsInit.getCookieUser();
if (userId == null) {
String userGroupId = basicSettingsInit.getCookieUserGroup();
if (userGroupId == null) {
userGroupId = basicSettingsInit.createCookieUserGroup(groupId);
}
String guestRoleId = basicSettingsInit.getGuestRoleId();
basicSettingsInit.createCookieUser(userGroupId, guestRoleId);
}
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/init/DeviceSatusScriptInit.java
|
Java
|
gpl-3.0
| 1,852
|
package com.zmops.iot.web.init;
import com.zmops.iot.constant.ConstantsContext;
import com.zmops.iot.domain.sys.SysConfig;
import io.ebean.DB;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
import java.util.List;
/**
* @author nantian created at 2021/8/1 20:50
*/
@Slf4j
@Component
public class SysConfigInit implements CommandLineRunner {
@Override
public void run(String... args) {
initConfigConst();
}
public void initConfigConst(){
//初始化所有的常量
List<SysConfig> list = DB.find(SysConfig.class).findList();
if (!list.isEmpty()) {
for (SysConfig sysConfig : list) {
ConstantsContext.putConstant(sysConfig.getCode(), sysConfig.getValue());
}
log.info("初始化常量" + list.size() + "条！");
}
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/init/SysConfigInit.java
|
Java
|
gpl-3.0
| 927
|
/**
* Copyright 2018-2020 stylefeng & fengshuonan (https://gitee.com/stylefeng)
* <p>
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* <p>
* http://www.apache.org/licenses/LICENSE-2.0
* <p>
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.zmops.iot.web.log;
import java.util.TimerTask;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
/**
* 日志管理器
*
* @author fengshuonan
*/
public class LogManager {
//日志记录操作延时
private final int OPERATE_DELAY_TIME = 10;
//异步操作记录日志的线程池
private ScheduledThreadPoolExecutor executor = new ScheduledThreadPoolExecutor(10);
private LogManager() {
}
public static LogManager logManager = new LogManager();
public static LogManager me() {
return logManager;
}
public void executeLog(TimerTask task) {
executor.schedule(task, OPERATE_DELAY_TIME, TimeUnit.MILLISECONDS);
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/log/LogManager.java
|
Java
|
gpl-3.0
| 1,392
|
/**
* Copyright 2018-2020 stylefeng & fengshuonan (https://gitee.com/stylefeng)
* <p>
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* <p>
* http://www.apache.org/licenses/LICENSE-2.0
* <p>
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.zmops.iot.web.log;
import com.zmops.iot.util.SpringContextHolder;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
import org.springframework.web.context.WebApplicationContext;
import java.io.Serializable;
/**
* 被修改的bean临时存放的地方
*
* @author fengshuonan
*/
@Component
@Scope(scopeName = WebApplicationContext.SCOPE_SESSION)
public class LogObjectHolder implements Serializable {
private Object object = null;
public void set(Object obj) {
this.object = obj;
}
public Object get() {
return object;
}
public static LogObjectHolder me() {
return SpringContextHolder.getBean(LogObjectHolder.class);
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/log/LogObjectHolder.java
|
Java
|
gpl-3.0
| 1,398
|
/**
* Copyright 2018-2020 stylefeng & fengshuonan (https://gitee.com/stylefeng)
* <p>
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* <p>
* http://www.apache.org/licenses/LICENSE-2.0
* <p>
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.zmops.iot.web.log.aop;
import com.zmops.iot.core.auth.context.LoginContextHolder;
import com.zmops.iot.core.auth.model.LoginUser;
import com.zmops.iot.core.log.BussinessLog;
import com.zmops.iot.web.log.LogManager;
import com.zmops.iot.web.log.factory.LogTaskFactory;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;
import java.lang.reflect.Method;
/**
* 日志记录
*
* @author fengshuonan nantian
*/
@Slf4j
@Aspect
@Component
public class LogAop {
@Pointcut(value = "@annotation(com.zmops.iot.core.log.BussinessLog)")
public void cutService() {
}
@Around("cutService()")
public Object recordSysLog(ProceedingJoinPoint point) throws Throwable {
//先执行业务
Object result = point.proceed();
try {
handle(point);
} catch (Exception e) {
log.error("日志记录出错!", e);
}
return result;
}
private void handle(ProceedingJoinPoint point) throws Exception {
//获取拦截的方法名
Signature sig = point.getSignature();
MethodSignature msig = null;
if (!(sig instanceof MethodSignature)) {
throw new IllegalArgumentException("该注解只能用于方法");
}
msig = (MethodSignature) sig;
Object target = point.getTarget();
Method currentMethod = target.getClass().getMethod(msig.getName(), msig.getParameterTypes());
String methodName = currentMethod.getName();
//如果当前用户未登录，不做日志
LoginUser user = LoginContextHolder.getContext().getUser();
if (null == user) {
return;
}
//获取拦截方法的参数
String className = point.getTarget().getClass().getName();
Object[] params = point.getArgs();
//获取操作名称
BussinessLog annotation = currentMethod.getAnnotation(BussinessLog.class);
String bussinessName = annotation.value();
String key = annotation.key();
Class dictClass = annotation.dict();
StringBuilder sb = new StringBuilder();
for (Object param : params) {
sb.append(param);
sb.append(" & ");
}
//如果涉及到修改,比对变化
String msg = "";
// if (bussinessName.contains("修改") || bussinessName.contains("编辑")) {
// Object obj1 = LogObjectHolder.me().get();
// Map<String, String> obj2 = HttpContext.getRequestParameters();
// msg = Contrast.contrastObj(dictClass, key, obj1, obj2);
// } else {
// Map<String, String> parameters = HttpContext.getRequestParameters();
// AbstractDictMap dictMap = (AbstractDictMap) dictClass.newInstance();
// msg = Contrast.parseMutiKey(dictMap, key, parameters);
// }
LogManager.me().executeLog(LogTaskFactory.bussinessLog(user.getId(), bussinessName, className, methodName, msg,user.getTenantId()));
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/log/aop/LogAop.java
|
Java
|
gpl-3.0
| 3,940
|
/**
* Copyright 2018-2020 stylefeng & fengshuonan (https://gitee.com/stylefeng)
* <p>
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* <p>
* http://www.apache.org/licenses/LICENSE-2.0
* <p>
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.zmops.iot.web.log.factory;
import com.zmops.iot.domain.sys.SysLoginLog;
import com.zmops.iot.domain.sys.SysOperationLog;
import com.zmops.iot.web.constant.state.LogSucceed;
import com.zmops.iot.web.constant.state.LogType;
import java.time.LocalDateTime;
/**
* 日志对象创建工厂
*
* @author fengshuonan
*/
public class LogFactory {
/**
* 创建操作日志
*/
public static SysOperationLog createOperationLog(LogType logType, Long userId, String bussinessName,
String clazzName, String methodName, String msg, LogSucceed succeed,Long tenantId) {
SysOperationLog operationLog = new SysOperationLog();
operationLog.setLogType(logType.getMessage());
operationLog.setLogName(bussinessName);
operationLog.setUserId(userId);
operationLog.setClassName(clazzName);
operationLog.setMethod(methodName);
operationLog.setCreateTime(LocalDateTime.now());
operationLog.setSucceed(succeed.getMessage());
operationLog.setMessage(msg);
operationLog.setTenantId(tenantId);
return operationLog;
}
/**
* 创建登录日志
*/
public static SysLoginLog createLoginLog(LogType logType, Long userId, String msg, String ip,Long tenantId) {
SysLoginLog loginLog = new SysLoginLog();
loginLog.setLogName(logType.getMessage());
loginLog.setUserId(userId);
loginLog.setCreateTime(LocalDateTime.now());
loginLog.setSucceed(LogSucceed.SUCCESS.getMessage());
loginLog.setIpAddress(ip);
loginLog.setMessage(msg);
loginLog.setTenantId(tenantId);
return loginLog;
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/log/factory/LogFactory.java
|
Java
|
gpl-3.0
| 2,370
|
/**
* Copyright 2018-2020 stylefeng & fengshuonan (https://gitee.com/stylefeng)
* <p>
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* <p>
* http://www.apache.org/licenses/LICENSE-2.0
* <p>
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.zmops.iot.web.log.factory;
import com.zmops.iot.domain.sys.SysLoginLog;
import com.zmops.iot.domain.sys.SysOperationLog;
import com.zmops.iot.util.ToolUtil;
import com.zmops.iot.web.constant.state.LogSucceed;
import com.zmops.iot.web.constant.state.LogType;
import io.ebean.DB;
import lombok.extern.slf4j.Slf4j;
import java.util.TimerTask;
/**
* 日志操作任务创建工厂
*
* @author fengshuonan nantian
*/
@Slf4j
public class LogTaskFactory {
public static TimerTask loginLog(final Long userId, final String ip,Long tenantId) {
return new TimerTask() {
@Override
public void run() {
try {
SysLoginLog loginLog = LogFactory.createLoginLog(LogType.LOGIN, userId, null, ip,tenantId);
DB.insert(loginLog);
} catch (Exception e) {
log.error("创建登录日志异常!", e);
}
}
};
}
public static TimerTask loginLog(final String username, final String msg, final String ip,Long tenantId) {
return new TimerTask() {
@Override
public void run() {
SysLoginLog loginLog = LogFactory.createLoginLog(
LogType.LOGIN_FAIL, null, "账号:" + username + "," + msg, ip,tenantId);
try {
DB.insert(loginLog);
} catch (Exception e) {
log.error("创建登录失败异常!", e);
}
}
};
}
public static TimerTask exitLog(final Long userId, final String ip,Long tenantId) {
return new TimerTask() {
@Override
public void run() {
SysLoginLog loginLog = LogFactory.createLoginLog(LogType.EXIT, userId, null, ip,tenantId);
try {
DB.insert(loginLog);
} catch (Exception e) {
log.error("创建退出日志异常!", e);
}
}
};
}
public static TimerTask bussinessLog(final Long userId, final String bussinessName, final String clazzName, final String methodName, final String msg,Long tenantId) {
return new TimerTask() {
@Override
public void run() {
SysOperationLog operationLog = LogFactory.createOperationLog(
LogType.BUSSINESS, userId, bussinessName, clazzName, methodName, msg, LogSucceed.SUCCESS,tenantId);
try {
DB.insert(operationLog);
} catch (Exception e) {
log.error("创建业务日志异常!", e);
}
}
};
}
public static TimerTask exceptionLog(final Long userId, final Throwable exception,Long tenantId) {
return new TimerTask() {
@Override
public void run() {
String msg = ToolUtil.getExceptionMsg(exception);
SysOperationLog operationLog = LogFactory.createOperationLog(
LogType.EXCEPTION, userId, "", null, null, msg, LogSucceed.FAIL,tenantId);
try {
DB.insert(operationLog);
} catch (Exception e) {
log.error("创建异常日志异常!", e);
}
}
};
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/log/factory/LogTaskFactory.java
|
Java
|
gpl-3.0
| 4,035
|
package com.zmops.iot.web.macro.controller;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.zmops.iot.domain.BaseEntity;
import com.zmops.iot.domain.device.Device;
import com.zmops.iot.domain.device.query.QDevice;
import com.zmops.iot.domain.product.query.QProduct;
import com.zmops.iot.enums.InheritStatus;
import com.zmops.iot.model.exception.ServiceException;
import com.zmops.iot.model.response.ResponseData;
import com.zmops.iot.util.ToolUtil;
import com.zmops.iot.web.exception.enums.BizExceptionEnum;
import com.zmops.iot.web.macro.dto.UserMacro;
import com.zmops.iot.web.macro.service.MacroService;
import com.zmops.zeus.driver.service.ZbxHost;
import com.zmops.zeus.driver.service.ZbxMacro;
import lombok.Getter;
import lombok.Setter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
/**
* @author nantian created at 2021/9/18 10:53
*/
@RequestMapping("/macro")
@RestController
public class MacroController {
@Autowired
private ZbxMacro zbxMacro;
@Autowired
private ZbxHost zbxHost;
@Autowired
private MacroService macroService;
/**
* 创建 变量
*
* @return ResponseData
*/
@RequestMapping("/create")
public ResponseData createUserMacro(@Validated(BaseEntity.Create.class) @RequestBody UserMacro userMacro) {
// 获取 host id
String zbxId = new QDevice().select(QDevice.alias().zbxId).deviceId.eq(userMacro.getDeviceId()).findSingleAttribute();
if (ToolUtil.isEmpty(zbxId)) {
zbxId = new QProduct().select(QProduct.alias().zbxId).productId.eq(Long.parseLong(userMacro.getDeviceId())).findSingleAttribute();
}
if (ToolUtil.isEmpty(zbxId)) {
throw new ServiceException(BizExceptionEnum.PRODUCT_NOT_EXISTS);
}
return ResponseData.success(macroService.createMacro(userMacro, zbxId));
}
/**
* 变量更新
*
* @param userMacro
* @return ResponseData
*/
@RequestMapping("/update")
public ResponseData updateUserMacro(@Validated(BaseEntity.Update.class) @RequestBody UserMacro userMacro) {
if (InheritStatus.YES.getCode().equals(userMacro.getInherit())) {
String zbxId = new QDevice().select(QDevice.alias().zbxId).deviceId.eq(userMacro.getDeviceId()).findSingleAttribute();
if (ToolUtil.isEmpty(zbxId)) {
throw new ServiceException(BizExceptionEnum.PRODUCT_NOT_EXISTS);
}
macroService.createMacro(userMacro, zbxId);
} else {
zbxMacro.macroUpdate(userMacro.getHostmacroid(), userMacro.getMacro(), userMacro.getValue(), userMacro.getDescription());
}
return ResponseData.success();
}
/**
* 变量列表
*
* @param userMacro
* @return ResponseData
*/
@RequestMapping("/list")
public ResponseData getUserMacro(@Validated(BaseEntity.Get.class) @RequestBody UserMacro userMacro) {
// 获取 模板ID 或者 设备ID
String zbxId = "";
Device device = new QDevice().deviceId.eq(userMacro.getDeviceId()).findOne();
if (device != null) {
zbxId = device.getZbxId();
} else {
zbxId = new QProduct().select(QProduct.alias().zbxId).productId.eq(Long.parseLong(userMacro.getDeviceId())).findSingleAttribute();
}
if (ToolUtil.isEmpty(zbxId)) {
throw new ServiceException(BizExceptionEnum.PRODUCT_NOT_EXISTS);
}
// 模板ID
if (device == null) {
List<UserMacro> tempMacroList = JSONObject.parseArray(zbxMacro.macroGet(zbxId + ""), UserMacro.class);
return ResponseData.success(tempMacroList);
}
// 模板IDs
List<HostQueryTempObject> tempListObject = JSON.parseArray(zbxHost.hostTempidGet(userMacro.getDeviceId()), HostQueryTempObject.class);
TemplateIdObject tempId = tempListObject.get(0).getParentTemplates().get(0);
if (ToolUtil.isNotEmpty(tempId)) {
// 模板宏
List<UserMacro> tempMacroList = JSONObject.parseArray(zbxMacro.macroGet(tempId.getTemplateid()), UserMacro.class);
tempMacroList.forEach(macro -> {
macro.setInherit("1");
macro.setInheritName("否");
});
// 主机宏
List<UserMacro> hostMacroList = JSONObject.parseArray(zbxMacro.macroGet(zbxId + ""), UserMacro.class);
Map<String, UserMacro> hostMacroMap = hostMacroList.parallelStream().collect(Collectors.toMap(UserMacro::getMacro, o -> o, (a, b) -> a));
//过滤模板宏中相同的KEY
tempMacroList.removeIf(macro -> null != hostMacroMap.get(macro.getMacro()));
tempMacroList.addAll(hostMacroList);
return ResponseData.success(tempMacroList);
}
return ResponseData.error(ResponseData.DEFAULT_ERROR_CODE, "");
}
/**
* 变量删除
*
* @param userMacro
* @return ResponseData
*/
@RequestMapping("/delete")
public ResponseData deleteUserMacro(@Validated(BaseEntity.Delete.class) @RequestBody UserMacro userMacro) {
zbxMacro.macroDelete(Collections.singletonList(userMacro.getHostmacroid()));
return ResponseData.success();
}
@Getter
@Setter
static class HostQueryTempObject {
private String hostid;
private List<TemplateIdObject> parentTemplates;
}
@Getter
@Setter
static class TemplateIdObject {
private String templateid;
private String name;
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/macro/controller/MacroController.java
|
Java
|
gpl-3.0
| 5,974
|
package com.zmops.iot.web.macro.dto;
import com.zmops.iot.domain.BaseEntity;
import lombok.Getter;
import lombok.Setter;
import javax.validation.constraints.NotBlank;
/**
* @author nantian created at 2021/9/18 11:47
*/
@Getter
@Setter
public class UserMacro {
@NotBlank(groups = {BaseEntity.Create.class, BaseEntity.Update.class, BaseEntity.Get.class})
private String deviceId; // 产品ID 或者 设备ID
private String macro;
private String value;
private String description;
@NotBlank(groups = BaseEntity.Update.class)
private String inherit = "0";
private String inheritName = "否";
@NotBlank(groups = {BaseEntity.Delete.class, BaseEntity.Update.class})
private String hostmacroid;
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/macro/dto/UserMacro.java
|
Java
|
gpl-3.0
| 745
|
package com.zmops.iot.web.macro.service;
import com.alibaba.fastjson.JSON;
import com.zmops.iot.web.macro.dto.UserMacro;
import com.zmops.zeus.driver.service.ZbxMacro;
import lombok.Getter;
import lombok.Setter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.Locale;
/**
* @author yefei
**/
@Service
public class MacroService {
@Autowired
ZbxMacro zbxMacro;
public Long createMacro(UserMacro userMacro, String zbxId) {
// 创建宏
String res = zbxMacro.macroCreate(zbxId, userMacro.getMacro().toUpperCase(Locale.ROOT), userMacro.getValue(), userMacro.getDescription());
Macroids macroids = JSON.parseObject(res, Macroids.class);
return macroids.getHostmacroids()[0];
}
@Getter
@Setter
static class Macroids {
private Long[] hostmacroids;
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/macro/service/MacroService.java
|
Java
|
gpl-3.0
| 905
|
package com.zmops.iot.web.product.controller;
import cn.hutool.core.util.IdUtil;
import com.alibaba.fastjson.JSON;
import com.zmops.iot.domain.BaseEntity;
import com.zmops.iot.domain.product.ProductAttribute;
import com.zmops.iot.domain.product.ProductAttributeEvent;
import com.zmops.iot.domain.product.query.QProductAttribute;
import com.zmops.iot.domain.product.query.QProductAttributeEvent;
import com.zmops.iot.model.exception.ServiceException;
import com.zmops.iot.model.page.Pager;
import com.zmops.iot.model.response.ResponseData;
import com.zmops.iot.web.exception.enums.BizExceptionEnum;
import com.zmops.iot.web.product.dto.ProductAttr;
import com.zmops.iot.web.product.dto.ProductAttrDto;
import com.zmops.iot.web.product.dto.param.ProductAttrParam;
import com.zmops.iot.web.product.service.ProductAttributeEventService;
import lombok.Data;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
/**
* @author nantian created at 2021/8/3 19:44
* <p>
* 产品 属性事件
*/
@RestController
@RequestMapping("/product/attribute/event")
public class ProductAttributeEventController {
@Autowired
private ProductAttributeEventService productAttributeEventService;
//依赖属性类型
private static final String ATTR_SOURCE_DEPEND = "18";
/**
* 产品属性事件 分页列表
*
* @return ResponseData
*/
@RequestMapping("/getAttrEventByPage")
public Pager<ProductAttrDto> prodAttributeEventList(@RequestBody ProductAttrParam productAttr) {
return productAttributeEventService.prodAttributeEventList(productAttr);
}
/**
* 属性事件 列表
*
* @return ResponseData
*/
@RequestMapping("/list")
public ResponseData list(@RequestBody ProductAttrParam productAttr) {
return ResponseData.success(productAttributeEventService.list(productAttr));
}
/**
* 属性事件 详情
*
* @return ResponseData
*/
@RequestMapping("/detail")
public ResponseData detail(@RequestParam(value = "attrId") Long attrId) {
return ResponseData.success(productAttributeEventService.detail(attrId));
}
/**
* 创建 产品属性事件
*
* @return ResponseData
*/
@RequestMapping("/create")
public ResponseData prodModelAttributeCreate(@RequestBody @Validated(BaseEntity.Create.class) ProductAttr productAttr) {
int i = new QProductAttribute().productId.eq(productAttr.getProductId()).key.eq(productAttr.getKey()).findCount();
if (i > 0) {
throw new ServiceException(BizExceptionEnum.PRODUCT_ATTR_KEY_EXISTS);
}
if (ATTR_SOURCE_DEPEND.equals(productAttr.getSource())) {
if (productAttr.getDepAttrId() == null) {
throw new ServiceException(BizExceptionEnum.PRODUCT_ATTR_DEPTED_NULL);
}
ProductAttributeEvent productAttributeEvent = new QProductAttributeEvent().attrId.eq(productAttr.getDepAttrId()).findOne();
if (null == productAttributeEvent) {
throw new ServiceException(BizExceptionEnum.PRODUCT_ATTR_DEPTED_NOT_EXIST);
}
productAttr.setMasterItemId(productAttributeEvent.getZbxId());
}
Long attrId = IdUtil.getSnowflake().nextId();
productAttr.setAttrId(attrId);
String response = productAttributeEventService.createTrapperItem(productAttr);
String zbxId = JSON.parseObject(response, TemplateIds.class).getItemids()[0];
productAttributeEventService.createProductAttr(productAttr, zbxId);
return ResponseData.success(productAttr);
}
/**
* 修改 产品属性事件
*
* @return ResponseData
*/
@RequestMapping("/update")
public ResponseData prodModelAttributeUpdate(@RequestBody @Validated(BaseEntity.Update.class) ProductAttr productAttr) {
int i = new QProductAttribute().productId.eq(productAttr.getProductId()).key.eq(productAttr.getKey())
.attrId.ne(productAttr.getAttrId()).findCount();
if (i > 0) {
throw new ServiceException(BizExceptionEnum.PRODUCT_ATTR_KEY_EXISTS);
}
if (ATTR_SOURCE_DEPEND.equals(productAttr.getSource())) {
if (productAttr.getDepAttrId() == null) {
throw new ServiceException(BizExceptionEnum.PRODUCT_ATTR_DEPTED_NULL);
}
ProductAttributeEvent productAttributeEvent = new QProductAttributeEvent().attrId.eq(productAttr.getDepAttrId()).findOne();
if (null == productAttributeEvent) {
throw new ServiceException(BizExceptionEnum.PRODUCT_ATTR_DEPTED_NOT_EXIST);
}
productAttr.setMasterItemId(productAttributeEvent.getZbxId());
}
return ResponseData.success(productAttributeEventService.updateTrapperItem(productAttr));
}
/**
* 删除 产品属性事件
*
* @return ResponseData
*/
@RequestMapping("/delete")
public ResponseData prodModelAttributeDelete(@RequestBody @Validated(BaseEntity.Delete.class) ProductAttr productAttr) {
productAttributeEventService.deleteTrapperItem(productAttr);
return ResponseData.success();
}
@Data
static class TemplateIds {
private String[] itemids;
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/product/controller/ProductAttributeEventController.java
|
Java
|
gpl-3.0
| 5,608
|
package com.zmops.iot.web.product.controller;
import cn.hutool.core.util.IdUtil;
import com.alibaba.fastjson.JSON;
import com.zmops.iot.domain.BaseEntity;
import com.zmops.iot.domain.device.Tag;
import com.zmops.iot.domain.device.query.QDevice;
import com.zmops.iot.domain.device.query.QTag;
import com.zmops.iot.domain.product.Product;
import com.zmops.iot.domain.product.query.*;
import com.zmops.iot.model.exception.ServiceException;
import com.zmops.iot.model.page.Pager;
import com.zmops.iot.model.response.ResponseData;
import com.zmops.iot.util.ToolUtil;
import com.zmops.iot.web.auth.Permission;
import com.zmops.iot.web.exception.enums.BizExceptionEnum;
import com.zmops.iot.web.product.dto.ProductBasicInfo;
import com.zmops.iot.web.product.dto.ProductDto;
import com.zmops.iot.web.product.dto.ProductTag;
import com.zmops.iot.web.product.dto.ValueMap;
import com.zmops.iot.web.product.service.ProductService;
import io.ebean.DB;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import javax.validation.Valid;
import java.util.ArrayList;
import java.util.List;
/**
* @author nantian created at 2021/8/3 19:44
* <p>
* 产品基本信息维护
*/
@Slf4j
@RestController
@RequestMapping("/product")
public class ProductController {
@Autowired
private ProductService productService;
/**
* 产品分页列表
*/
@Permission(code = "product_list")
@PostMapping("/getProductByPage")
public Pager<ProductDto> getProductByPage(@RequestBody ProductBasicInfo prodBasicInfo) {
return productService.getProductByPage(prodBasicInfo);
}
/**
* 产品列表
*/
@Permission(code = "product_list")
@PostMapping("/list")
public ResponseData prodList(@RequestBody ProductBasicInfo prodBasicInfo) {
return ResponseData.success(productService.prodList(prodBasicInfo));
}
/**
* 产品详情
*/
@Permission(code = "product_detail")
@GetMapping("/detail")
public ResponseData prodDetail(@RequestParam("productId") Long prodId) {
return ResponseData.success(productService.prodDetail(prodId));
}
/**
* 产品标签列表
*/
@Permission(code = "product")
@GetMapping("/tag/list")
public ResponseData prodTagList(@RequestParam("productId") String prodId) {
return ResponseData.success(productService.prodTagList(prodId));
}
/**
* 值映射列表
*/
@Permission(code = "product")
@GetMapping("/valueMap/list")
public ResponseData valueMapList(@RequestParam("productId") Long prodId) {
return ResponseData.success(productService.valueMapList(prodId));
}
/**
* 创建产品
*
* @param prodBasicInfo 产品基本信息
* @return
*/
@Permission(code = "product_add")
@PostMapping("/create")
public ResponseData prodCreate(@RequestBody @Validated(value = BaseEntity.Create.class) ProductBasicInfo prodBasicInfo) {
int i = new QProduct().productCode.eq(prodBasicInfo.getProdCode()).findCount();
if (i > 0) {
throw new ServiceException(BizExceptionEnum.PRODUCT_HAS_EXIST);
}
// 第一步：创建模板
Long prodId = IdUtil.getSnowflake().nextId();
String result = productService.zbxTemplateCreate(prodId + "");
// 第二步：创建产品
String zbxId = JSON.parseObject(result, TemplateIds.class).getTemplateids()[0];
productService.createProduct(zbxId, prodId, prodBasicInfo);
prodBasicInfo.setProductId(prodId);
return ResponseData.success(prodBasicInfo);
}
/**
* 更新产品
*
* @return
*/
@Permission(code = "product_update")
@PostMapping("/update")
public ResponseData prodUpdate(@RequestBody @Validated(value = BaseEntity.Update.class)
ProductBasicInfo prodBasicInfo) {
int i = new QProduct()
.productCode.eq(prodBasicInfo.getProdCode())
.productId.ne(prodBasicInfo.getProductId()).findCount();
if (i > 0) {
throw new ServiceException(BizExceptionEnum.PRODUCT_HAS_EXIST);
}
Product product = productService.updateProduct(prodBasicInfo);
return ResponseData.success(prodBasicInfo);
}
/**
* 删除产品
*
* @param prodBasicInfo 产品基础信息
* @return
*/
@Permission(code = "product_delete")
@PostMapping("/delete")
public ResponseData prodDelete(@RequestBody @Validated(value = BaseEntity.Delete.class)
ProductBasicInfo prodBasicInfo) {
//第一步：验证产品下 是否有设备存在
Product product = new QProduct().productId.eq(prodBasicInfo.getProductId()).findOne();
if (null == product) {
throw new ServiceException(BizExceptionEnum.PRODUCT_NOT_EXISTS);
}
int deviceNum = new QDevice().productId.eq(prodBasicInfo.getProductId()).findCount();
if (deviceNum > 0) {
throw new ServiceException(BizExceptionEnum.PRODUCT_HAS_BIND_DEVICE);
}
//第二步：删除Zabbix对应的模板
productService.zbxTemplateDelete(product.getZbxId() + "");
//删除关联信息
List<Long> statusFunctionRuleIds = new QProductStatusFunctionRelation().select(QProductStatusFunctionRelation.alias().ruleId).relationId.eq(product.getProductId() + "").findSingleAttributeList();
if (ToolUtil.isNotEmpty(statusFunctionRuleIds)) {
new QProductStatusFunction().ruleId.in(statusFunctionRuleIds).delete();
new QProductStatusFunctionRelation().relationId.eq(product.getProductId() + "").delete();
}
List<Long> serviceIds = new QProductServiceRelation().select(QProductServiceRelation.alias().serviceId).relationId.eq(product.getProductId() + "").findSingleAttributeList();
if (ToolUtil.isNotEmpty(serviceIds)) {
new QProductService().id.in(serviceIds).delete();
new QProductServiceParam().serviceId.in(serviceIds).delete();
new QProductServiceRelation().relationId.eq(product.getProductId() + "").delete();
}
List<Long> eventIds = new QProductEventRelation().select(QProductEventRelation.alias().eventRuleId).relationId.eq(product.getProductId() + "").findSingleAttributeList();
if (ToolUtil.isNotEmpty(eventIds)) {
new QProductEvent().eventRuleId.in(eventIds).delete();
new QProductEventExpression().eventRuleId.in(eventIds).delete();
new QProductEventService().eventRuleId.in(eventIds).delete();
new QProductEventRelation().relationId.eq(product.getProductId() + "").delete();
}
new QProductAttribute().productId.eq(product.getProductId() + "").delete();
new QProductAttributeEvent().productId.eq(product.getProductId() + "").delete();
//第三步：删除产品
boolean del = product.delete();
return ResponseData.success(del);
}
/**
* 产品创建 TAG
*
* @return
*/
@Permission(code = "product")
@PostMapping("/tag/update")
public ResponseData prodTagCreate(@RequestBody @Valid ProductTag productTag) {
String productId = productTag.getProductId();
Product product = new QProduct().productId.eq(Long.parseLong(productId)).findOne();
if (null == product) {
throw new ServiceException(BizExceptionEnum.PRODUCT_NOT_EXISTS);
}
new QTag().sid.eq(productTag.getProductId()).delete();
List<Tag> tags = new ArrayList<>();
for (ProductTag.Tag tag : productTag.getProductTag()) {
tags.add(Tag.builder()
.sid(productTag.getProductId())
.tag(tag.getTag()).value(tag.getValue())
.build()
);
}
DB.saveAll(tags);
String response = productService.updateTemplateTags(product.getZbxId(), productTag);
String templateId = JSON.parseObject(response, TemplateIds.class).getTemplateids()[0];
if (templateId.equals(product.getZbxId())) {
log.info("产品标签修改成功，ID：{}", templateId);
}
return ResponseData.success(productTag);
}
/**
* 产品创建值映射
*
* @param valueMap
* @return
*/
@Permission(code = "product")
@PostMapping("/valueMap/update")
public ResponseData prodValueMapCreate(@RequestBody @Validated(BaseEntity.Create.class) ValueMap valueMap) {
Product product = new QProduct().productId.eq(Long.parseLong(valueMap.getProductId())).findOne();
if (null == product) {
throw new ServiceException(BizExceptionEnum.PRODUCT_NOT_EXISTS);
}
String response = "";
if (ToolUtil.isEmpty(valueMap.getValuemapid())) {
response = productService.valueMapCreate(product.getZbxId(), valueMap.getValueMapName(), valueMap.getValueMaps());
} else {
response = productService.valueMapUpdate(product.getZbxId(), valueMap.getValueMapName(), valueMap.getValueMaps(), valueMap.getValuemapid());
}
String valuemapid = JSON.parseObject(response, TemplateIds.class).getValuemapids()[0];
return ResponseData.success(valuemapid);
}
/**
* 删除值映射
*
* @param valueMap
* @return
*/
@Permission(code = "product")
@PostMapping("/valueMap/delete")
public ResponseData prodValueMapDelete(@RequestBody @Validated(BaseEntity.Delete.class) ValueMap valueMap) {
String response = productService.valueMapDelete(valueMap.getValuemapid());
String valuemapid = JSON.parseObject(response, TemplateIds.class).getValuemapids()[0];
return ResponseData.success(valuemapid);
}
@Data
static class TemplateIds {
private String[] templateids;
private String[] valuemapids;
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/product/controller/ProductController.java
|
Java
|
gpl-3.0
| 10,169
|
package com.zmops.iot.web.product.controller;
import cn.hutool.core.util.IdUtil;
import com.alibaba.fastjson.JSONObject;
import com.zmops.iot.domain.BaseEntity;
import com.zmops.iot.domain.product.ProductEvent;
import com.zmops.iot.domain.product.ProductEventRelation;
import com.zmops.iot.domain.product.query.QProductEvent;
import com.zmops.iot.domain.product.query.QProductEventExpression;
import com.zmops.iot.domain.product.query.QProductEventRelation;
import com.zmops.iot.domain.product.query.QProductEventService;
import com.zmops.iot.enums.CommonStatus;
import com.zmops.iot.enums.InheritStatus;
import com.zmops.iot.model.exception.ServiceException;
import com.zmops.iot.model.page.Pager;
import com.zmops.iot.model.response.ResponseData;
import com.zmops.iot.util.ToolUtil;
import com.zmops.iot.web.event.applicationEvent.ProductEventTriggerCreateEvent;
import com.zmops.iot.web.event.applicationEvent.ProductEventTriggerUpdateEvent;
import com.zmops.iot.web.exception.enums.BizExceptionEnum;
import com.zmops.iot.web.product.dto.ProductEventDto;
import com.zmops.iot.web.product.dto.ProductEventRule;
import com.zmops.iot.web.product.dto.param.EventParm;
import com.zmops.iot.web.product.service.ProductEventRuleService;
import com.zmops.zeus.driver.service.ZbxTrigger;
import io.ebean.DB;
import io.ebean.annotation.Transactional;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Collectors;
/**
* @author nantian created at 2021/8/26 23:04
* <p>
* 产品 物模型功能 【告警规则】
*/
@RestController
@RequestMapping("/product/event/trigger")
public class ProductEventTriggerController {
@Autowired
private ProductEventRuleService productEventRuleService;
@Autowired
private ZbxTrigger zbxTrigger;
private static final String ALARM_TAG_NAME = "__alarm__";
private static final String EXECUTE_TAG_NAME = "__execute__";
@Autowired
ApplicationEventPublisher publisher;
/**
* 触发器 分页列表
*
* @param eventParm
* @return
*/
@PostMapping("/getEventByPage")
public Pager<ProductEventDto> getEventByPage(@Validated @RequestBody EventParm eventParm) {
return productEventRuleService.getEventByPage(eventParm);
}
/**
* 触发器 详情
*
* @param eventRuleId
* @return
*/
@GetMapping("/detail")
public ResponseData detail(@RequestParam("eventRuleId") long eventRuleId, @RequestParam("prodId") String prodId) {
ProductEvent productEvent = new QProductEvent().eventRuleId.eq(eventRuleId).findOne();
if (null == productEvent) {
throw new ServiceException(BizExceptionEnum.EVENT_NOT_EXISTS);
}
return ResponseData.success(productEventRuleService.detail(productEvent, eventRuleId, prodId));
}
/**
* 创建 触发器
*
* @param eventRule 触发器规则
* @return 触发器ID
*/
@Transactional
@PostMapping("/create")
public ResponseData createProductEventRule(@RequestBody @Validated(value = BaseEntity.Create.class)
ProductEventRule eventRule) {
Long eventRuleId = IdUtil.getSnowflake().nextId(); // ruleId, trigger name
eventRule.setEventRuleId(eventRuleId);
productEventRuleService.createProductEventRule(eventRule);
//step 1: 先创建 zbx 触发器
String expression = eventRule.getExpList()
.stream().map(Object::toString).collect(Collectors.joining(" " + eventRule.getExpLogic() + " "));
//step 2: zbx 保存触发器
String[] triggerIds = productEventRuleService.createZbxTrigger(eventRuleId + "", expression, eventRule.getEventLevel());
//step 4: zbx 触发器创建 Tag
Map<String, String> tags = new ConcurrentHashMap<>(3);
if (ToolUtil.isNotEmpty(eventRule.getTags())) {
tags = eventRule.getTags().stream()
.collect(Collectors.toMap(ProductEventRule.Tag::getTag, ProductEventRule.Tag::getValue, (k1, k2) -> k2));
}
if (!tags.containsKey(ALARM_TAG_NAME)) {
tags.put(ALARM_TAG_NAME, "{HOST.HOST}");
}
if (ToolUtil.isNotEmpty(eventRule.getDeviceServices()) && !tags.containsKey(EXECUTE_TAG_NAME)) {
tags.put(EXECUTE_TAG_NAME, eventRuleId + "");
}
// Optional<ProductEventRule.Expression> any = eventRule.getExpList().parallelStream().filter(o -> EVENT_TYPE_NAME.equals(o.getProductAttrType())).findAny();
// if (any.isPresent()) {
// tags.put(EVENT_TAG_NAME, eventRuleId + "");
// }
for (String triggerId : triggerIds) {
zbxTrigger.triggerTagCreate(triggerId, tags);
}
//step 5: 更新 zbxId
productEventRuleService.updateProductEventRuleZbxId(eventRuleId, triggerIds);
//step 6: 同步到产品下的设备
publisher.publishEvent(new ProductEventTriggerCreateEvent(this,eventRule));
// 返回触发器ID
return ResponseData.success(eventRuleId);
}
/**
* 修改 触发器
*
* @param eventRule 触发器规则
* @return 触发器ID
*/
@Transactional
@PostMapping("/update")
public ResponseData updateProductEventRule(@RequestBody @Validated(value = BaseEntity.Update.class) ProductEventRule eventRule) {
//step 1: 更新所有服务
productEventRuleService.updateProductEventRule(eventRule.getEventRuleId(), eventRule);
//step 2: 更新zbx表达式
String expression = eventRule.getExpList()
.stream().map(Object::toString).collect(Collectors.joining(" " + eventRule.getExpLogic() + " "));
ProductEvent event = new QProductEvent().eventRuleId.eq(eventRule.getEventRuleId()).findOne();
if (event == null) {
throw new ServiceException(BizExceptionEnum.EVENT_NOT_EXISTS);
}
List<ProductEventRelation> list = new QProductEventRelation().eventRuleId.eq(event.getEventRuleId()).inherit.eq(InheritStatus.NO.getCode()).findList();
if (list.isEmpty()) {
throw new ServiceException(BizExceptionEnum.EVENT_EXPRESSION_NOT_EXISTS);
}
zbxTrigger.triggerUpdate(list.get(0).getZbxId(), expression, eventRule.getEventLevel());
//step 3: zbx 触发器创建 Tag
Map<String, String> tags = eventRule.getTags().stream()
.collect(Collectors.toMap(ProductEventRule.Tag::getTag, ProductEventRule.Tag::getValue, (k1, k2) -> k2));
if (ToolUtil.isEmpty(tags)) {
tags = new HashMap<>(2);
}
if (!tags.containsKey(ALARM_TAG_NAME)) {
tags.put(ALARM_TAG_NAME, "{HOST.HOST}");
}
// if (ToolUtil.isNotEmpty(eventRule.getDeviceServices()) && !tags.containsKey(EXECUTE_TAG_NAME)) {
// tags.put(EXECUTE_TAG_NAME, eventRule.getEventRuleId() + "");
// }
// Optional<ProductEventRule.Expression> any = eventRule.getExpList().parallelStream().filter(o -> EVENT_TYPE_NAME.equals(o.getProductAttrType())).findAny();
// if (any.isPresent()) {
// tags.put(EVENT_TAG_NAME, eventRule.getEventRuleId() + "");
// }
zbxTrigger.triggerTagCreate(list.get(0).getZbxId(), tags);
//step 4: 同步到产品下的设备
publisher.publishEvent(new ProductEventTriggerUpdateEvent(this,eventRule));
return ResponseData.success(eventRule.getEventRuleId());
}
/**
* 修改 触发器
*
* @param eventRule 触发器规则
* @return 触发器ID
*/
@PostMapping("/status")
public ResponseData updateProductEventStatus(@RequestBody @Validated(value = BaseEntity.Status.class) ProductEventRule eventRule) {
DB.update(ProductEventRelation.class).where().eq("eventRuleId", eventRule.getEventRuleId()).asUpdate().set("status", eventRule.getStatus()).update();
ProductEventRelation productEventRelation = new QProductEventRelation().eventRuleId.eq(eventRule.getEventRuleId()).inherit.eq("0").findOne();
if (null != productEventRelation && null != productEventRelation.getZbxId()) {
zbxTrigger.triggerStatusUpdate(productEventRelation.getZbxId(), eventRule.getStatus().equals(CommonStatus.ENABLE.getCode()) ? "0" : "1");
}
return ResponseData.success();
}
/**
* 删除 触发器
*
* @param eventRule 触发器规则
* @return 触发器ID
*/
@Transactional
@PostMapping("/delete")
public ResponseData deleteProductEventRule(@RequestBody @Validated(value = BaseEntity.Delete.class)
ProductEventRule eventRule) {
ProductEventRelation productEventRelation = new QProductEventRelation().eventRuleId.eq(eventRule.getEventRuleId()).inherit.eq("0").findOne();
if (null == productEventRelation) {
return ResponseData.success();
}
//step 01:删除 zbx触发器
String s = zbxTrigger.triggerGet(productEventRelation.getZbxId());
List<ProductEventRuleService.Triggers> triggers = JSONObject.parseArray(s, ProductEventRuleService.Triggers.class);
if (ToolUtil.isNotEmpty(triggers)) {
zbxTrigger.triggerDelete(productEventRelation.getZbxId());
}
//step 1:删除 与产品 设备的关联
new QProductEventRelation().eventRuleId.eq(eventRule.getEventRuleId()).delete();
//step 2:删除 关联的执行服务
new QProductEventService().eventRuleId.eq(eventRule.getEventRuleId()).delete();
//step 3:删除 关联的表达式
new QProductEventExpression().eventRuleId.eq(eventRule.getEventRuleId()).delete();
//step 4:删除 触发器
new QProductEvent().eventRuleId.eq(eventRule.getEventRuleId()).delete();
return ResponseData.success();
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/product/controller/ProductEventTriggerController.java
|
Java
|
gpl-3.0
| 10,225
|
package com.zmops.iot.web.product.controller;
import cn.hutool.core.util.IdUtil;
import com.alibaba.fastjson.JSON;
import com.zmops.iot.domain.BaseEntity;
import com.zmops.iot.domain.product.ProductAttribute;
import com.zmops.iot.domain.product.query.QProductAttribute;
import com.zmops.iot.model.exception.ServiceException;
import com.zmops.iot.model.page.Pager;
import com.zmops.iot.model.response.ResponseData;
import com.zmops.iot.web.exception.enums.BizExceptionEnum;
import com.zmops.iot.web.product.dto.ProductAttr;
import com.zmops.iot.web.product.dto.ProductAttrDto;
import com.zmops.iot.web.product.dto.param.ProductAttrParam;
import com.zmops.iot.web.product.service.ProductModelService;
import lombok.Data;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
/**
* @author nantian created at 2021/8/3 19:44
* <p>
* 产品物模型： 属性
*/
@RestController
@RequestMapping("/product/model")
public class ProductModelController {
@Autowired
private ProductModelService productModelService;
//依赖属性类型
private static final String ATTR_SOURCE_DEPEND = "18";
/**
* 产品物模型 属性 分页列表
*
* @return ResponseData
*/
@RequestMapping("/getAttrTrapperByPage")
public Pager<ProductAttrDto> prodModelAttributeList(@RequestBody ProductAttrParam productAttr) {
return productModelService.prodModelAttributeList(productAttr);
}
/**
* 产品物模型 属性 列表
*
* @return ResponseData
*/
@RequestMapping("/list")
public ResponseData list(@RequestBody ProductAttrParam productAttr) {
return ResponseData.success(productModelService.list(productAttr));
}
/**
* 产品物模型 属性详情
*
* @return ResponseData
*/
@RequestMapping("/detail")
public ResponseData detail(@RequestParam(value = "attrId") Long attrId) {
return ResponseData.success(productModelService.detail(attrId));
}
/**
* 创建 产品物模型 属性
*
* @return ResponseData
*/
@RequestMapping("/attr/trapper/create")
public ResponseData prodModelAttributeCreate(@RequestBody @Validated(BaseEntity.Create.class) ProductAttr productAttr) {
int i = new QProductAttribute().productId.eq(productAttr.getProductId()).key.eq(productAttr.getKey()).findCount();
if (i > 0) {
throw new ServiceException(BizExceptionEnum.PRODUCT_ATTR_KEY_EXISTS);
}
if (ATTR_SOURCE_DEPEND.equals(productAttr.getSource())) {
if (productAttr.getDepAttrId() == null) {
throw new ServiceException(BizExceptionEnum.PRODUCT_ATTR_DEPTED_NULL);
}
ProductAttribute productAttribute = new QProductAttribute().attrId.eq(productAttr.getDepAttrId()).findOne();
if (null == productAttribute) {
throw new ServiceException(BizExceptionEnum.PRODUCT_ATTR_DEPTED_NOT_EXIST);
}
productAttr.setMasterItemId(productAttribute.getZbxId());
}
Long attrId = IdUtil.getSnowflake().nextId();
productAttr.setAttrId(attrId);
String response = productModelService.createTrapperItem(productAttr);
String zbxId = JSON.parseObject(response, TemplateIds.class).getItemids()[0];
productModelService.createProductAttr(productAttr, zbxId);
return ResponseData.success(productAttr);
}
/**
* 修改 产品物模型 属性
*
* @return ResponseData
*/
@RequestMapping("/attr/trapper/update")
public ResponseData prodModelAttributeUpdate(@RequestBody @Validated(BaseEntity.Update.class) ProductAttr productAttr) {
int i = new QProductAttribute().productId.eq(productAttr.getProductId()).key.eq(productAttr.getKey())
.attrId.ne(productAttr.getAttrId()).findCount();
if (i > 0) {
throw new ServiceException(BizExceptionEnum.PRODUCT_ATTR_KEY_EXISTS);
}
if (ATTR_SOURCE_DEPEND.equals(productAttr.getSource())) {
if (productAttr.getDepAttrId() == null) {
throw new ServiceException(BizExceptionEnum.PRODUCT_ATTR_DEPTED_NULL);
}
ProductAttribute productAttribute = new QProductAttribute().attrId.eq(productAttr.getDepAttrId()).findOne();
if (null == productAttribute) {
throw new ServiceException(BizExceptionEnum.PRODUCT_ATTR_DEPTED_NOT_EXIST);
}
productAttr.setMasterItemId(productAttribute.getZbxId());
}
return ResponseData.success(productModelService.updateTrapperItem(productAttr));
}
/**
* 删除 产品物模型 属性
*
* @return ResponseData
*/
@RequestMapping("/attr/trapper/delete")
public ResponseData prodModelAttributeDelete(@RequestBody @Validated(BaseEntity.Delete.class) ProductAttr productAttr) {
productModelService.deleteTrapperItem(productAttr);
return ResponseData.success();
}
@Data
static class TemplateIds {
private String[] itemids;
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/product/controller/ProductModelController.java
|
Java
|
gpl-3.0
| 5,407
|
package com.zmops.iot.web.product.controller;
import com.zmops.iot.domain.BaseEntity;
import com.zmops.iot.model.page.Pager;
import com.zmops.iot.model.response.ResponseData;
import com.zmops.iot.web.product.dto.ProductServiceDto;
import com.zmops.iot.web.product.dto.param.ProductSvcParam;
import com.zmops.iot.web.product.service.ProductSvcService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
/**
* @author nantian created at 2021/8/4 16:33
* <p>
* 产品物模型： 服务
*/
@RestController
@RequestMapping("/product/service")
public class ProductServiceController {
@Autowired
ProductSvcService productSvcService;
/**
* 服务分页列表
*/
@RequestMapping("/getServiceByPage")
public Pager<ProductServiceDto> getServiceByPage(@Validated @RequestBody ProductSvcParam productSvcParam) {
return productSvcService.getServiceByPage(productSvcParam);
}
/**
* 服务列表
*/
@RequestMapping("/list")
public ResponseData list(@Validated @RequestBody ProductSvcParam productSvcParam) {
return ResponseData.success(productSvcService.list(productSvcParam));
}
/**
* 根据服务 获取参数列表
*/
@RequestMapping("/param/list")
public ResponseData paramList(@RequestParam("serviceId") long serviceId) {
return ResponseData.success(productSvcService.paramList(serviceId));
}
/**
* 服务创建
*/
@RequestMapping("/create")
public ResponseData create(@Validated(BaseEntity.Create.class) @RequestBody ProductServiceDto productServiceDto) {
productServiceDto.setId(null);
return ResponseData.success(productSvcService.create(productServiceDto));
}
/**
* 服务修改
*/
@RequestMapping("/update")
public ResponseData update(@Validated(BaseEntity.Update.class) @RequestBody ProductServiceDto productServiceDto) {
return ResponseData.success(productSvcService.update(productServiceDto));
}
/**
* 服务删除
*/
@RequestMapping("/delete")
public ResponseData delete(@Validated(BaseEntity.Delete.class) @RequestBody ProductServiceDto productServiceDto) {
productSvcService.delete(productServiceDto.getIds());
return ResponseData.success(productServiceDto.getIds());
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/product/controller/ProductServiceController.java
|
Java
|
gpl-3.0
| 2,634
|
package com.zmops.iot.web.product.controller;
import com.zmops.iot.domain.BaseEntity;
import com.zmops.iot.domain.product.ProductAttribute;
import com.zmops.iot.domain.product.ProductStatusFunction;
import com.zmops.iot.domain.product.query.QProductAttribute;
import com.zmops.iot.domain.product.query.QProductStatusFunction;
import com.zmops.iot.domain.product.query.QProductStatusFunctionRelation;
import com.zmops.iot.model.exception.ServiceException;
import com.zmops.iot.model.response.ResponseData;
import com.zmops.iot.web.exception.enums.BizExceptionEnum;
import com.zmops.iot.web.product.dto.ProductStatusJudgeRule;
import com.zmops.iot.web.product.service.ProductTriggerService;
import com.zmops.zeus.driver.service.ZbxItem;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
/**
* @author nantian created at 2021/8/3 19:45
* <p>
* 设备在线 离线状态 触发器
*/
@RestController
@RequestMapping("/product/status/trigger")
public class ProductStatusTriggerController {
@Autowired
private ZbxItem zbxItem;
@Autowired
private ProductTriggerService productTriggerService;
/**
* 离线 或者 在线触发器 信息
*
* @param relationId 关联产品或设备ID
* @return ResponseData
*/
@GetMapping("/detail")
public ResponseData getRule(@RequestParam("relationId") String relationId) {
return ResponseData.success(productTriggerService.getRule(relationId));
}
/**
* 创建 离线 或者 在线触发器
*
* @param rule 在线规则
* @return ResponseData
*/
@PostMapping("/create")
public ResponseData createDeviceStatusTrigger(@RequestBody @Validated(BaseEntity.Create.class) ProductStatusJudgeRule rule) {
ProductAttribute prodAttr = new QProductAttribute().attrId.eq(rule.getAttrId()).findOne();
ProductAttribute prodAttrSecond = new QProductAttribute().attrId.eq(rule.getAttrIdRecovery()).findOne();
if (null == prodAttr || null == prodAttrSecond) {
throw new ServiceException(BizExceptionEnum.PRODUCT_ATTR_KEY_NOT_EXISTS);
}
int count = new QProductStatusFunctionRelation().relationId.eq(rule.getRelationId()).findCount();
if (count > 0) {
throw new ServiceException(BizExceptionEnum.RULE_EXISTS);
}
return ResponseData.success(productTriggerService.createDeviceStatusJudgeTrigger(rule));
}
/**
* 修改 离线 或者 在线触发器
*
* @param rule 在线规则
* @return ResponseData
*/
@PostMapping("/update")
public ResponseData updateDeviceStatusTrigger(@RequestBody @Validated(BaseEntity.Update.class) ProductStatusJudgeRule rule) {
ProductAttribute prodAttr = new QProductAttribute().attrId.eq(rule.getAttrId()).findOne();
ProductAttribute prodAttrSecond = new QProductAttribute().attrId.eq(rule.getAttrIdRecovery()).findOne();
if (null == prodAttr || null == prodAttrSecond) {
throw new ServiceException(BizExceptionEnum.PRODUCT_ATTR_KEY_NOT_EXISTS);
}
// 数据库查询 triggerId 并且赋值
ProductStatusFunction productStatusFunction = new QProductStatusFunction().ruleId.eq(rule.getRuleId()).findOne();
if (null == productStatusFunction) {
throw new ServiceException(BizExceptionEnum.RULE_NOT_EXISTS);
}
return ResponseData.success(productTriggerService.updateDeviceStatusJudgeTrigger(rule));
}
/**
* 删除 离线 或者 在线触发器
*
* @param rule 在线规则
* @return ResponseData
*/
@PostMapping("/delete")
public ResponseData deleteDeviceStatusTrigger(@RequestBody @Validated(BaseEntity.Delete.class) ProductStatusJudgeRule rule) {
productTriggerService.deleteDeviceStatusTrigger(rule.getRuleId());
return ResponseData.success();
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/product/controller/ProductStatusTriggerController.java
|
Java
|
gpl-3.0
| 4,013
|
package com.zmops.iot.web.product.controller;
import com.zmops.iot.core.log.BussinessLog;
import com.zmops.iot.domain.BaseEntity;
import com.zmops.iot.model.response.ResponseData;
import com.zmops.iot.web.auth.Permission;
import com.zmops.iot.web.product.dto.param.ProductTypeParam;
import com.zmops.iot.web.product.service.ProductTypeService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* @author yefei
* <p>
* 产品分类信息维护
*/
@Slf4j
@RestController
@RequestMapping("/productType")
public class ProductTypeController {
@Autowired
private ProductTypeService productTypeService;
/**
* 产品分类树
*/
@Permission(code = "product_type")
@RequestMapping("/tree")
public ResponseData tree() {
return ResponseData.success(productTypeService.tree());
}
/**
* 新增产品分类
*/
@Permission(code = "product_type")
@RequestMapping("/create")
@BussinessLog("新增产品分类")
public ResponseData create(@Validated(BaseEntity.Create.class) @RequestBody ProductTypeParam productType) {
return ResponseData.success(productTypeService.create(productType));
}
/**
* 修改产品分类
*/
@Permission(code = "product_type")
@RequestMapping("/update")
@BussinessLog("修改产品分类")
public ResponseData update(@Validated(BaseEntity.Update.class) @RequestBody ProductTypeParam productType) {
return ResponseData.success(productTypeService.update(productType));
}
/**
* 删除产品分类
*/
@Permission(code = "product_type")
@RequestMapping("/delete")
@BussinessLog("删除产品分类")
public ResponseData delete(@Validated(BaseEntity.Delete.class) @RequestBody ProductTypeParam productType) {
productTypeService.delete(productType);
return ResponseData.success();
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/product/controller/ProductTypeController.java
|
Java
|
gpl-3.0
| 2,178
|
package com.zmops.iot.web.product.dto;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.zmops.iot.domain.BaseEntity;
import lombok.Data;
import lombok.Getter;
import lombok.Setter;
import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.NotNull;
import java.time.LocalDateTime;
import java.util.List;
/**
* @author nantian created at 2021/8/5 13:53
* <p>
* dto for product attribute
*/
@Data
public class ProductAttr {
@NotNull(groups = BaseEntity.Update.class)
private Long attrId;
//属性名 非 item name
@NotNull(groups = {BaseEntity.Update.class, BaseEntity.Create.class})
private String attrName;
@NotNull(groups = {BaseEntity.Update.class, BaseEntity.Create.class})
private String key;
private String units;
//来源：设备 trapper ，属性依赖 dependent
@NotNull(groups = {BaseEntity.Update.class, BaseEntity.Create.class})
private String source;
private Byte eventLevel = 1;
private String remark;
private Long depAttrId;
@JsonIgnore
private String masterItemId;
@JsonIgnore
private String zbxId;
@NotNull(groups = {BaseEntity.Update.class, BaseEntity.Create.class})
private String productId;
@NotNull(groups = {BaseEntity.Update.class, BaseEntity.Create.class})
private String valueType;
private String valuemapid;
private List<ProductTag.Tag> tags;
//预处理
private List<ProcessingStep> processStepList;
@NotEmpty(groups = BaseEntity.Delete.class)
private List<Long> attrIds;
private Integer delay;
//取数间隔单位
private String unit;
LocalDateTime createTime;
LocalDateTime updateTime;
Long createUser;
Long updateUser;
/**
* 预处理步骤
*/
public static class ProcessingStep {
@Getter
@Setter
private String type;
@Setter
private String[] params;
@Getter
@Setter
private String errorHandler;
@Getter
@Setter
private String errorHandlerParams;
public String getParams() {
StringBuilder paramStr = new StringBuilder();
if (null != params && params.length > 0) {
for (String param : params) {
paramStr.append(param).append("\\\\n");
}
return paramStr.substring(0, paramStr.length() - 3);
}
return "";
}
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/product/dto/ProductAttr.java
|
Java
|
gpl-3.0
| 2,490
|
package com.zmops.iot.web.product.dto;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.zmops.iot.model.cache.filter.CachedValue;
import com.zmops.iot.model.cache.filter.CachedValueFilter;
import com.zmops.iot.model.cache.filter.DicType;
import lombok.Data;
import java.time.LocalDateTime;
import java.util.List;
/**
* @author nantian created at 2021/8/5 13:53
* <p>
* dto for product attribute
*/
@Data
@JsonSerialize(using = CachedValueFilter.class)
public class ProductAttrDto {
private Long attrId;
@JsonProperty("attrName")
private String name;
private String key;
@CachedValue(value = "UNITS", fieldName = "unitsName")
private String units;
@CachedValue(value = "ATTR_TYPE", fieldName = "sourceName")
private String source;
private String remark;
private Long depAttrId;
@CachedValue(value = "EVENT_LEVEL", fieldName = "eventLevelName")
private String eventLevel;
@JsonIgnore
private String zbxId;
private String productId;
@CachedValue(value = "DATA_TYPE", fieldName = "valueTypeName")
private String valueType;
private String valuemapid;
private List<ProductTag.Tag> tags;
//预处理
@JsonIgnore
private List<ProductAttr.ProcessingStep> processStepList;
private Long templateId;
private LocalDateTime createTime;
private LocalDateTime updateTime;
@CachedValue(type = DicType.SysUserName, fieldName = "createUserName")
private Long createUser;
@CachedValue(type = DicType.SysUserName, fieldName = "updateUserName")
private Long updateUser;
private String clock;
private String value;
private String originalValue;
private Integer delay;
private String delayName;
//取数间隔单位
private String unit;
private String error;
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/product/dto/ProductAttrDto.java
|
Java
|
gpl-3.0
| 1,946
|
package com.zmops.iot.web.product.dto;
import com.zmops.iot.domain.BaseEntity;
import com.zmops.iot.web.sys.dto.param.BaseQueryParam;
import lombok.Data;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Pattern;
/**
* @author nantian created at 2021/8/3 19:46
*/
@Data
public class ProductBasicInfo extends BaseQueryParam {
@NotNull(groups = {BaseEntity.Update.class, BaseEntity.Delete.class})
private Long productId;
@NotNull(groups = {BaseEntity.Update.class, BaseEntity.Create.class})
private Long groupId; //产品分类ID
@NotNull(groups = {BaseEntity.Update.class, BaseEntity.Create.class})
@Pattern(regexp = "^[A-Za-z0-9]+$",
message = "产品编号不能包含中文字符")
private String prodCode; //产品编号
@NotNull(groups = {BaseEntity.Update.class, BaseEntity.Create.class})
private String prodName; //产品名称
@NotNull(groups = {BaseEntity.Update.class, BaseEntity.Create.class})
private String prodType; //产品类型
private String manufacturer; //产品厂商
private String model; //产品型号
private String remark; //备注
private String tag;
private String tagVal;
private Long tenantId;
private String icon;
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/product/dto/ProductBasicInfo.java
|
Java
|
gpl-3.0
| 1,279
|
package com.zmops.iot.web.product.dto;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.zmops.iot.model.cache.filter.CachedValue;
import com.zmops.iot.model.cache.filter.CachedValueFilter;
import com.zmops.iot.model.cache.filter.DicType;
import lombok.Data;
import java.time.LocalDateTime;
/**
* @author yefei
**/
@Data
@JsonSerialize(using = CachedValueFilter.class)
public class ProductDto {
private Long productId;
@CachedValue(type = DicType.ProdType, fieldName = "groupName")
private Long groupId;
@JsonProperty("prodName")
private String name;
@JsonProperty("prodType")
@CachedValue(value = "DEVICE_TYPE", fieldName = "typeName")
private String type;
private String manufacturer;
private String model;
private String remark;
@JsonProperty("prodCode")
private String productCode;
private String zbxId;
private LocalDateTime createTime;
private LocalDateTime updateTime;
@CachedValue(type = DicType.SysUserName, fieldName = "createUserName")
private Long createUser;
@CachedValue(type = DicType.SysUserName, fieldName = "updateUserName")
private Long updateUser;
private Long deviceNum;
@CachedValue(type = DicType.Tenant, fieldName = "tenantName")
private Long tenantId;
private String icon;
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/product/dto/ProductDto.java
|
Java
|
gpl-3.0
| 1,414
|
package com.zmops.iot.web.product.dto;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.zmops.iot.model.cache.filter.CachedValue;
import com.zmops.iot.model.cache.filter.CachedValueFilter;
import com.zmops.iot.model.cache.filter.DicType;
import lombok.Data;
/**
* @author yefei
**/
@Data
@JsonSerialize(using = CachedValueFilter.class)
public class ProductEventDto {
private Long eventRuleId;
private Byte eventNotify;
private String eventRuleName;
@CachedValue(value = "EVENT_LEVEL", fieldName = "eventLevelName")
private String eventLevel;
@CachedValue(value = "STATUS", fieldName = "statusName")
private String status;
@CachedValue(value = "WHETHER", fieldName = "inheritName")
private String inherit;
private String remark;
private String classify;
private String expLogic;
@CachedValue(type = DicType.SysUserName, fieldName = "createUserName")
private Long createUser;
private String createTime;
@CachedValue(type = DicType.SysUserName, fieldName = "updateUserName")
private Long updateUser;
private String updateTime;
@CachedValue(type= DicType.Tenant, fieldName = "tenantName")
private Long tenantId;
private Integer taskId;
@CachedValue(value = "triggerType", fieldName = "triggerTypeName")
private String triggerType;
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/product/dto/ProductEventDto.java
|
Java
|
gpl-3.0
| 1,363
|
package com.zmops.iot.web.product.dto;
import com.zmops.iot.domain.BaseEntity;
import com.zmops.iot.util.ToolUtil;
import lombok.Data;
import lombok.Getter;
import lombok.Setter;
import org.apache.commons.lang.StringUtils;
import javax.validation.Valid;
import javax.validation.constraints.Max;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.NotNull;
import java.util.List;
/**
* @author nantian created at 2021/9/14 14:47
* <p>
* 告警规则
*/
@Getter
@Setter
public class ProductEventRule {
@NotNull(groups = {BaseEntity.Update.class, BaseEntity.Delete.class, BaseEntity.Status.class})
private Long eventRuleId;
@NotNull(groups = {BaseEntity.Create.class, BaseEntity.Update.class})
private Byte eventNotify; // 0 否 1 是，默认 1
// 告警规则名称
@NotBlank(groups = {BaseEntity.Create.class, BaseEntity.Update.class})
private String eventRuleName;
// 告警规则级别
@NotNull(groups = {BaseEntity.Create.class, BaseEntity.Update.class})
private Byte eventLevel;
// 表达式列表
@Valid
@NotEmpty(groups = {BaseEntity.Create.class, BaseEntity.Update.class})
private List<Expression> expList;
@NotBlank(groups = {BaseEntity.Create.class, BaseEntity.Update.class})
private String expLogic; // and or
private String remark;
private List<DeviceService> deviceServices;
private List<Tag> tags;
@NotNull(groups = BaseEntity.Update.class)
private String zbxId;
@NotBlank(groups = BaseEntity.Create.class)
private String productId; // 产品ID
@NotBlank(groups = BaseEntity.Status.class)
private String status;
private String classify = "0";
@Data
public static class Tag {
@Max(20)
private String tag;
@Max(50)
private String value;
}
@Getter
@Setter
// 告警表达式 构成
public static class Expression {
private Long eventExpId;
@NotBlank(groups = {BaseEntity.Create.class, BaseEntity.Update.class})
private String function; // last avg max min sum change nodata
private String scope; // s m h T
@NotBlank(groups = {BaseEntity.Create.class, BaseEntity.Update.class})
private String condition; // > < = <> >= <=
@NotBlank(groups = {BaseEntity.Create.class, BaseEntity.Update.class})
private String value;
@NotNull(groups = {BaseEntity.Create.class, BaseEntity.Update.class})
private String productAttrKey; // 产品属性 Key
private String productId; // 产品 ID
private String unit;
private Long productAttrId;
private String productAttrType;
private String attrValueType;
private String period;
@Override
public String toString() {
StringBuilder expression = new StringBuilder();
expression.append(function);
expression.append("(/");
expression.append(productId);
expression.append("/");
expression.append(productAttrKey);
if (StringUtils.isNotBlank(scope)) {
expression.append(", ");
expression.append(scope);
}
expression.append(") ").append(condition).append(" ").append(ToolUtil.addQuotes(value));
return expression.toString();
}
}
@Setter
@Getter
public static class DeviceService {
private String deviceId;
private String executeDeviceId;
private Long serviceId;
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/product/dto/ProductEventRule.java
|
Java
|
gpl-3.0
| 3,634
|
package com.zmops.iot.web.product.dto;
import com.zmops.iot.domain.product.ProductEventExpression;
import com.zmops.iot.domain.product.ProductEventService;
import com.zmops.iot.model.cache.filter.CachedValue;
import lombok.Data;
import lombok.Getter;
import lombok.Setter;
import javax.validation.constraints.Max;
import javax.validation.constraints.NotNull;
import java.util.List;
/**
* @author nantian created at 2021/9/14 14:47
* <p>
* 告警规则
*/
@Getter
@Setter
public class ProductEventRuleDto {
private Long eventRuleId;
private Byte eventNotify;
private String eventRuleName;
private Byte eventLevel;
private List<ProductEventExpression> expList;
private String expLogic;
private String remark;
private List<ProductEventService> deviceServices;
private List<Tag> tags;
private String zbxId;
private String productId;
private String status;
private String inherit;
private String inheritProductId;
private String scheduleConf;
@CachedValue(value = "triggerType", fieldName = "triggerTypeName")
private Integer triggerType;
private Integer taskId;
@Data
public static class Tag {
@Max(20)
private String tag;
@Max(50)
private String value;
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/product/dto/ProductEventRuleDto.java
|
Java
|
gpl-3.0
| 1,303
|
package com.zmops.iot.web.product.dto;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.zmops.iot.domain.BaseEntity;
import com.zmops.iot.domain.product.ProductServiceParam;
import com.zmops.iot.model.cache.filter.CachedValue;
import com.zmops.iot.model.cache.filter.CachedValueFilter;
import lombok.Data;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
import java.util.List;
/**
* @author yefei
**/
@Data
@JsonSerialize(using = CachedValueFilter.class)
public class ProductServiceDto {
@NotNull(groups = BaseEntity.Update.class)
private Long id;
@NotBlank(groups = BaseEntity.Create.class)
private String name;
private String mark;
private String remark;
@NotNull(groups = BaseEntity.Create.class)
private String relationId;
@CachedValue(value = "EXECUTE_TYPE", fieldName = "asyncName")
private String async;
@CachedValue(value = "WHETHER", fieldName = "inheritName")
private String inherit;
private List<ProductServiceParam> productServiceParamList;
@NotNull(groups = BaseEntity.Delete.class)
private List<Long> ids;
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/product/dto/ProductServiceDto.java
|
Java
|
gpl-3.0
| 1,165
|
package com.zmops.iot.web.product.dto;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.zmops.iot.model.cache.filter.CachedValue;
import com.zmops.iot.model.cache.filter.CachedValueFilter;
import com.zmops.iot.model.cache.filter.DicType;
import lombok.Data;
/**
* @author nantian created at 2021/8/5 16:06
* <p>
* 设备 离线/上线 规则 last(/Zabbix server/system.cpu.util[,user])>10
*/
@Data
@JsonSerialize(using = CachedValueFilter.class)
public class ProductStatusFunctionDto {
private String relationId;
private Long ruleId;
private Long attrId;
private Integer ruleStatus;
private String ruleFunction;
private String ruleCondition;
@CachedValue(value = "UNITS", fieldName = "unitName")
private String unit;
@CachedValue(value = "UNITS", fieldName = "unitsName")
private String units;
@CachedValue(value = "UNITS", fieldName = "unitsRecoveryName")
private String unitsRecovery;
private String productAttrKey;
private Long attrIdRecovery;
private String ruleFunctionRecovery;
private String ruleConditionRecovery;
private String productAttrKeyRecovery;
@CachedValue(value = "UNITS", fieldName = "unitRecoveryName")
private String unitRecovery;
private String attrName;
private String attrNameRecovery;
@CachedValue(type = DicType.SysUserName, fieldName = "createUserName")
private Long createUser;
private String createTime;
@CachedValue(type = DicType.SysUserName, fieldName = "updateUserName")
private Long updateUser;
private String updateTime;
private String zbxIdRecovery;
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/product/dto/ProductStatusFunctionDto.java
|
Java
|
gpl-3.0
| 1,653
|
package com.zmops.iot.web.product.dto;
import com.zmops.iot.domain.BaseEntity;
import lombok.Data;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
/**
* @author nantian created at 2021/8/5 16:06
* <p>
* 设备 离线/上线 规则 last(/Zabbix server/system.cpu.util[,user])>10
*/
@Data
public class ProductStatusJudgeRule {
@NotBlank(groups = {BaseEntity.Create.class})
private String relationId; // deviceid
@NotNull(groups = {BaseEntity.Update.class, BaseEntity.Delete.class})
private Long ruleId; // 自动生成，trigger name
private String ruleName;
//##################### 下线规则
@NotNull(groups = {BaseEntity.Create.class})
private Long attrId; // 设备属性ID
@NotBlank(groups = {BaseEntity.Create.class})
private String ruleFunction; // nodata 或者 > < = 函数
@NotBlank(groups = {BaseEntity.Create.class})
private String ruleCondition; // 时间 或者 特定值
@NotNull(groups = {BaseEntity.Create.class})
private String unit; //单位 s m h 或空
@NotBlank(groups = {BaseEntity.Create.class})
private String productAttrKey; // 属性 Key
//##################### 上线规则
@NotNull(groups = {BaseEntity.Create.class})
private Long attrIdRecovery; // 设备属性ID
@NotBlank(groups = {BaseEntity.Create.class})
private String ruleFunctionRecovery; // nodata 或者 > < = 函数
@NotBlank(groups = {BaseEntity.Create.class})
private String ruleConditionRecovery; // 时间 或者 特定值
@NotBlank(groups = {BaseEntity.Create.class})
private String productAttrKeyRecovery; // 属性 Key
private String unitRecovery;
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/product/dto/ProductStatusJudgeRule.java
|
Java
|
gpl-3.0
| 1,725
|
package com.zmops.iot.web.product.dto;
import lombok.Data;
import javax.validation.Valid;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Pattern;
import javax.validation.constraints.Size;
import java.util.List;
/**
* @author nantian created at 2021/8/4 11:44
* <p>
* 产品标签
*/
@Data
public class ProductTag {
@NotNull
private String productId;
@Valid
private List<Tag> productTag;
@Data
public static class Tag {
@Size(max = 20)
@Pattern(regexp = "^[A-Za-z0-9]+$",
message = "标签名称不能包含中文、特殊字符")
private String tag;
@Size(max = 50)
private String value;
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/product/dto/ProductTag.java
|
Java
|
gpl-3.0
| 723
|
package com.zmops.iot.web.product.dto;
import com.zmops.iot.domain.BaseEntity;
import lombok.Data;
import javax.validation.constraints.NotNull;
import java.util.Map;
/**
* @author nantian created at 2021/8/4 15:11
*/
@Data
public class ValueMap {
@NotNull(groups = BaseEntity.Create.class)
private String productId;
@NotNull(groups = BaseEntity.Create.class)
private String valueMapName;
@NotNull(groups = BaseEntity.Create.class)
private Map<String, String> valueMaps;
@NotNull(groups = BaseEntity.Delete.class)
private String valuemapid;
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/product/dto/ValueMap.java
|
Java
|
gpl-3.0
| 585
|
package com.zmops.iot.web.product.dto;
import lombok.Data;
import java.util.List;
/**
* @author yefei
**/
@Data
public class ZbxTriggerInfo {
private List<Host> hosts;
private List<Tag> tags;
private String triggerid;
private String description;
@Data
public static class Host{
private String hostid;
private String host;
}
@Data
public static class Tag{
private String tag;
private String value;
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/product/dto/ZbxTriggerInfo.java
|
Java
|
gpl-3.0
| 481
|
package com.zmops.iot.web.product.dto.param;
import com.zmops.iot.web.sys.dto.param.BaseQueryParam;
import lombok.Data;
import javax.validation.constraints.NotBlank;
/**
* @author yefei
**/
@Data
public class EventParm extends BaseQueryParam {
private String eventRuleName;
@NotBlank
private String prodId;
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/product/dto/param/EventParm.java
|
Java
|
gpl-3.0
| 329
|
package com.zmops.iot.web.product.dto.param;
import com.zmops.iot.domain.BaseEntity;
import com.zmops.iot.web.sys.dto.param.BaseQueryParam;
import lombok.Data;
import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.NotNull;
import java.util.List;
/**
* @author yefei
**/
@Data
public class ProductAttrParam extends BaseQueryParam {
@NotNull(groups = BaseEntity.Get.class, message = "请选择一个设备再查询")
private String prodId;
private String attrName;
private String key;
private String source;
@NotEmpty(groups = BaseEntity.Delete.class)
private List<Long> ids;
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/product/dto/param/ProductAttrParam.java
|
Java
|
gpl-3.0
| 642
|
package com.zmops.iot.web.product.dto.param;
import com.zmops.iot.web.sys.dto.param.BaseQueryParam;
import lombok.Data;
import javax.validation.constraints.NotBlank;
/**
* @author yefei
**/
@Data
public class ProductSvcParam extends BaseQueryParam {
private String name;
private String mark;
@NotBlank
private String prodId;
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/product/dto/param/ProductSvcParam.java
|
Java
|
gpl-3.0
| 351
|
package com.zmops.iot.web.product.dto.param;
import com.zmops.iot.domain.BaseEntity;
import lombok.Data;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
import java.util.List;
/**
* @author yefei
**/
@Data
public class ProductTypeParam {
@NotNull(groups = BaseEntity.Update.class)
private Long id;
private Long pid = 0L;
private String pids;
@NotBlank(groups = BaseEntity.Create.class)
private String name;
private String remark;
private Long tenantId;
@NotNull(groups = BaseEntity.Delete.class)
private List<Long> ids;
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/product/dto/param/ProductTypeParam.java
|
Java
|
gpl-3.0
| 617
|
package com.zmops.iot.web.product.service;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.zmops.iot.domain.device.Device;
import com.zmops.iot.domain.device.query.QDevice;
import com.zmops.iot.domain.product.Product;
import com.zmops.iot.domain.product.ProductAttributeEvent;
import com.zmops.iot.domain.product.query.QProduct;
import com.zmops.iot.domain.product.query.QProductAttributeEvent;
import com.zmops.iot.domain.product.query.QProductEventExpression;
import com.zmops.iot.model.exception.ServiceException;
import com.zmops.iot.model.page.Pager;
import com.zmops.iot.util.ToolUtil;
import com.zmops.iot.web.event.applicationEvent.ProductAttrCreateEvent;
import com.zmops.iot.web.event.applicationEvent.ProductAttrUpdateEvent;
import com.zmops.iot.web.exception.enums.BizExceptionEnum;
import com.zmops.iot.web.product.dto.ProductAttr;
import com.zmops.iot.web.product.dto.ProductAttrDto;
import com.zmops.iot.web.product.dto.ProductTag;
import com.zmops.iot.web.product.dto.param.ProductAttrParam;
import com.zmops.zeus.driver.entity.ZbxItemInfo;
import com.zmops.zeus.driver.entity.ZbxProcessingStep;
import com.zmops.zeus.driver.service.ZbxItem;
import io.ebean.DB;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.stereotype.Service;
import java.util.*;
import java.util.stream.Collectors;
/**
* @author yefei
**/
@Service
@Slf4j
public class ProductAttributeEventService {
@Autowired
private ZbxItem zbxItem;
@Autowired
ApplicationEventPublisher publisher;
/**
* 产品属性分页列表
*
* @param productAttr
* @return
*/
public Pager<ProductAttrDto> prodAttributeEventList(ProductAttrParam productAttr) {
QProductAttributeEvent qProductAttribute = new QProductAttributeEvent();
if (ToolUtil.isNotEmpty(productAttr.getProdId())) {
qProductAttribute.productId.eq(productAttr.getProdId());
}
if (ToolUtil.isNotEmpty(productAttr.getAttrName())) {
qProductAttribute.name.contains(productAttr.getAttrName());
}
if (ToolUtil.isNotEmpty(productAttr.getKey())) {
qProductAttribute.key.contains(productAttr.getKey());
}
List<ProductAttrDto> pagedList = qProductAttribute.setFirstRow((productAttr.getPage() - 1) * productAttr.getMaxRow()).setMaxRows(productAttr.getMaxRow()).asDto(ProductAttrDto.class).findList();
int count = qProductAttribute.findCount();
return new Pager<>(pagedList, count);
}
/**
* 产品属性列表
*
* @param productAttr
* @return
*/
public List<ProductAttrDto> list(ProductAttrParam productAttr) {
QProductAttributeEvent qProductAttribute = new QProductAttributeEvent();
if (null != productAttr.getProdId()) {
qProductAttribute.productId.eq(productAttr.getProdId());
}
if (ToolUtil.isNotEmpty(productAttr.getAttrName())) {
qProductAttribute.name.contains(productAttr.getAttrName());
}
if (ToolUtil.isNotEmpty(productAttr.getKey())) {
qProductAttribute.key.contains(productAttr.getKey());
}
List<ProductAttributeEvent> list = qProductAttribute.orderBy(" create_time desc").findList();
return ToolUtil.convertBean(list, ProductAttrDto.class);
// StringBuilder sql = new StringBuilder("select * from product_attribute_event where 1=1");
// if (null != productAttr.getProdId()) {
// sql.append(" and product_id = :productId");
// }
// if (ToolUtil.isNotEmpty(productAttr.getAttrName())) {
// sql.append(" and name like :attrName");
// }
// if (ToolUtil.isNotEmpty(productAttr.getKey())) {
// sql.append(" and key like :key");
// }
// sql.append(" order by create_time desc");
// DtoQuery<ProductAttrDto> dto = DB.findDto(ProductAttrDto.class, sql.toString());
//
// if (null != productAttr.getProdId()) {
// dto.setParameter("productId", productAttr.getProdId());
// }
// if (ToolUtil.isNotEmpty(productAttr.getAttrName())) {
// dto.setParameter("attrName", "%" + productAttr.getAttrName() + "%");
// }
// if (ToolUtil.isNotEmpty(productAttr.getKey())) {
// dto.setParameter("key", "%" + productAttr.getKey() + "%");
// }
// return dto.findList();
}
/**
* 产品属性详情
*
* @param attrId
* @return
*/
public ProductAttrDto detail(Long attrId) {
// ProductAttrDto attr = new QProductAttributeEvent().attrId.eq(attrId).asDto(ProductAttrDto.class).findOne();
ProductAttrDto attr = DB.findDto(ProductAttrDto.class, "select * from product_attribute_event where attr_id=:attrId").setParameter("attrId", attrId).findOne();
if (attr == null || ToolUtil.isEmpty(attr.getZbxId())) {
return attr;
}
JSONArray itemInfo = JSONObject.parseArray(zbxItem.getItemInfo(attr.getZbxId(), null));
attr.setTags(JSONObject.parseArray(itemInfo.getJSONObject(0).getString("tags"), ProductTag.Tag.class));
attr.setProcessStepList(formatProcessStep(itemInfo.getJSONObject(0).getString("preprocessing")));
String valuemap = itemInfo.getJSONObject(0).getString("valuemap");
if (ToolUtil.isNotEmpty(valuemap) && !"[]".equals(valuemap)) {
attr.setValuemapid(JSONObject.parseObject(valuemap).getString("valuemapid"));
}
return attr;
}
private List<ProductAttr.ProcessingStep> formatProcessStep(String preprocessing) {
if (ToolUtil.isEmpty(preprocessing)) {
return Collections.emptyList();
}
List<ProductAttr.ProcessingStep> processingSteps = new ArrayList<>();
JSONArray jsonArray = JSONObject.parseArray(preprocessing);
for (Object object : jsonArray) {
ProductAttr.ProcessingStep processingStep = new ProductAttr.ProcessingStep();
processingStep.setType(((JSONObject) object).getString("type"));
processingStep.setParams(((JSONObject) object).getString("params").split("\\n"));
processingSteps.add(processingStep);
}
return processingSteps;
}
/**
* 创建 产品属性
*
* @param productAttr 产品属性DTO
*/
public void createProductAttr(ProductAttr productAttr, String zbxId) {
ProductAttributeEvent productAttributeEvent = new ProductAttributeEvent();
buildProdAttribute(productAttributeEvent, productAttr);
productAttributeEvent.setZbxId(zbxId);
productAttributeEvent.save();
publisher.publishEvent(new ProductAttrCreateEvent(this, productAttr));
log.debug("------------------");
}
private ProductAttributeEvent buildProdAttribute(ProductAttributeEvent prodAttribute, ProductAttr productAttr) {
prodAttribute.setProductId(productAttr.getProductId());
prodAttribute.setName(productAttr.getAttrName());
prodAttribute.setKey(productAttr.getKey());
prodAttribute.setUnits(productAttr.getUnits());
prodAttribute.setRemark(productAttr.getRemark());
prodAttribute.setValueType(productAttr.getValueType());
prodAttribute.setAttrId(productAttr.getAttrId());
prodAttribute.setEventLevel(productAttr.getEventLevel());
prodAttribute.setSource(productAttr.getSource());
prodAttribute.setDepAttrId(productAttr.getDepAttrId());
prodAttribute.setValuemapid(productAttr.getValuemapid());
prodAttribute.setUnit(productAttr.getUnit());
return prodAttribute;
}
/**
* 创建 Trapper 类型 ITEM
*
* @param productAttr 属性
* @return String
*/
public String createTrapperItem(ProductAttr productAttr) {
String itemName = productAttr.getAttrId() + "";
String hostId = "";
Device device = new QDevice().deviceId.eq(productAttr.getProductId()).findOne();
if (null == device) {
Product prod = new QProduct().productId.eq(Long.parseLong(productAttr.getProductId())).findOne();
if (null == prod) {
throw new ServiceException(BizExceptionEnum.PRODUCT_NOT_EXISTS);
}
hostId = prod.getZbxId();
} else {
hostId = device.getZbxId();
}
List<ZbxProcessingStep> processingSteps = new ArrayList<>();
if (ToolUtil.isNotEmpty(productAttr.getProcessStepList())) {
productAttr.getProcessStepList().forEach(i -> {
ZbxProcessingStep step = new ZbxProcessingStep();
step.setType(i.getType());
step.setParams(i.getParams());
processingSteps.add(step);
});
}
Map<String, String> tagMap = new HashMap<>();
if (ToolUtil.isNotEmpty(productAttr.getTags())) {
tagMap = productAttr.getTags().stream()
.collect(Collectors.toMap(ProductTag.Tag::getTag, ProductTag.Tag::getValue, (k1, k2) -> k2));
}
return zbxItem.createTrapperItem(itemName, productAttr.getKey(),
hostId, productAttr.getSource(), productAttr.getDelay() + "", productAttr.getMasterItemId(), productAttr.getValueType(), productAttr.getUnits(), processingSteps, productAttr.getValuemapid(), tagMap, null);
}
/**
* 修改 Trapper 类型 ITEM
*
* @param productAttr 属性
* @return String
*/
public ProductAttr updateTrapperItem(ProductAttr productAttr) {
ProductAttributeEvent productAttributeEvent = new QProductAttributeEvent().attrId.eq(productAttr.getAttrId()).findOne();
buildProdAttribute(productAttributeEvent, productAttr);
String hostId = "";
Device device = new QDevice().deviceId.eq(productAttr.getProductId()).findOne();
if (null == device) {
Product prod = new QProduct().productId.eq(Long.parseLong(productAttr.getProductId())).findOne();
if (null == prod) {
throw new ServiceException(BizExceptionEnum.PRODUCT_NOT_EXISTS);
}
hostId = prod.getZbxId();
} else {
hostId = device.getZbxId();
}
List<ZbxProcessingStep> processingSteps = new ArrayList<>();
if (ToolUtil.isNotEmpty(productAttr.getProcessStepList())) {
productAttr.getProcessStepList().forEach(i -> {
ZbxProcessingStep step = new ZbxProcessingStep();
step.setType(i.getType());
step.setParams(i.getParams());
processingSteps.add(step);
});
}
Map<String, String> tagMap = new HashMap<>();
if (ToolUtil.isNotEmpty(productAttr.getTags())) {
tagMap = productAttr.getTags().stream()
.collect(Collectors.toMap(ProductTag.Tag::getTag, ProductTag.Tag::getValue, (k1, k2) -> k2));
}
zbxItem.updateTrapperItem(productAttributeEvent.getZbxId(), productAttr.getAttrId() + "", productAttr.getKey(),
hostId, productAttr.getSource(), productAttr.getDelay() + "", productAttr.getMasterItemId(), productAttr.getValueType(), productAttr.getUnits(), processingSteps, productAttr.getValuemapid(), tagMap, null);
DB.update(productAttributeEvent);
publisher.publishEvent(new ProductAttrUpdateEvent(this, productAttr));
log.debug("----------------------");
return productAttr;
}
/**
* 删称 Trapper 类型 ITEM
*
* @param productAttr 属性
* @return String
*/
public void deleteTrapperItem(ProductAttr productAttr) {
//检查是否有属性依赖
int count = new QProductAttributeEvent().depAttrId.in(productAttr.getAttrIds()).findCount();
if (count > 0) {
throw new ServiceException(BizExceptionEnum.PRODUCT_ATTR_DEPTED);
}
//检查属性是否被告警规则引入
List<Long> attrIds = new QProductAttributeEvent().select(QProductAttributeEvent.alias().attrId).templateId.in(productAttr.getAttrIds()).findSingleAttributeList();
count = new QProductEventExpression().productAttrId.in(productAttr.getAttrIds()).findCount();
if (count > 0) {
throw new ServiceException(BizExceptionEnum.PRODUCT_EVENT_HASDEPTED);
}
List<String> zbxIds = new QProductAttributeEvent().select(QProductAttributeEvent.alias().zbxId).attrId.in(productAttr.getAttrIds()).findSingleAttributeList();
//删除zbx item
if (ToolUtil.isNotEmpty(zbxIds)) {
List<ZbxItemInfo> itemInfos = JSONObject.parseArray(zbxItem.getItemInfo(zbxIds.toString(), null), ZbxItemInfo.class);
if (ToolUtil.isNotEmpty(itemInfos)) {
zbxItem.deleteTrapperItem(itemInfos.parallelStream().map(ZbxItemInfo::getItemid).collect(Collectors.toList()));
}
}
//删除 属性
new QProductAttributeEvent().attrId.in(productAttr.getAttrIds()).delete();
//删除 设备 继承的属性
new QProductAttributeEvent().templateId.in(productAttr.getAttrIds()).delete();
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/product/service/ProductAttributeEventService.java
|
Java
|
gpl-3.0
| 13,347
|
package com.zmops.iot.web.product.service;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.zmops.iot.domain.product.ProductEvent;
import com.zmops.iot.domain.product.ProductEventExpression;
import com.zmops.iot.domain.product.ProductEventRelation;
import com.zmops.iot.domain.product.query.QProductEvent;
import com.zmops.iot.domain.product.query.QProductEventExpression;
import com.zmops.iot.domain.product.query.QProductEventRelation;
import com.zmops.iot.domain.product.query.QProductEventService;
import com.zmops.iot.enums.CommonStatus;
import com.zmops.iot.enums.InheritStatus;
import com.zmops.iot.model.page.Pager;
import com.zmops.iot.util.DefinitionsUtil;
import com.zmops.iot.util.ToolUtil;
import com.zmops.iot.web.product.dto.ProductEventDto;
import com.zmops.iot.web.product.dto.ProductEventRule;
import com.zmops.iot.web.product.dto.ProductEventRuleDto;
import com.zmops.iot.web.product.dto.param.EventParm;
import com.zmops.zeus.driver.service.ZbxTrigger;
import io.ebean.DB;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Service;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
/**
* @author nantian created at 2021/9/15 13:59
* <p>
* 告警规则 创建，产品 和 设备
*/
@Slf4j
@Service
public class ProductEventRuleService implements CommandLineRunner {
@Autowired
private ZbxTrigger zbxTrigger;
private static final String TRIGGER_CLASSIFY = "0";
/**
* 保存触发器
*
* @param eventRule 告警规则
*/
public void createProductEventRule(ProductEventRule eventRule) {
// step 1: 保存产品告警规则
ProductEvent event = initEventRule(eventRule);
event.setEventRuleId(eventRule.getEventRuleId());
DB.save(event);
//step 2: 保存 表达式，方便回显
List<ProductEventExpression> expList = new ArrayList<>();
eventRule.getExpList().forEach(i -> {
ProductEventExpression exp = initEventExpression(i);
exp.setEventRuleId(eventRule.getEventRuleId());
expList.add(exp);
});
DB.saveAll(expList);
//step 3: 保存触发器 调用 本产品方法
if (null != eventRule.getDeviceServices() && !eventRule.getDeviceServices().isEmpty()) {
eventRule.getDeviceServices().forEach(i -> {
DB.sqlUpdate("insert into product_event_service(event_rule_id, device_id,execute_device_id, service_id) values (:eventRuleId, :deviceId,:executeDeviceId, :serviceId)")
.setParameter("eventRuleId", eventRule.getEventRuleId())
.setParameter("executeDeviceId", i.getExecuteDeviceId())
.setParameter("serviceId", i.getServiceId())
.setParameter("deviceId", eventRule.getProductId())
.execute();
});
}
//step 4: 保存关联关系
ProductEventRelation productEventRelation = new ProductEventRelation();
productEventRelation.setEventRuleId(eventRule.getEventRuleId());
productEventRelation.setRelationId(eventRule.getProductId());
productEventRelation.setStatus(CommonStatus.ENABLE.getCode());
productEventRelation.setInherit(InheritStatus.NO.getCode());
productEventRelation.setRemark(eventRule.getRemark());
DB.save(productEventRelation);
//更新緩存
updateProductEvent();
}
/**
* 更新触发器
*
* @param eventRuleId 触发器ID
* @param eventRule 告警规则
*/
public void updateProductEventRule(Long eventRuleId, ProductEventRule eventRule) {
//step 1: 函数表达式
DB.sqlUpdate("delete from product_event_expression where event_rule_id = :eventRuleId")
.setParameter("eventRuleId", eventRule.getEventRuleId())
.execute();
//step 2: 删除服务方法调用
DB.sqlUpdate("delete from product_event_service where event_rule_id = :eventRuleId")
.setParameter("eventRuleId", eventRule.getEventRuleId())
.execute();
// step 3: 保存产品告警规则
ProductEvent event = initEventRule(eventRule);
event.setEventRuleId(eventRuleId);
DB.update(event);
//step 4: 保存 表达式，方便回显
List<ProductEventExpression> expList = new ArrayList<>();
eventRule.getExpList().forEach(i -> {
ProductEventExpression exp = initEventExpression(i);
exp.setEventRuleId(eventRuleId);
expList.add(exp);
});
DB.saveAll(expList);
//step 5: 保存触发器 调用 本产品方法
if (null != eventRule.getDeviceServices() && !eventRule.getDeviceServices().isEmpty()) {
eventRule.getDeviceServices().forEach(i -> {
DB.sqlUpdate("insert into product_event_service(event_rule_id, device_id, service_id) values (:eventRuleId, :deviceId, :serviceId)")
.setParameter("eventRuleId", eventRuleId)
.setParameter("deviceId", eventRule.getProductId())
.setParameter("executeDeviceId", i.getExecuteDeviceId())
.setParameter("serviceId", i.getServiceId())
.execute();
});
}
//step 6:保存备注
if (null != eventRule.getRemark()) {
DB.update(ProductEventRelation.class).where().eq("eventRuleId", eventRule.getEventRuleId()).eq("relationId", eventRule.getProductId())
.asUpdate().set("remark", eventRule.getRemark()).update();
}
//更新緩存
updateProductEvent();
}
private ProductEvent initEventRule(ProductEventRule eventRule) {
ProductEvent event = new ProductEvent();
event.setEventLevel(eventRule.getEventLevel().toString());
event.setExpLogic(eventRule.getExpLogic());
event.setEventNotify(eventRule.getEventNotify().toString());
event.setClassify(eventRule.getClassify());
event.setEventRuleName(eventRule.getEventRuleName());
return event;
}
private ProductEventExpression initEventExpression(ProductEventRule.Expression exp) {
ProductEventExpression eventExpression = new ProductEventExpression();
eventExpression.setCondition(exp.getCondition());
eventExpression.setFunction(exp.getFunction());
eventExpression.setScope(exp.getScope());
eventExpression.setValue(exp.getValue());
// eventExpression.setDeviceId(exp.getProductId());
eventExpression.setProductAttrKey(exp.getProductAttrKey());
eventExpression.setProductAttrId(exp.getProductAttrId());
eventExpression.setProductAttrType(exp.getProductAttrType());
eventExpression.setPeriod(exp.getPeriod());
eventExpression.setUnit(exp.getUnit());
eventExpression.setAttrValueType(exp.getAttrValueType());
return eventExpression;
}
/**
* 更新 触发器规则 zbxId
*
* @param eventRuleId 规则ID
* @param zbxId triggerId
*/
public void updateProductEventRuleZbxId(Long eventRuleId, String[] zbxId) {
String s = zbxTrigger.triggerGet(Arrays.toString(zbxId));
List<Triggers> triggers = JSONObject.parseArray(s, Triggers.class);
Map<String, String> map = triggers.parallelStream().collect(Collectors.toMap(o -> o.hosts.get(0).host, Triggers::getTriggerid, (a, b) -> a));
List<ProductEventRelation> productEventRelationList = new QProductEventRelation().eventRuleId.eq(eventRuleId).findList();
productEventRelationList.forEach(productEventRelation -> {
if (null != map.get(productEventRelation.getRelationId())) {
DB.update(ProductEventRelation.class).where().eq("eventRuleId", eventRuleId).eq("relationId", productEventRelation.getRelationId())
.asUpdate().set("zbxId", map.get(productEventRelation.getRelationId())).update();
}
});
}
/**
* 创建 触发器
*
* @param triggerName 触发器名称
* @param expression 表达式
* @param level 告警等级
* @return 触发器ID
*/
public String[] createZbxTrigger(String triggerName, String expression, Byte level) {
String res = zbxTrigger.triggerCreate(triggerName, expression, level,0);
return JSON.parseObject(res, TriggerIds.class).getTriggerids();
}
/**
* 触发器 分页列表
*
* @param eventParm
* @return
*/
public Pager<ProductEventDto> getEventByPage(EventParm eventParm) {
QProductEvent query = new QProductEvent();
if (ToolUtil.isNotEmpty(eventParm.getEventRuleName())) {
query.eventRuleName.contains(eventParm.getEventRuleName());
}
query.classify.eq(TRIGGER_CLASSIFY);
List<ProductEventRelation> productEventRelationList = new QProductEventRelation().relationId.eq(eventParm.getProdId()).findList();
if (ToolUtil.isEmpty(productEventRelationList)) {
return new Pager<>();
}
List<Long> eventRuleIdList = productEventRelationList.parallelStream().map(ProductEventRelation::getEventRuleId).collect(Collectors.toList());
if (ToolUtil.isNotEmpty(eventRuleIdList)) {
query.eventRuleId.in(eventRuleIdList);
}
Map<Long, ProductEventRelation> productEventRelationMap = productEventRelationList.parallelStream().collect(Collectors.toMap(ProductEventRelation::getEventRuleId, o -> o, (a, b) -> a));
List<ProductEventDto> list = query.setFirstRow((eventParm.getPage() - 1) * eventParm.getMaxRow())
.setMaxRows(eventParm.getMaxRow()).orderBy(" create_time desc").asDto(ProductEventDto.class).findList();
list.forEach(productEventDto -> {
if (null != productEventRelationMap.get(productEventDto.getEventRuleId())) {
productEventDto.setStatus(productEventRelationMap.get(productEventDto.getEventRuleId()).getStatus());
productEventDto.setRemark(productEventRelationMap.get(productEventDto.getEventRuleId()).getRemark());
productEventDto.setInherit(productEventRelationMap.get(productEventDto.getEventRuleId()).getInherit());
}
});
return new Pager<>(list, query.findCount());
}
/**
* 获取 告警规则 详情
*
* @param productEvent
* @param eventRuleId
* @param prodId
* @return
*/
public ProductEventRuleDto detail(ProductEvent productEvent, long eventRuleId, String prodId) {
ProductEventRuleDto productEventRuleDto = new ProductEventRuleDto();
ToolUtil.copyProperties(productEvent, productEventRuleDto);
List<ProductEventExpression> expList = new QProductEventExpression().eventRuleId.eq(eventRuleId).findList();
expList.forEach(productEventExpression -> {
if (ToolUtil.isEmpty(productEventExpression.getDeviceId())) {
productEventExpression.setDeviceId(prodId);
}
});
productEventRuleDto.setExpList(expList);
productEventRuleDto.setDeviceServices(new QProductEventService().eventRuleId.eq(eventRuleId).deviceId.eq(prodId).findList());
ProductEventRelation productEventRelation = new QProductEventRelation().relationId.eq(prodId).eventRuleId.eq(eventRuleId).findOne();
productEventRuleDto.setStatus(productEventRelation.getStatus());
productEventRuleDto.setRemark(productEventRelation.getRemark());
JSONArray triggerInfo = JSONObject.parseArray(zbxTrigger.triggerAndTagsGet(productEventRelation.getZbxId()));
List<ProductEventRuleDto.Tag> tagList = JSONObject.parseArray(triggerInfo.getJSONObject(0).getString("tags"), ProductEventRuleDto.Tag.class);
productEventRuleDto.setZbxId(productEventRelation.getZbxId());
productEventRuleDto.setTags(tagList.stream()
.filter(s -> !s.getTag().equals("__execute__") && !s.getTag().equals("__alarm__") && !s.getTag().equals("__event__"))
.collect(Collectors.toList()));
return productEventRuleDto;
}
public void updateProductEvent() {
List<ProductEvent> deviceList = new QProductEvent().findList();
Map<Long, String> map = deviceList.parallelStream().collect(Collectors.toMap(ProductEvent::getEventRuleId, ProductEvent::getEventRuleName, (a, b) -> a));
DefinitionsUtil.updateProductEventCache(map);
}
@Override
public void run(String... args) throws Exception {
updateProductEvent();
}
@Data
static class TriggerIds {
private String[] triggerids;
}
@Data
public static class Triggers {
private String triggerid;
private String description;
private List<Hosts> hosts;
}
@Data
public static class Hosts {
private String hostid;
private String host;
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/product/service/ProductEventRuleService.java
|
Java
|
gpl-3.0
| 13,361
|
package com.zmops.iot.web.product.service;
import com.zmops.iot.web.event.applicationEvent.ProductModelCreateEvent;
import com.zmops.iot.web.event.applicationEvent.ProductModelUpdateEvent;
import com.zmops.iot.web.product.dto.ProductAttr;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.stereotype.Component;
@Component
@EnableAsync
public class ProductModelEventPublisher {
@Autowired
ApplicationEventPublisher publisher;
@Async
public void productModelCreateEventPublish(ProductAttr productAttr) {
publisher.publishEvent(new ProductModelCreateEvent(this, productAttr));
}
@Async
public void productModelUpdateEventPublish(ProductAttr productAttr) {
publisher.publishEvent(new ProductModelUpdateEvent(this, productAttr));
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/product/service/ProductModelEventPublisher.java
|
Java
|
gpl-3.0
| 1,002
|
package com.zmops.iot.web.product.service;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.zmops.iot.domain.product.Product;
import com.zmops.iot.domain.product.ProductAttribute;
import com.zmops.iot.domain.product.query.QProduct;
import com.zmops.iot.domain.product.query.QProductAttribute;
import com.zmops.iot.domain.product.query.QProductEventExpression;
import com.zmops.iot.model.exception.ServiceException;
import com.zmops.iot.model.page.Pager;
import com.zmops.iot.util.ToolUtil;
import com.zmops.iot.web.exception.enums.BizExceptionEnum;
import com.zmops.iot.web.product.dto.ProductAttr;
import com.zmops.iot.web.product.dto.ProductAttrDto;
import com.zmops.iot.web.product.dto.ProductTag;
import com.zmops.iot.web.product.dto.param.ProductAttrParam;
import com.zmops.zeus.driver.entity.ZbxItemInfo;
import com.zmops.zeus.driver.entity.ZbxProcessingStep;
import com.zmops.zeus.driver.service.ZbxItem;
import io.ebean.DB;
import io.ebean.DtoQuery;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.*;
import java.util.stream.Collectors;
/**
* @author yefei
**/
@Service
public class ProductModelService {
@Autowired
private ZbxItem zbxItem;
@Autowired
ProductModelEventPublisher productModelEventPublisher;
/**
* 产品属性分页列表
*
* @param productAttr
* @return
*/
public Pager<ProductAttrDto> prodModelAttributeList(ProductAttrParam productAttr) {
QProductAttribute qProductAttribute = new QProductAttribute();
if (ToolUtil.isNotEmpty(productAttr.getProdId())) {
qProductAttribute.productId.eq(productAttr.getProdId());
}
if (ToolUtil.isNotEmpty(productAttr.getAttrName())) {
qProductAttribute.name.contains(productAttr.getAttrName());
}
if (ToolUtil.isNotEmpty(productAttr.getKey())) {
qProductAttribute.key.contains(productAttr.getKey());
}
List<ProductAttrDto> pagedList = qProductAttribute
.setFirstRow((productAttr.getPage() - 1) * productAttr.getMaxRow())
.setMaxRows(productAttr.getMaxRow()).orderBy(" create_time desc ")
.asDto(ProductAttrDto.class).findList();
int count = qProductAttribute.findCount();
return new Pager<>(pagedList, count);
}
/**
* 产品属性列表
*
* @param productAttr
* @return
*/
public List<ProductAttrDto> list(ProductAttrParam productAttr) {
// QProductAttribute qProductAttribute = new QProductAttribute();
// if (null != productAttr.getProdId()) {
// qProductAttribute.productId.eq(productAttr.getProdId());
// }
// if (ToolUtil.isNotEmpty(productAttr.getAttrName())) {
// qProductAttribute.name.contains(productAttr.getAttrName());
// }
// if (ToolUtil.isNotEmpty(productAttr.getKey())) {
// qProductAttribute.key.contains(productAttr.getKey());
// }
StringBuilder sql = new StringBuilder("select * from product_attribute where 1=1");
if (null != productAttr.getProdId()) {
sql.append(" and product_id = :productId");
}
if (ToolUtil.isNotEmpty(productAttr.getAttrName())) {
sql.append(" and name like :attrName");
}
if (ToolUtil.isNotEmpty(productAttr.getKey())) {
sql.append(" and key like :key");
}
if (ToolUtil.isNotEmpty(productAttr.getSource())) {
sql.append(" and source = :source");
}
sql.append(" order by create_time desc");
DtoQuery<ProductAttrDto> dto = DB.findDto(ProductAttrDto.class, sql.toString());
if (null != productAttr.getProdId()) {
dto.setParameter("productId", productAttr.getProdId());
}
if (ToolUtil.isNotEmpty(productAttr.getAttrName())) {
dto.setParameter("attrName", "%" + productAttr.getAttrName() + "%");
}
if (ToolUtil.isNotEmpty(productAttr.getKey())) {
dto.setParameter("key", "%" + productAttr.getKey() + "%");
}
if (ToolUtil.isNotEmpty(productAttr.getSource())) {
dto.setParameter("source", productAttr.getSource());
}
return dto.findList();
}
/**
* 产品属性详情
*
* @param attrId
* @return
*/
public ProductAttrDto detail(Long attrId) {
//ProductAttrDto attr = new QProductAttribute().attrId.eq(attrId).asDto(ProductAttrDto.class).findOne();
ProductAttrDto attr = DB.findDto(ProductAttrDto.class, "select * from product_attribute where attr_id=:attrId").setParameter("attrId", attrId).findOne();
if (attr == null || ToolUtil.isEmpty(attr.getZbxId())) {
return attr;
}
JSONArray itemInfo = JSONObject.parseArray(zbxItem.getItemInfo(attr.getZbxId(), null));
attr.setTags(JSONObject.parseArray(itemInfo.getJSONObject(0).getString("tags"), ProductTag.Tag.class));
attr.setProcessStepList(formatProcessStep(itemInfo.getJSONObject(0).getString("preprocessing")));
// String valuemap = itemInfo.getJSONObject(0).getString("valuemap");
//
// if (ToolUtil.isNotEmpty(valuemap) && !"[]".equals(valuemap)) {
// attr.setValuemapid(JSONObject.parseObject(valuemap).getString("valuemapid"));
// }
return attr;
}
private List<ProductAttr.ProcessingStep> formatProcessStep(String preprocessing) {
if (ToolUtil.isEmpty(preprocessing)) {
return Collections.emptyList();
}
List<ProductAttr.ProcessingStep> processingSteps = new ArrayList<>();
JSONArray jsonArray = JSONObject.parseArray(preprocessing);
for (Object object : jsonArray) {
ProductAttr.ProcessingStep processingStep = new ProductAttr.ProcessingStep();
processingStep.setType(((JSONObject) object).getString("type"));
processingStep.setParams(((JSONObject) object).getString("params").split("\\n"));
processingSteps.add(processingStep);
}
return processingSteps;
}
/**
* 创建 产品属性
*
* @param productAttr 产品属性DTO
*/
public void createProductAttr(ProductAttr productAttr, String zbxId) {
ProductAttribute productAttribute = new ProductAttribute();
buildProdAttribute(productAttribute, productAttr);
productAttribute.setZbxId(zbxId);
productAttribute.save();
productModelEventPublisher.productModelCreateEventPublish(productAttr);
// WorkerWrapper<ProductAttr, Boolean> asyncAttrZbxIdWork = new WorkerWrapper.Builder<ProductAttr, Boolean>()
// .worker(asyncAttrZbxIdWorker).param(productAttr).build();
// WorkerWrapper<ProductAttr, Boolean> saveProdAttrWork = new WorkerWrapper.Builder<ProductAttr, Boolean>()
// .worker(saveProdAttrWorker).param(productAttr).next(asyncAttrZbxIdWork).build();
//
// try {
// Async.beginWork(10000, saveProdAttrWork);
// } catch (ExecutionException | InterruptedException e) {
// e.printStackTrace();
// }
}
private void buildProdAttribute(ProductAttribute prodAttribute, ProductAttr productAttr) {
prodAttribute.setProductId(productAttr.getProductId());
prodAttribute.setName(productAttr.getAttrName());
prodAttribute.setKey(productAttr.getKey());
prodAttribute.setSource(productAttr.getSource());
prodAttribute.setUnits(productAttr.getUnits());
prodAttribute.setRemark(productAttr.getRemark());
prodAttribute.setValueType(productAttr.getValueType());
prodAttribute.setAttrId(productAttr.getAttrId());
prodAttribute.setDepAttrId(productAttr.getDepAttrId());
prodAttribute.setValuemapid(productAttr.getValuemapid());
prodAttribute.setUnit(productAttr.getUnit());
}
/**
* 创建 Trapper 类型 ITEM
*
* @param productAttr 属性
* @return String
*/
public String createTrapperItem(ProductAttr productAttr) {
String itemName = productAttr.getAttrId() + "";
Product prod = new QProduct().productId.eq(Long.parseLong(productAttr.getProductId())).findOne();
if (null == prod) {
throw new ServiceException(BizExceptionEnum.PRODUCT_NOT_EXISTS);
}
String hostId = prod.getZbxId();
List<ZbxProcessingStep> processingSteps = new ArrayList<>();
if (ToolUtil.isNotEmpty(productAttr.getProcessStepList())) {
productAttr.getProcessStepList().forEach(i -> {
ZbxProcessingStep step = new ZbxProcessingStep();
step.setType(i.getType());
step.setParams(i.getParams().replaceAll("\n", "").replaceAll("\"", "\\\\\\\\\""));
processingSteps.add(step);
});
}
Map<String, String> tagMap = new HashMap<>();
if (ToolUtil.isNotEmpty(productAttr.getTags())) {
tagMap = productAttr.getTags().stream()
.collect(Collectors.toMap(ProductTag.Tag::getTag, ProductTag.Tag::getValue, (k1, k2) -> k2));
}
String delay = "";
if (null != productAttr.getDelay()) {
delay = productAttr.getDelay() + productAttr.getUnit();
}
return zbxItem.createTrapperItem(itemName, productAttr.getKey(),
hostId, productAttr.getSource(), delay, productAttr.getMasterItemId(), productAttr.getValueType(), productAttr.getUnits(), processingSteps, productAttr.getValuemapid(), tagMap, null);
}
/**
* 修改 Trapper 类型 ITEM
*
* @param productAttr 属性
* @return String
*/
public ProductAttr updateTrapperItem(ProductAttr productAttr) {
ProductAttribute productAttribute = new QProductAttribute().attrId.eq(productAttr.getAttrId()).findOne();
if (null == productAttribute) {
productAttribute = new ProductAttribute();
}
buildProdAttribute(productAttribute, productAttr);
Product prod = new QProduct().productId.eq(Long.parseLong(productAttr.getProductId())).findOne();
if (null == prod) {
throw new ServiceException(BizExceptionEnum.PRODUCT_NOT_EXISTS);
}
String hostId = prod.getZbxId();
List<ZbxProcessingStep> processingSteps = new ArrayList<>();
if (ToolUtil.isNotEmpty(productAttr.getProcessStepList())) {
productAttr.getProcessStepList().forEach(i -> {
ZbxProcessingStep step = new ZbxProcessingStep();
step.setType(i.getType());
step.setParams(i.getParams().replaceAll("\n", "").replaceAll("\"", "\\\\\\\\\""));
processingSteps.add(step);
});
}
Map<String, String> tagMap = new HashMap<>();
if (ToolUtil.isNotEmpty(productAttr.getTags())) {
tagMap = productAttr.getTags().stream()
.collect(Collectors.toMap(ProductTag.Tag::getTag, ProductTag.Tag::getValue, (k1, k2) -> k2));
}
String delay = "";
if (null != productAttr.getDelay()) {
delay = productAttr.getDelay() + productAttr.getUnit();
}
zbxItem.updateTrapperItem(productAttribute.getZbxId(), productAttr.getAttrId() + "", productAttr.getKey(),
hostId, productAttr.getSource(), delay, productAttr.getMasterItemId(), productAttr.getValueType(), productAttr.getUnits(), processingSteps, productAttr.getValuemapid(), tagMap, null);
DB.update(productAttribute);
productModelEventPublisher.productModelUpdateEventPublish(productAttr);
// WorkerWrapper<ProductAttr, Boolean> updateProdAttrWork = new WorkerWrapper.Builder<ProductAttr, Boolean>().worker(updateProdAttrWorker).param(productAttr).build();
//
// try {
// Async.beginWork(100, updateProdAttrWork);
// } catch (ExecutionException | InterruptedException e) {
// e.printStackTrace();
// }
return productAttr;
}
/**
* 删称 Trapper 类型 ITEM
*
* @param productAttr 属性
* @return String
*/
public void deleteTrapperItem(ProductAttr productAttr) {
//检查是否有属性依赖
int count = new QProductAttribute().depAttrId.in(productAttr.getAttrIds()).findCount();
if (count > 0) {
throw new ServiceException(BizExceptionEnum.PRODUCT_ATTR_DEPTED);
}
//检查属性是否被告警规则引入
// List<Long> attrIds = new QProductAttribute().select(QProductAttribute.alias().attrId).templateId.in(productAttr.getAttrIds()).findSingleAttributeList();
// attrIds.addAll(productAttr.getAttrIds());
count = new QProductEventExpression().productAttrId.in(productAttr.getAttrIds()).findCount();
if (count > 0) {
throw new ServiceException(BizExceptionEnum.PRODUCT_EVENT_HASDEPTED);
}
List<String> zbxIds = new QProductAttribute().select(QProductAttribute.alias().zbxId).attrId.in(productAttr.getAttrIds()).findSingleAttributeList();
//删除zbx item
if (ToolUtil.isNotEmpty(zbxIds)) {
List<ZbxItemInfo> itemInfos = JSONObject.parseArray(zbxItem.getItemInfo(zbxIds.toString(), null), ZbxItemInfo.class);
if (ToolUtil.isNotEmpty(itemInfos)) {
zbxItem.deleteTrapperItem(itemInfos.parallelStream().map(ZbxItemInfo::getItemid).collect(Collectors.toList()));
}
}
//删除 属性
new QProductAttribute().attrId.in(productAttr.getAttrIds()).delete();
//删除 设备 继承的属性
new QProductAttribute().templateId.in(productAttr.getAttrIds()).delete();
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/product/service/ProductModelService.java
|
Java
|
gpl-3.0
| 13,881
|
package com.zmops.iot.web.product.service;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.zmops.iot.constant.ConstantsContext;
import com.zmops.iot.core.auth.context.LoginContextHolder;
import com.zmops.iot.domain.device.Device;
import com.zmops.iot.domain.device.Tag;
import com.zmops.iot.domain.device.query.QDevice;
import com.zmops.iot.domain.device.query.QTag;
import com.zmops.iot.domain.product.Product;
import com.zmops.iot.domain.product.query.QProduct;
import com.zmops.iot.model.page.Pager;
import com.zmops.iot.util.ToolUtil;
import com.zmops.iot.web.product.dto.ProductBasicInfo;
import com.zmops.iot.web.product.dto.ProductDto;
import com.zmops.iot.web.product.dto.ProductTag;
import com.zmops.zeus.driver.service.ZbxTemplate;
import com.zmops.zeus.driver.service.ZbxValueMap;
import io.ebean.DB;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;
import static com.zmops.iot.web.init.DeviceSatusScriptInit.GLOBAL_HOST_GROUP_CODE;
/**
* @author nantian created at 2021/8/3 20:41
*/
@Service
public class ProductService {
@Autowired
private ZbxTemplate zbxTemplate;
@Autowired
private ZbxValueMap zbxValueMap;
/**
* 产品列表
*/
public List<Product> prodList(ProductBasicInfo prodBasicInfo) {
QProduct qProduct = new QProduct();
if (ToolUtil.isNotEmpty(prodBasicInfo.getTag())) {
QTag qTag = new QTag().select(QTag.Alias.sid).templateId.isNull();
qTag.tag.contains(prodBasicInfo.getTag());
if (ToolUtil.isNotEmpty(prodBasicInfo.getTagVal())) {
qTag.value.contains(prodBasicInfo.getTagVal());
}
List<Long> sids = qTag.findSingleAttributeList();
if (ToolUtil.isNotEmpty(sids)) {
qProduct.productId.in(sids);
}
}
if (null != prodBasicInfo.getGroupId()) {
qProduct.groupId.eq(prodBasicInfo.getGroupId());
}
if (ToolUtil.isNotEmpty(prodBasicInfo.getProdType())) {
qProduct.type.eq(prodBasicInfo.getProdType());
}
if (ToolUtil.isNotEmpty(prodBasicInfo.getProdName())) {
qProduct.name.contains(prodBasicInfo.getProdName());
}
Long tenantId = LoginContextHolder.getContext().getUser().getTenantId();
if (null != tenantId) {
qProduct.tenantId.eq(tenantId);
}
return qProduct.orderBy(" create_time desc").findList();
}
/**
* 产品分页列表
*/
public Pager<ProductDto> getProductByPage(ProductBasicInfo prodBasicInfo) {
QProduct qProduct = new QProduct();
if (null != prodBasicInfo.getGroupId()) {
qProduct.groupId.eq(prodBasicInfo.getGroupId());
}
if (ToolUtil.isNotEmpty(prodBasicInfo.getProdType())) {
qProduct.type.eq(prodBasicInfo.getProdType());
}
if (ToolUtil.isNotEmpty(prodBasicInfo.getProdName())) {
qProduct.name.contains(prodBasicInfo.getProdName());
}
Long tenantId = LoginContextHolder.getContext().getUser().getTenantId();
if (null != tenantId) {
qProduct.tenantId.eq(tenantId);
}
List<ProductDto> list = qProduct.setFirstRow((prodBasicInfo.getPage() - 1) * prodBasicInfo.getMaxRow())
.setMaxRows(prodBasicInfo.getMaxRow()).orderBy(" create_time desc").asDto(ProductDto.class).findList();
if (ToolUtil.isNotEmpty(list)) {
List<Long> productIds = list.parallelStream().map(ProductDto::getProductId).collect(Collectors.toList());
List<Device> deviceList = new QDevice().select(QDevice.alias().productId, QDevice.alias().totalCount).productId.in(productIds).findList();
Map<Long, Long> map = deviceList.parallelStream().collect(Collectors.toMap(Device::getProductId, Device::getTotalCount, (a, b) -> a));
for (ProductDto productDto : list) {
productDto.setDeviceNum(Optional.ofNullable(map.get(productDto.getProductId())).orElse(0L));
}
}
return new Pager<>(list, qProduct.findCount());
}
/**
* 创建 zabbix 模板
*
* @param templateName zabbix 模板名称
* @return
*/
public String zbxTemplateCreate(String templateName) {
// 全局分组
String hostGroupId = ConstantsContext.getConstntsMap().get(GLOBAL_HOST_GROUP_CODE).toString();
return zbxTemplate.templateCreate(templateName, hostGroupId);
}
/**
* 根据模板ID 删除模板
*
* @param templdateId 模板ID
* @return
*/
public void zbxTemplateDelete(String templdateId) {
JSONArray jsonArray = JSONObject.parseArray(zbxTemplate.templateGet(templdateId));
if (jsonArray.size() > 0) {
zbxTemplate.templateDelete(templdateId);
}
}
/**
* 保存 产品
*
* @param zbxId 模板ID
* @param productId 产品ID
* @param prodBasicInfo 产品基本信息
* @return
*/
public Product createProduct(String zbxId, Long productId, ProductBasicInfo prodBasicInfo) {
Product product = buildPord(prodBasicInfo);
product.setProductId(productId);
product.setZbxId(zbxId);
DB.save(product);
return product;
}
/**
* 更新模板标签，不可以重名，覆盖更新
*
* @param tag 标签列表
* @return
*/
public String updateTemplateTags(String templateId, ProductTag tag) {
Map<String, String> tagMap = tag.getProductTag().stream()
.collect(Collectors.toMap(ProductTag.Tag::getTag, ProductTag.Tag::getValue, (k1, k2) -> k2));
return zbxTemplate.templateTagUpdate(templateId, tagMap);
}
/**
* 创建产品 值映射
*
* @param hostid 产品模板ID
* @param valueMapName 名称
* @param valueMaps KV
* @return
*/
public String valueMapCreate(String hostid, String valueMapName, Map<String, String> valueMaps) {
return zbxValueMap.valueMapCreate(hostid, valueMapName, valueMaps);
}
/**
* 修改 产品值映射
*
* @param hostid 产品模板ID
* @param valueMapName 名称
* @param valueMaps KV
* @param valueMapId 映射ID
* @return
*/
public String valueMapUpdate(String hostid, String valueMapName, Map<String, String> valueMaps, String valueMapId) {
return zbxValueMap.valueMapUpdate(hostid, valueMapName, valueMaps, valueMapId);
}
/**
* 删除值映射
*
* @param valueMapId 值映射ID
* @return String
*/
public String valueMapDelete(String valueMapId) {
return zbxValueMap.valueMapDelete(valueMapId);
}
/**
* 修改 产品 基本信息
*
* @param prodBasicInfo 基本信息
* @return
*/
public Product updateProduct(ProductBasicInfo prodBasicInfo) {
Product product = buildPord(prodBasicInfo);
product.setProductId(prodBasicInfo.getProductId());
DB.update(product);
return product;
}
private static Product buildPord(ProductBasicInfo prodBasicInfo) {
Product product = new Product();
product.setProductCode(prodBasicInfo.getProdCode());
product.setName(prodBasicInfo.getProdName());
product.setManufacturer(prodBasicInfo.getManufacturer());
product.setModel(prodBasicInfo.getModel());
product.setRemark(prodBasicInfo.getRemark());
product.setType(prodBasicInfo.getProdType());
product.setGroupId(prodBasicInfo.getGroupId());
product.setTenantId(prodBasicInfo.getTenantId());
product.setIcon(prodBasicInfo.getIcon());
return product;
}
/**
* 产品详情
*
* @param prodId
* @return
*/
public ProductDto prodDetail(Long prodId) {
ProductDto prod = new QProduct().productId.eq(prodId).asDto(ProductDto.class).findOne();
return prod;
}
/**
* 产品标签列表
*
* @param prodId
* @return
*/
public List<Tag> prodTagList(String prodId) {
QTag tag = QTag.alias();
return new QTag().select(tag.id, tag.sid, tag.tag, tag.value).sid.eq(prodId).orderBy(" create_time desc").findList();
}
/**
* 产品值映射
*
* @param prodId
* @return
*/
public JSONArray valueMapList(Long prodId) {
JSONArray zbxTemplateInfo = getZbxTemplateInfo(prodId);
if (zbxTemplateInfo.size() == 0) {
return new JSONArray();
}
//查询ZBX valueMap
return JSONObject.parseArray(zbxTemplateInfo.getJSONObject(0).getString("valuemaps"));
}
/**
* 根据产品ID 取zbx template信息
*
* @param prodId
* @return
*/
private JSONArray getZbxTemplateInfo(Long prodId) {
String zbxId = new QProduct().select(QProduct.alias().zbxId).productId.eq(prodId).findSingleAttribute();
if (null == zbxId) {
return new JSONArray();
}
return JSONObject.parseArray(zbxTemplate.templateDetail(zbxId));
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/product/service/ProductService.java
|
Java
|
gpl-3.0
| 9,381
|
package com.zmops.iot.web.product.service;
import com.zmops.iot.domain.product.ProductService;
import com.zmops.iot.domain.product.ProductServiceParam;
import com.zmops.iot.domain.product.ProductServiceRelation;
import com.zmops.iot.domain.product.query.QProductEventService;
import com.zmops.iot.domain.product.query.QProductService;
import com.zmops.iot.domain.product.query.QProductServiceParam;
import com.zmops.iot.domain.product.query.QProductServiceRelation;
import com.zmops.iot.model.exception.ServiceException;
import com.zmops.iot.model.page.Pager;
import com.zmops.iot.util.DefinitionsUtil;
import com.zmops.iot.util.ToolUtil;
import com.zmops.iot.web.event.applicationEvent.ProductServiceCreateEvent;
import com.zmops.iot.web.event.applicationEvent.ProductServiceUpdateEvent;
import com.zmops.iot.web.exception.enums.BizExceptionEnum;
import com.zmops.iot.web.product.dto.ProductServiceDto;
import com.zmops.iot.web.product.dto.param.ProductSvcParam;
import io.ebean.DB;
import io.ebean.DtoQuery;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
/**
* @author yefei
* <p>
* 产品 物模型 服务
**/
@Service
public class ProductSvcService implements CommandLineRunner {
@Autowired
ApplicationEventPublisher publisher;
/**
* 服务分页列表
*
* @param productSvcParam
* @return
*/
public Pager<ProductServiceDto> getServiceByPage(ProductSvcParam productSvcParam) {
StringBuilder sql = new StringBuilder("SELECT s.*,r.inherit from product_service s LEFT JOIN product_service_relation r on r.service_id=s.id where 1=1 ");
QProductService qProductService = new QProductService();
if (ToolUtil.isNotEmpty(productSvcParam.getName())) {
sql.append(" and s.name like :name");
qProductService.name.contains(productSvcParam.getName());
}
if (ToolUtil.isNotEmpty(productSvcParam.getMark())) {
sql.append(" and s.mark like :mark");
qProductService.mark.contains(productSvcParam.getMark());
}
if (ToolUtil.isNotEmpty(productSvcParam.getProdId())) {
sql.append(" and r.relation_id = :relationId");
List<Long> serviceIds = getServiceIdList(productSvcParam.getProdId());
if (ToolUtil.isNotEmpty(serviceIds)) {
qProductService.id.in(serviceIds);
}
}
sql.append(" order by id desc");
DtoQuery<ProductServiceDto> query = DB.findDto(ProductServiceDto.class, sql.toString());
if (ToolUtil.isNotEmpty(productSvcParam.getName())) {
query.setParameter("name", "%" + productSvcParam.getName() + "%");
}
if (ToolUtil.isNotEmpty(productSvcParam.getMark())) {
query.setParameter("mark", "%" + productSvcParam.getMark() + "%");
}
if (ToolUtil.isNotEmpty(productSvcParam.getProdId())) {
query.setParameter("relationId", productSvcParam.getProdId());
}
List<ProductServiceDto> productServiceDtoList = query.setFirstRow((productSvcParam.getPage() - 1) * productSvcParam.getMaxRow())
.setMaxRows(productSvcParam.getMaxRow()).findList();
if (ToolUtil.isEmpty(productServiceDtoList)) {
return new Pager<>(productServiceDtoList, 0);
}
//查询关联的参数
List<Long> sids = productServiceDtoList.parallelStream().map(ProductServiceDto::getId).collect(Collectors.toList());
List<ProductServiceParam> serviceParamList = new QProductServiceParam().serviceId.in(sids).deviceId.eq(productSvcParam.getProdId()).findList();
Map<Long, List<ProductServiceParam>> map = serviceParamList.parallelStream().collect(Collectors.groupingBy(ProductServiceParam::getServiceId));
productServiceDtoList.forEach(productServiceDto -> {
if (null != map.get(productServiceDto.getId())) {
productServiceDto.setProductServiceParamList(map.get(productServiceDto.getId()));
}
});
return new Pager<>(productServiceDtoList, qProductService.findCount());
}
/**
* 服务列表
*
* @param productSvcParam
* @return
*/
public List<ProductService> list(ProductSvcParam productSvcParam) {
QProductService qProdService = new QProductService();
if (ToolUtil.isNotEmpty(productSvcParam.getName())) {
qProdService.name.contains(productSvcParam.getName());
}
if (ToolUtil.isNotEmpty(productSvcParam.getProdId())) {
List<Long> serviceIds = getServiceIdList(productSvcParam.getProdId());
if (ToolUtil.isEmpty(serviceIds)) {
return Collections.emptyList();
}
qProdService.id.in(serviceIds);
}
if (ToolUtil.isNotEmpty(productSvcParam.getMark())) {
qProdService.mark.contains(productSvcParam.getMark());
}
qProdService.orderBy(" id desc");
return qProdService.findList();
}
/**
* 服务创建
*
* @param productServiceDto
* @return
*/
@Transactional(rollbackFor = Exception.class)
public ProductServiceDto create(ProductServiceDto productServiceDto) {
//查询 是否已存在同名服务
List<Long> serviceIds = getServiceIdList(productServiceDto.getRelationId());
if (ToolUtil.isNotEmpty(serviceIds)) {
int count = new QProductService().name.eq(productServiceDto.getName()).id.in(serviceIds).findCount();
if (count > 0) {
throw new ServiceException(BizExceptionEnum.SERVICE_EXISTS);
}
}
//保存服务
ProductService productService = new ProductService();
ToolUtil.copyProperties(productServiceDto, productService);
DB.save(productService);
Long serviceId = productService.getId();
productServiceDto.setId(serviceId);
//保存服务与产品 关联关系
ProductServiceRelation productServiceRelation = new ProductServiceRelation();
productServiceRelation.setServiceId(productService.getId());
productServiceRelation.setRelationId(productServiceDto.getRelationId());
DB.save(productServiceRelation);
//保存服务参数
if (ToolUtil.isNotEmpty(productServiceDto.getProductServiceParamList())) {
for (ProductServiceParam productServiceParam : productServiceDto.getProductServiceParamList()) {
productServiceParam.setServiceId(null);
productServiceParam.setServiceId(serviceId);
productServiceParam.setDeviceId(productServiceDto.getRelationId());
}
DB.saveAll(productServiceDto.getProductServiceParamList());
}
//同步到设备
if (ToolUtil.isNum(productServiceDto.getRelationId())) {
publisher.publishEvent(new ProductServiceCreateEvent(this, productServiceDto));
}
updateService();
return productServiceDto;
}
/**
* 服务修改
*
* @param productServiceDto
* @return
*/
public ProductServiceDto update(ProductServiceDto productServiceDto) {
//查询 是否已存在同名服务
List<Long> serviceIds = getServiceIdList(productServiceDto.getRelationId());
if (ToolUtil.isNotEmpty(serviceIds)) {
int count = new QProductService().name.eq(productServiceDto.getName()).id.in(serviceIds)
.id.ne(productServiceDto.getId()).findCount();
if (count > 0) {
throw new ServiceException(BizExceptionEnum.SERVICE_EXISTS);
}
}
//保存服务
ProductService productService = new ProductService();
ToolUtil.copyProperties(productServiceDto, productService);
DB.update(productService);
//重新保存服务参数
new QProductServiceParam().serviceId.eq(productServiceDto.getId()).deviceId.eq(productServiceDto.getRelationId()).delete();
if (ToolUtil.isNotEmpty(productServiceDto.getProductServiceParamList())) {
for (ProductServiceParam productServiceParam : productServiceDto.getProductServiceParamList()) {
productServiceParam.setServiceId(productServiceDto.getId());
productServiceParam.setDeviceId(productServiceDto.getRelationId());
}
DB.saveAll(productServiceDto.getProductServiceParamList());
}
//同步到设备
if (ToolUtil.isNum(productServiceDto.getRelationId())) {
publisher.publishEvent(new ProductServiceUpdateEvent(this, productServiceDto));
}
updateService();
return productServiceDto;
}
private List<Long> getServiceIdList(String relationId) {
return new QProductServiceRelation().select(QProductServiceRelation.Alias.serviceId).relationId.eq(relationId)
.findSingleAttributeList();
}
/**
* 服务删除
*
* @param ids
* @return
*/
public void delete(List<Long> ids) {
//检查服务是否被 告警 联动规则引用
int count = new QProductEventService().serviceId.in(ids).findCount();
if (count > 0) {
throw new ServiceException(BizExceptionEnum.PRODUCT_EVENT_HAS_DEPTED);
}
new QProductServiceParam().serviceId.in(ids).delete();
new QProductServiceRelation().serviceId.in(ids).delete();
new QProductService().id.in(ids).delete();
}
/**
* 根据服务 获取参数列表
*/
public List<ProductServiceParam> paramList(long serviceId) {
return new QProductServiceParam().serviceId.eq(serviceId).findList();
}
/**
* 更新服务名称 服务参数 缓存
*/
private void updateService() {
List<ProductService> serviceList = new QProductService().findList();
Map<Long, String> map = serviceList.parallelStream().collect(Collectors.toMap(ProductService::getId, ProductService::getName, (a, b) -> a));
DefinitionsUtil.updateServiceCache(map);
List<ProductServiceParam> serviceParamList = new QProductServiceParam().findList();
Map<Long, List<ProductServiceParam>> paramMap = serviceParamList.parallelStream().collect(Collectors.groupingBy(ProductServiceParam::getServiceId));
DefinitionsUtil.updateServiceParamCache(paramMap);
}
@Override
public void run(String... args) throws Exception {
updateService();
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/product/service/ProductSvcService.java
|
Java
|
gpl-3.0
| 10,855
|
package com.zmops.iot.web.product.service;
import cn.hutool.core.util.IdUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.zmops.iot.domain.product.ProductStatusFunction;
import com.zmops.iot.domain.product.ProductStatusFunctionRelation;
import com.zmops.iot.domain.product.query.QProductStatusFunction;
import com.zmops.iot.domain.product.query.QProductStatusFunctionRelation;
import com.zmops.iot.model.exception.ServiceException;
import com.zmops.iot.util.ToolUtil;
import com.zmops.iot.web.device.dto.DeviceDto;
import com.zmops.iot.web.exception.enums.BizExceptionEnum;
import com.zmops.iot.web.product.dto.ProductStatusFunctionDto;
import com.zmops.iot.web.product.dto.ProductStatusJudgeRule;
import com.zmops.iot.web.product.dto.ZbxTriggerInfo;
import com.zmops.zeus.driver.service.ZbxDeviceStatusTrigger;
import com.zmops.zeus.driver.service.ZbxTrigger;
import io.ebean.DB;
import lombok.Data;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;
/**
* @author nantian created at 2021/8/10 17:55
* <p>
* <p>
* 创建 设备 状态触发器
*/
@Service
public class ProductTriggerService {
@Autowired
private ZbxDeviceStatusTrigger deviceStatusTrigger;
@Autowired
private ZbxTrigger zbxTrigger;
/**
* 离线 或者 在线触发器 信息
*
* @param relationId 在线规则
* @return ResponseData
*/
public ProductStatusFunctionDto getRule(String relationId) {
String sql = "select s.*,p.name attrName,p2.name attrNameRecovery,p.units,p2.units unitsRecovery " +
" from product_status_function s" +
" LEFT JOIN product_attribute p on p.attr_id = s.attr_id" +
" LEFT JOIN product_attribute p2 on p2.attr_id = s.attr_id_recovery" +
" where s.rule_id in (select rule_id from product_status_function_relation where relation_id = :relationId)";
return DB.findDto(ProductStatusFunctionDto.class, sql).setParameter("relationId", relationId).findOne();
}
/**
* 创建 设备状态 触发器
*
* @param judgeRule 判断规则
* @return Integer
*/
@Transactional(rollbackFor = Exception.class)
public Long createDeviceStatusJudgeTrigger(ProductStatusJudgeRule judgeRule) {
long ruleId = IdUtil.getSnowflake().nextId();
judgeRule.setRuleId(ruleId);
//step 1:保存到zbx 建立上线及下线规则
String ruleCondition = judgeRule.getRuleCondition();
if(!ToolUtil.isNum(ruleCondition)){
ruleCondition = "\""+ruleCondition+"\"";
}
String res = deviceStatusTrigger.createDeviceStatusTrigger(judgeRule.getRuleId() + "", judgeRule.getRelationId(),
judgeRule.getProductAttrKey(), ruleCondition + judgeRule.getUnit(), judgeRule.getRuleFunction(), judgeRule.getProductAttrKeyRecovery(),
judgeRule.getRuleConditionRecovery() + judgeRule.getUnitRecovery(), judgeRule.getRuleFunctionRecovery());
String[] triggerIds = getTriggerId(res);
//step 2:保存规则
ProductStatusFunction productStatusFunction = new ProductStatusFunction();
BeanUtils.copyProperties(judgeRule, productStatusFunction);
productStatusFunction.setRuleId(ruleId);
DB.save(productStatusFunction);
//step 3:保存规则与产品的关联关系
ProductStatusFunctionRelation productStatusFunctionRelation = new ProductStatusFunctionRelation();
productStatusFunctionRelation.setRelationId(judgeRule.getRelationId());
productStatusFunctionRelation.setRuleId(ruleId);
//对应zbx下线规则ID
productStatusFunctionRelation.setZbxId(triggerIds[0]);
//对应zbx上线规则ID
productStatusFunctionRelation.setZbxIdRecovery(triggerIds[1]);
DB.save(productStatusFunctionRelation);
//step 4:同步到设备
String relationId = judgeRule.getRelationId();
if (ToolUtil.isNum(relationId)) {
//查询出继承了此产品的设备
String sql = "select device_id from device where product_id = :productId and device_id not in (select relation_id from product_status_function_relation where inherit='0')";
List<DeviceDto> deviceDtoList = DB.findDto(DeviceDto.class, sql).setParameter("productId", Long.parseLong(relationId)).findList();
if (ToolUtil.isEmpty(deviceDtoList)) {
return productStatusFunction.getRuleId();
}
//从Zbx 查询出所有设备的 名称是 judgeRule.getRuleId() 的触发器
String triggerRes = zbxTrigger.triggerGetByName(judgeRule.getRuleId() + "");
if (ToolUtil.isEmpty(triggerRes)) {
return productStatusFunction.getRuleId();
}
List<ZbxTriggerInfo> zbxTriggerInfoList = JSONObject.parseArray(triggerRes, ZbxTriggerInfo.class);
Map<String, String> hostTriggerMap = zbxTriggerInfoList.parallelStream().filter(o -> o.getTags().parallelStream().anyMatch(t -> "__offline__".equals(t.getTag())))
.collect(Collectors.toMap(o -> o.getHosts().get(0).getHost(), ZbxTriggerInfo::getTriggerid, (a, b) -> a));
Map<String, String> hostRecoveryTriggerMap = zbxTriggerInfoList.parallelStream().filter(o -> o.getTags().parallelStream().anyMatch(t -> "__online__".equals(t.getTag())))
.collect(Collectors.toMap(o -> o.getHosts().get(0).getHost(), ZbxTriggerInfo::getTriggerid, (a, b) -> a));
//保存 设备与规则的关系
deviceDtoList.forEach(deviceDto -> {
String zbxId = Optional.ofNullable(hostTriggerMap.get(deviceDto.getDeviceId())).orElse("");
String zbxIdRecovery = Optional.ofNullable(hostRecoveryTriggerMap.get(deviceDto.getDeviceId())).orElse("");
DB.sqlUpdate("insert into product_status_function_relation (relation_id,rule_id,inherit,zbx_id,zbx_id_recovery) SELECT :deviceId,rule_id,1,:zbxId,:zbxIdRecovery from product_status_function_relation where relation_id=:relationId")
.setParameter("deviceId", deviceDto.getDeviceId()).setParameter("relationId", judgeRule.getRelationId() + "")
.setParameter("zbxId", zbxId)
.setParameter("zbxIdRecovery", zbxIdRecovery)
.execute();
});
}
return productStatusFunction.getRuleId();
}
/**
* 修改 触发器
*
* @param judgeRule 判断规则
* @return Integer
*/
public Long updateDeviceStatusJudgeTrigger(ProductStatusJudgeRule judgeRule) {
ProductStatusFunctionRelation relation = new QProductStatusFunctionRelation().ruleId.eq(judgeRule.getRuleId()).relationId.eq(judgeRule.getRelationId()).findOne();
if (null == relation) {
return judgeRule.getRuleId();
}
String ruleCondition = judgeRule.getRuleCondition();
if(!ToolUtil.isNum(ruleCondition)){
ruleCondition = "\""+ruleCondition+"\"";
}
deviceStatusTrigger.updateDeviceStatusTrigger(relation.getZbxId(), judgeRule.getRuleId() + "", judgeRule.getRelationId(),
judgeRule.getProductAttrKey(), ruleCondition + judgeRule.getUnit(), judgeRule.getRuleFunction(), judgeRule.getProductAttrKeyRecovery(),
judgeRule.getRuleConditionRecovery() + judgeRule.getUnitRecovery(), judgeRule.getRuleFunctionRecovery(), relation.getZbxIdRecovery());
ProductStatusFunction productStatusFunction = new ProductStatusFunction();
BeanUtils.copyProperties(judgeRule, productStatusFunction);
DB.update(productStatusFunction);
return judgeRule.getRuleId();
}
/**
* 值拷贝
*
* @param rule 新规则
* @param judgeRule 规则
*/
private void buildTriggerCreateMap(Map<String, String> rule, ProductStatusJudgeRule judgeRule) {
rule.put("ruleId", judgeRule.getRuleId() + "");
rule.put("deviceId", judgeRule.getRelationId());
rule.put("ruleFunction", judgeRule.getRuleFunction());
rule.put("ruleCondition", judgeRule.getRuleCondition());
rule.put("itemKey", judgeRule.getProductAttrKey());
rule.put("itemKeyRecovery", judgeRule.getProductAttrKeyRecovery());
rule.put("ruleConditionRecovery", judgeRule.getRuleConditionRecovery());
rule.put("ruleFunctionRecovery", judgeRule.getRuleFunctionRecovery());
}
private String[] getTriggerId(String responseStr) {
TriggerIds ids = JSON.parseObject(responseStr, TriggerIds.class);
if (null == ids || ids.getTriggerids().length != 2) {
throw new ServiceException(BizExceptionEnum.ZBX_CALL_ERR);
}
return ids.getTriggerids();
}
/**
* 删除 离线 或者 在线触发器
*/
@Transactional(rollbackFor = Exception.class)
public void deleteDeviceStatusTrigger(Long ruleId) {
new QProductStatusFunctionRelation().ruleId.eq(ruleId).delete();
new QProductStatusFunction().ruleId.eq(ruleId).delete();
}
@Data
static class TriggerIds {
String[] triggerids;
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/product/service/ProductTriggerService.java
|
Java
|
gpl-3.0
| 9,511
|
package com.zmops.iot.web.product.service;
import com.zmops.iot.core.auth.context.LoginContextHolder;
import com.zmops.iot.core.tree.DefaultTreeBuildFactory;
import com.zmops.iot.domain.product.ProductType;
import com.zmops.iot.domain.product.query.QProduct;
import com.zmops.iot.domain.product.query.QProductType;
import com.zmops.iot.model.exception.ServiceException;
import com.zmops.iot.model.node.TreeNode;
import com.zmops.iot.util.DefinitionsUtil;
import com.zmops.iot.util.ToolUtil;
import com.zmops.iot.web.exception.enums.BizExceptionEnum;
import com.zmops.iot.web.product.dto.param.ProductTypeParam;
import io.ebean.DB;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.stream.Collectors;
/**
* @author yefei
* <p>
* 产品分类管理
**/
@Service
public class ProductTypeService implements CommandLineRunner {
/**
* 产品分类树
*/
public List<TreeNode> tree() {
String sql = "select p.id,p.pid pId,p.name,p.pids,t.name tenantName,p.create_time,u.name createUserName from product_type p " +
" LEFT JOIN tenant_info t on t.tenant_id = p.tenant_id " +
" LEFT JOIN sys_user u on u.user_id = p.create_user";
Long tenantId = LoginContextHolder.getContext().getUser().getTenantId();
if (null != tenantId) {
sql += " where p.tenant_id = " + tenantId;
}
List<TreeNode> list = DB.findDto(TreeNode.class, sql).findList();
DefaultTreeBuildFactory<TreeNode> treeBuildFactory = new DefaultTreeBuildFactory<>();
treeBuildFactory.setRootParentId("0");
return treeBuildFactory.doTreeBuild(list);
}
/**
* 新增分类
*
* @param productTypeParam
* @return
*/
public ProductType create(ProductTypeParam productTypeParam) {
int count = new QProductType().name.eq(productTypeParam.getName()).tenantId.eq(productTypeParam.getTenantId())
.pid.eq(productTypeParam.getPid())
.findCount();
if (count > 0) {
throw new ServiceException(BizExceptionEnum.PRODUCT_TYPE_EXIST);
}
ProductType productType = new ProductType();
ToolUtil.copyProperties(productTypeParam, productType);
setPids(productType);
DB.save(productType);
updateProductType();
return productType;
}
/**
* 新增分类
*
* @param productTypeParam
* @return
*/
public Object update(ProductTypeParam productTypeParam) {
int oldProTypeCount = new QProductType().id.eq(productTypeParam.getId()).findCount();
if (oldProTypeCount <= 0) {
throw new ServiceException(BizExceptionEnum.PRODUCT_TYPE_NOT_EXIST);
}
int count = new QProductType().name.eq(productTypeParam.getName()).tenantId.eq(productTypeParam.getTenantId())
.pid.eq(productTypeParam.getPid())
.id.ne(productTypeParam.getId())
.findCount();
if (count > 0) {
throw new ServiceException(BizExceptionEnum.PRODUCT_TYPE_EXIST);
}
ProductType productType = new ProductType();
ToolUtil.copyProperties(productTypeParam, productType);
setPids(productType);
DB.update(productType);
updateProductType();
return productType;
}
/**
* 新增分类
*
* @param productTypeParam
* @return
*/
public void delete(ProductTypeParam productTypeParam) {
int count = new QProduct().groupId.in(productTypeParam.getIds()).findCount();
if (count > 0) {
throw new ServiceException(BizExceptionEnum.PRODUCT_TYPE_HAS_BIND);
}
new QProductType().id.in(productTypeParam.getIds()).delete();
updateProductType();
}
/**
* 设置父级ids
*/
private void setPids(ProductType productType) {
if (productType.getPid().equals(0L)) {
productType.setPids("[0],");
} else {
Long pid = productType.getPid();
ProductType temp = new QProductType().id.eq(pid).findOne();
if (null == temp) {
throw new ServiceException(BizExceptionEnum.PRODUCT_TYPE_PID_NOT_EXIST);
}
if (null != productType.getId() && productType.getId().equals(productType.getPid())) {
throw new ServiceException(BizExceptionEnum.PRODUCT_TYPE_PID_ERR);
}
if (null != productType.getId() && temp.getPids().contains("[" + productType.getId() + "]")) {
throw new ServiceException(BizExceptionEnum.PRODUCT_TYPE_PID_ERR);
}
String pids = temp.getPids();
productType.setPids(pids + "[" + pid + "],");
}
}
private void updateProductType() {
List<ProductType> list = new QProductType().findList();
if (ToolUtil.isEmpty(list)) {
return;
}
DefinitionsUtil.updateProductType(list.parallelStream().collect(Collectors.toMap(ProductType::getId, ProductType::getName, (a, b) -> a)));
}
@Override
public void run(String... args) throws Exception {
updateProductType();
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/product/service/ProductTypeService.java
|
Java
|
gpl-3.0
| 5,268
|
package com.zmops.iot.web.product.service.event;
import com.alibaba.fastjson.JSONObject;
import com.zmops.iot.domain.product.ProductAttributeEvent;
import com.zmops.iot.domain.product.query.QProductAttributeEvent;
import com.zmops.iot.util.ToolUtil;
import com.zmops.iot.web.event.applicationEvent.ProductAttrCreateEvent;
import com.zmops.iot.web.product.dto.ProductAttr;
import com.zmops.zeus.driver.entity.ZbxItemInfo;
import com.zmops.zeus.driver.service.ZbxItem;
import io.ebean.DB;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationListener;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.stereotype.Component;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
/**
* @author yefei
* <p>
* 更新设备属性事件中ZBXID
*/
@Slf4j
@Component
@EnableAsync
public class AsyncAttrEventZbxIdEventHandler implements ApplicationListener<ProductAttrCreateEvent> {
@Autowired
ZbxItem zbxItem;
@Override
@Async
public void onApplicationEvent(ProductAttrCreateEvent event) {
log.debug("AsyncAttrEventZbxIdWorker……");
ProductAttr productAttr = event.getEventData();
Long attrId = productAttr.getAttrId();
//根据name 取出监控项
List<ZbxItemInfo> itemInfos = JSONObject.parseArray(zbxItem.getItemListByName(attrId + ""), ZbxItemInfo.class);
if (ToolUtil.isEmpty(itemInfos)) {
return;
}
Map<String, ZbxItemInfo> itemMap = itemInfos.parallelStream().collect(Collectors.toMap(o -> o.getHosts().get(0).getHost(), o -> o));
//取出继承的属性 并塞入对应的 itemId
List<ProductAttributeEvent> productAttributeEventList = new QProductAttributeEvent().templateId.eq(attrId).findList();
for (ProductAttributeEvent productAttributeEvent : productAttributeEventList) {
if (itemMap.get(productAttributeEvent.getProductId() + "") == null) {
continue;
}
productAttributeEvent.setZbxId(itemMap.get(productAttributeEvent.getProductId() + "").getItemid());
}
DB.updateAll(productAttributeEventList);
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/product/service/event/AsyncAttrEventZbxIdEventHandler.java
|
Java
|
gpl-3.0
| 2,329
|
package com.zmops.iot.web.product.service.event;
import com.alibaba.fastjson.JSONObject;
import com.zmops.iot.domain.product.ProductAttribute;
import com.zmops.iot.domain.product.query.QProductAttribute;
import com.zmops.iot.util.ToolUtil;
import com.zmops.iot.web.event.applicationEvent.ProductModelCreateEvent;
import com.zmops.iot.web.product.dto.ProductAttr;
import com.zmops.zeus.driver.entity.ZbxItemInfo;
import com.zmops.zeus.driver.service.ZbxItem;
import io.ebean.DB;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationListener;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
/**
* @author yefei
* <p>
* 更新设备属性中ZBXID
*/
@Slf4j
@Component
@Order(1)
public class AsyncAttrZbxIdEventHandler implements ApplicationListener<ProductModelCreateEvent> {
@Autowired
ZbxItem zbxItem;
@Override
public void onApplicationEvent(ProductModelCreateEvent event) {
log.debug("AsyncAttrZbxIdWorker……");
ProductAttr productAttr = event.getEventData();
Long attrId = productAttr.getAttrId();
//根据name 取出监控项
List<ZbxItemInfo> itemInfos = JSONObject.parseArray(zbxItem.getItemListByName(attrId + ""), ZbxItemInfo.class);
if (ToolUtil.isEmpty(itemInfos)) {
return;
}
Map<String, ZbxItemInfo> itemMap = itemInfos.parallelStream().collect(Collectors.toMap(o -> o.getHosts().get(0).getHost(), o -> o));
//取出继承的属性 并塞入对应的 itemId
List<ProductAttribute> productAttributeList = new QProductAttribute().templateId.eq(attrId).findList();
for (ProductAttribute productAttribute : productAttributeList) {
productAttribute.setZbxId(itemMap.get(productAttribute.getProductId() + "").getItemid());
}
DB.updateAll(productAttributeList);
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/product/service/event/AsyncAttrZbxIdEventHandler.java
|
Java
|
gpl-3.0
| 2,057
|
package com.zmops.iot.web.product.service.event;
import cn.hutool.core.util.IdUtil;
import com.zmops.iot.domain.device.query.QDevice;
import com.zmops.iot.domain.product.ProductAttributeEvent;
import com.zmops.iot.util.ToolUtil;
import com.zmops.iot.web.event.applicationEvent.ProductAttrCreateEvent;
import com.zmops.iot.web.product.dto.ProductAttr;
import io.ebean.DB;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.ApplicationListener;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;
import java.util.ArrayList;
import java.util.List;
/**
* @author yefei
* <p>
* 产品属性事件创建 同步到设备 步骤
*/
@Slf4j
@Component
public class SaveProdAttrEventEventHandler implements ApplicationListener<ProductAttrCreateEvent> {
@Override
@Async
public void onApplicationEvent(ProductAttrCreateEvent event) {
log.debug("SaveProdAttrEventTriggerWorker…………");
ProductAttr productAttr = event.getEventData();
String prodId = productAttr.getProductId();
int count = new QDevice().deviceId.eq(prodId).findCount();
if (count > 0) {
return;
}
List<String> deviceIds = new QDevice().select(QDevice.Alias.deviceId).productId.eq(Long.parseLong(prodId)).findSingleAttributeList();
List<ProductAttributeEvent> productAttributeEventList = new ArrayList<>();
for (String deviceId : deviceIds) {
ProductAttributeEvent productAttributeEvent = new ProductAttributeEvent();
ToolUtil.copyProperties(productAttr, productAttributeEvent);
productAttributeEvent.setAttrId(IdUtil.getSnowflake().nextId());
productAttributeEvent.setName(productAttr.getAttrName());
productAttributeEvent.setProductId(deviceId);
productAttributeEvent.setTemplateId(productAttr.getAttrId());
productAttributeEventList.add(productAttributeEvent);
}
DB.saveAll(productAttributeEventList);
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/product/service/event/SaveProdAttrEventEventHandler.java
|
Java
|
gpl-3.0
| 2,056
|
package com.zmops.iot.web.product.service.event;
import cn.hutool.core.util.IdUtil;
import com.zmops.iot.domain.product.ProductAttribute;
import com.zmops.iot.domain.product.query.QProductAttribute;
import com.zmops.iot.util.ToolUtil;
import com.zmops.iot.web.device.dto.DeviceDto;
import com.zmops.iot.web.event.applicationEvent.ProductModelCreateEvent;
import com.zmops.iot.web.product.dto.ProductAttr;
import io.ebean.DB;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.ApplicationListener;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Collectors;
/**
* @author yefei
* <p>
* 产品属性创建 同步到设备 步骤
*/
@Slf4j
@Component
@Order(0)
public class SaveProdAttrEventHandler implements ApplicationListener<ProductModelCreateEvent> {
private static final String ATTR_SOURCE_DEPEND = "18";
@Override
public void onApplicationEvent(ProductModelCreateEvent event) {
log.debug("SaveProdAttrWorker…………");
ProductAttr productAttr = event.getEventData();
String sql = "select device_id from device " +
" where product_id = :productId and device_id not in (" +
" select product_id from product_attribute " +
" where template_id is null and key = :key)";
List<DeviceDto> deviceDtoList = DB.findDto(DeviceDto.class, sql).setParameter("productId", Long.parseLong(productAttr.getProductId()))
.setParameter("key", productAttr.getKey()).findList();
List<ProductAttribute> productAttributeList = new ArrayList<>();
if (ToolUtil.isEmpty(deviceDtoList)) {
return;
}
//处理依赖属性
Map<String, Long> attrIdMap = new ConcurrentHashMap<>(deviceDtoList.size());
if (ATTR_SOURCE_DEPEND.equals(productAttr.getSource())) {
List<ProductAttribute> list = new QProductAttribute().templateId.eq(productAttr.getDepAttrId()).findList();
attrIdMap = list.parallelStream().collect(Collectors.toMap(ProductAttribute::getProductId, ProductAttribute::getAttrId, (a, b) -> a));
}
for (DeviceDto deviceDto : deviceDtoList) {
ProductAttribute productAttrbute = new ProductAttribute();
ToolUtil.copyProperties(productAttr, productAttrbute);
productAttrbute.setAttrId(IdUtil.getSnowflake().nextId());
productAttrbute.setName(productAttr.getAttrName());
productAttrbute.setProductId(deviceDto.getDeviceId());
productAttrbute.setTemplateId(productAttr.getAttrId());
if (ATTR_SOURCE_DEPEND.equals(productAttr.getSource()) && null != attrIdMap.get(deviceDto.getDeviceId())) {
productAttrbute.setDepAttrId(attrIdMap.get(deviceDto.getDeviceId()));
}
productAttributeList.add(productAttrbute);
}
DB.saveAll(productAttributeList);
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/product/service/event/SaveProdAttrEventHandler.java
|
Java
|
gpl-3.0
| 3,104
|
package com.zmops.iot.web.product.service.event;
import com.alibaba.fastjson.JSON;
import com.zmops.iot.web.event.applicationEvent.ProductAttrCreateEvent;
import com.zmops.iot.web.product.dto.ProductAttr;
import com.zmops.zeus.driver.service.ZbxTrigger;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationListener;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
/**
* @author yefei
* <p>
* 产品属性事件创建 告警 步骤
*/
@Slf4j
@Component
public class SaveProdAttrEventTriggerEventHandler implements ApplicationListener<ProductAttrCreateEvent> {
@Autowired
private ZbxTrigger zbxTrigger;
private static final String EVENT_TAG_NAME = "__event__";
@Override
@Async
public void onApplicationEvent(ProductAttrCreateEvent event) {
log.debug("SaveProdAttrEventTriggerWorker…………");
ProductAttr productAttr = event.getEventData();
String prodId = productAttr.getProductId();
StringBuilder expression = new StringBuilder();
expression.append("count(/");
expression.append(prodId);
expression.append("/");
expression.append(productAttr.getKey());
expression.append(",#1");
expression.append(") >0 ");
String res = zbxTrigger.triggerCreate(productAttr.getAttrName(), expression.toString(), productAttr.getEventLevel(),1);
String[] triggerids = JSON.parseObject(res, TriggerIds.class).getTriggerids();
Map<String, String> tags = new ConcurrentHashMap<>(1);
tags.put(EVENT_TAG_NAME, "{HOST.HOST}##" + productAttr.getKey());
zbxTrigger.triggerTagCreate(triggerids[0], tags);
}
@Data
static class TriggerIds {
private String[] triggerids;
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/product/service/event/SaveProdAttrEventTriggerEventHandler.java
|
Java
|
gpl-3.0
| 1,967
|
package com.zmops.iot.web.product.service.event;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
/**
* @author yefei
* <p>
* 产品服务创建 同步到设备 步骤
*/
@Slf4j
@Component
public class SaveProdStatusTriggerEventHandler {//implements IWorker<ProductServiceDto, Boolean>
// @Override
// public Boolean action(ProductServiceDto productServiceDto, Map<String, WorkerWrapper> map) {
//
// String prodId = productServiceDto.getRelationId();
//
// List<String> deviceIds = new QDevice().select(QDevice.Alias.deviceId).productId.eq(Long.parseLong(prodId)).findSingleAttributeList();
// List<ProductStatusFunctionRelation> productStatusFunctionRelationList = new ArrayList<>();
// for (String deviceId : deviceIds) {
// ProductStatusFunctionRelation productStatusFunctionRelation = new ProductStatusFunctionRelation();
// productStatusFunctionRelation.setRelationId(deviceId);
// productStatusFunctionRelation.setRuleId(productServiceDto.getId());
// productStatusFunctionRelation.setInherit("1");
// productStatusFunctionRelationList.add(productStatusFunctionRelation);
// }
// DB.saveAll(productStatusFunctionRelationList);
//
// return true;
// }
//
//
// @Override
// public Boolean defaultValue() {
// return true;
// }
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/product/service/event/SaveProdStatusTriggerEventHandler.java
|
Java
|
gpl-3.0
| 1,408
|
package com.zmops.iot.web.product.service.event;
import com.zmops.iot.domain.device.query.QDevice;
import com.zmops.iot.domain.product.ProductServiceParam;
import com.zmops.iot.domain.product.ProductServiceRelation;
import com.zmops.iot.util.ToolUtil;
import com.zmops.iot.web.event.applicationEvent.ProductServiceCreateEvent;
import com.zmops.iot.web.product.dto.ProductServiceDto;
import io.ebean.DB;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.ApplicationListener;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.stereotype.Component;
import java.util.ArrayList;
import java.util.List;
/**
* @author yefei
* <p>
* 产品服务创建 同步到设备 步骤
*/
@Slf4j
@Component
@EnableAsync
public class SaveProdSvcEventHandler implements ApplicationListener<ProductServiceCreateEvent> {
@Override
@Async
public void onApplicationEvent(ProductServiceCreateEvent event) {
ProductServiceDto productServiceDto = event.getEventData();
String prodId = productServiceDto.getRelationId();
//查询出 继承了此产品的设备
List<String> deviceIds = new QDevice().select(QDevice.Alias.deviceId).productId.eq(Long.parseLong(prodId)).findSingleAttributeList();
if (ToolUtil.isEmpty(deviceIds)) {
return;
}
List<ProductServiceRelation> productServiceRelationList = new ArrayList<>();
List<ProductServiceParam> productServiceParamList = new ArrayList<>();
for (String deviceId : deviceIds) {
//保存设备与服务的关联关系
ProductServiceRelation productServiceRelation = new ProductServiceRelation();
productServiceRelation.setRelationId(deviceId);
productServiceRelation.setServiceId(productServiceDto.getId());
productServiceRelation.setInherit("1");
productServiceRelationList.add(productServiceRelation);
//保存设备与服务参数的关联关系
productServiceDto.getProductServiceParamList().forEach(productServiceParam -> {
ProductServiceParam param = new ProductServiceParam();
ToolUtil.copyProperties(productServiceParam, param);
param.setId(null);
param.setDeviceId(deviceId);
param.setServiceId(productServiceDto.getId());
productServiceParamList.add(param);
});
}
DB.saveAll(productServiceRelationList);
DB.saveAll(productServiceParamList);
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/product/service/event/SaveProdSvcEventHandler.java
|
Java
|
gpl-3.0
| 2,629
|
package com.zmops.iot.web.product.service.event;
import com.alibaba.fastjson.JSONObject;
import com.zmops.iot.domain.device.query.QDevice;
import com.zmops.iot.domain.product.ProductEventRelation;
import com.zmops.iot.domain.product.ProductEventService;
import com.zmops.iot.enums.CommonStatus;
import com.zmops.iot.enums.InheritStatus;
import com.zmops.iot.web.event.applicationEvent.ProductEventTriggerCreateEvent;
import com.zmops.iot.web.product.dto.ProductEventRule;
import com.zmops.iot.web.product.service.ProductEventRuleService;
import com.zmops.zeus.driver.service.ZbxTrigger;
import io.ebean.DB;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationListener;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.stereotype.Component;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
/**
* @author yefei
* <p>
* 产品服务创建 同步到设备 步骤
*/
@Slf4j
@Component
@EnableAsync
public class SaveProductEventTriggerEventHandler implements ApplicationListener<ProductEventTriggerCreateEvent> {
@Autowired
ZbxTrigger zbxTrigger;
@Override
@Async
public void onApplicationEvent(ProductEventTriggerCreateEvent event) {
log.debug("SaveProductEventTriggerWorker…………");
ProductEventRule productEventRule = event.getEventData();
String prodId = productEventRule.getProductId();
List<String> deviceIds = new QDevice().select(QDevice.Alias.deviceId).productId.eq(Long.parseLong(prodId)).findSingleAttributeList();
List<ProductEventRuleService.Triggers> triggers = JSONObject.parseArray(zbxTrigger.triggerGetByName(productEventRule.getEventRuleId() + ""), ProductEventRuleService.Triggers.class);
Map<String, String> treiggerMap = triggers.parallelStream().collect(Collectors.toMap(o -> o.getHosts().get(0).getHost(), ProductEventRuleService.Triggers::getTriggerid, (a, b) -> a));
List<ProductEventRelation> productEventRelationList = new ArrayList<>();
List<ProductEventService> addProductEventServiceList = new ArrayList<>();
for (String deviceId : deviceIds) {
ProductEventRelation productEventRelation = new ProductEventRelation();
productEventRelation.setRelationId(deviceId);
productEventRelation.setEventRuleId(productEventRule.getEventRuleId());
productEventRelation.setInherit(InheritStatus.YES.getCode());
productEventRelation.setStatus(CommonStatus.ENABLE.getCode());
productEventRelation.setRemark(productEventRule.getRemark());
if (null != treiggerMap.get(deviceId)) {
productEventRelation.setZbxId(treiggerMap.get(deviceId));
}
productEventRelationList.add(productEventRelation);
productEventRule.getDeviceServices().forEach(productEventService -> {
ProductEventService newProductEventService = new ProductEventService();
newProductEventService.setDeviceId(deviceId);
newProductEventService.setExecuteDeviceId(deviceId);
newProductEventService.setEventRuleId(productEventRule.getEventRuleId());
newProductEventService.setServiceId(productEventService.getServiceId());
addProductEventServiceList.add(newProductEventService);
});
}
DB.saveAll(productEventRelationList);
DB.saveAll(addProductEventServiceList);
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/product/service/event/SaveProductEventTriggerEventHandler.java
|
Java
|
gpl-3.0
| 3,667
|
package com.zmops.iot.web.product.service.event;
import com.zmops.iot.domain.product.ProductAttributeEvent;
import com.zmops.iot.domain.product.query.QProductAttributeEvent;
import com.zmops.iot.web.event.applicationEvent.ProductAttrCreateEvent;
import com.zmops.iot.web.product.dto.ProductAttr;
import io.ebean.DB;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.ApplicationListener;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;
import java.util.List;
/**
* @author yefei
* <p>
* 产品属性修改 同步到设备 步骤
*/
@Slf4j
@Component
public class UpdateAttributeEventEventHandler implements ApplicationListener<ProductAttrCreateEvent> {
@Override
@Async
public void onApplicationEvent(ProductAttrCreateEvent event) {
log.debug("UpdateAttributeEventWorker…………");
ProductAttr productAttr = event.getEventData();
List<ProductAttributeEvent> list = new QProductAttributeEvent().templateId.eq(productAttr.getAttrId()).findList();
for (ProductAttributeEvent productAttributeEvent : list) {
productAttributeEvent.setName(productAttr.getAttrName());
productAttributeEvent.setKey(productAttr.getKey());
productAttributeEvent.setUnits(productAttr.getUnits());
productAttributeEvent.setValueType(productAttr.getValueType());
}
DB.updateAll(list);
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/product/service/event/UpdateAttributeEventEventHandler.java
|
Java
|
gpl-3.0
| 1,465
|
package com.zmops.iot.web.product.service.event;
import com.zmops.iot.domain.device.query.QDevice;
import com.zmops.iot.domain.product.ProductServiceParam;
import com.zmops.iot.domain.product.query.QProductServiceParam;
import com.zmops.iot.util.ToolUtil;
import com.zmops.iot.web.event.applicationEvent.ProductServiceCreateEvent;
import com.zmops.iot.web.product.dto.ProductServiceDto;
import io.ebean.DB;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.ApplicationListener;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;
import java.util.ArrayList;
import java.util.List;
/**
* @author yefei
* <p>
* 产品服务修改 同步到设备 步骤
*/
@Slf4j
@Component
public class UpdateProdSvcEventHandler implements ApplicationListener<ProductServiceCreateEvent> {
@Override
@Async
public void onApplicationEvent(ProductServiceCreateEvent event) {
log.debug("UpdateProdSvcWorker…………");
ProductServiceDto productServiceDto = event.getEventData();
String prodId = productServiceDto.getRelationId();
//查询出继承了此产品的设备
List<String> deviceIds = new QDevice().select(QDevice.Alias.deviceId).productId.eq(Long.parseLong(prodId)).findSingleAttributeList();
if (ToolUtil.isEmpty(deviceIds)) {
return;
}
new QProductServiceParam().serviceId.eq(productServiceDto.getId()).deviceId.in(deviceIds).delete();
//保存设备与服务参数的 关联关系
List<ProductServiceParam> productServiceParamList = new ArrayList<>();
for (String deviceId : deviceIds) {
productServiceDto.getProductServiceParamList().forEach(productServiceParam -> {
ProductServiceParam param = new ProductServiceParam();
ToolUtil.copyProperties(productServiceParam, param);
param.setId(null);
param.setDeviceId(deviceId);
param.setServiceId(productServiceDto.getId());
productServiceParamList.add(param);
});
}
DB.saveAll(productServiceParamList);
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/product/service/event/UpdateProdSvcEventHandler.java
|
Java
|
gpl-3.0
| 2,186
|
package com.zmops.iot.web.product.service.event;
import com.zmops.iot.domain.device.query.QDevice;
import com.zmops.iot.domain.product.ProductEventService;
import com.zmops.iot.web.event.applicationEvent.ProductEventTriggerCreateEvent;
import com.zmops.iot.web.product.dto.ProductEventRule;
import com.zmops.zeus.driver.service.ZbxTrigger;
import io.ebean.DB;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationListener;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.stereotype.Component;
import java.util.ArrayList;
import java.util.List;
/**
* @author yefei
* <p>
* 产品服务创建 同步到设备 步骤
*/
@Slf4j
@Component
@EnableAsync
public class UpdateProductEventTriggerEventHandler implements ApplicationListener<ProductEventTriggerCreateEvent> {
@Autowired
ZbxTrigger zbxTrigger;
@Override
@Async
public void onApplicationEvent(ProductEventTriggerCreateEvent event) {
log.debug("UpdateProductEventTriggerWorker…………");
ProductEventRule productEventRule = event.getEventData();
String prodId = productEventRule.getProductId();
List<String> deviceIds = new QDevice().select(QDevice.Alias.deviceId).productId.eq(Long.parseLong(prodId)).findSingleAttributeList();
List<ProductEventService> addProductEventServiceList = new ArrayList<>();
for (String deviceId : deviceIds) {
productEventRule.getDeviceServices().forEach(productEventService -> {
ProductEventService newProductEventService = new ProductEventService();
newProductEventService.setDeviceId(deviceId);
newProductEventService.setExecuteDeviceId(deviceId);
newProductEventService.setEventRuleId(productEventRule.getEventRuleId());
newProductEventService.setServiceId(productEventService.getServiceId());
addProductEventServiceList.add(newProductEventService);
});
}
DB.saveAll(addProductEventServiceList);
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/product/service/event/UpdateProductEventTriggerEventHandler.java
|
Java
|
gpl-3.0
| 2,200
|
package com.zmops.iot.web.protocol.controller;
import com.dtflys.forest.Forest;
import com.zmops.iot.domain.BaseEntity;
import com.zmops.iot.domain.protocol.ProtocolComponent;
import com.zmops.iot.domain.protocol.query.QProtocolComponent;
import com.zmops.iot.model.exception.ServiceException;
import com.zmops.iot.model.page.Pager;
import com.zmops.iot.model.response.ResponseData;
import com.zmops.iot.web.exception.enums.BizExceptionEnum;
import com.zmops.iot.web.protocol.dto.ProtocolComponentDto;
import com.zmops.iot.web.protocol.dto.param.ProtocolComponentParam;
import com.zmops.iot.web.protocol.service.ProtocolComponentService;
import com.zmops.zeus.driver.service.ZeusServer;
import io.ebean.DB;
import io.ebean.annotation.Transactional;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
import java.net.URISyntaxException;
import java.util.HashMap;
import java.util.Map;
/**
* 协议组件
*
* @author yefei
**/
@RestController
@RequestMapping("/protocol/component")
public class ProtocolComponentController {
@Autowired
ProtocolComponentService protocolComponentService;
@Autowired
ZeusServer zeusServer;
/**
* 协议组件分页列表
*/
@RequestMapping("/getProtocolComponentByPage")
public Pager<ProtocolComponentDto> getProtocolComponentByPage(@RequestBody ProtocolComponentParam protocolComponentParam) {
return protocolComponentService.getProtocolComponentByPage(protocolComponentParam);
}
/**
* 协议组件列表
*/
@RequestMapping("/list")
public ResponseData list(@RequestBody ProtocolComponentParam protocolComponentParam) {
return ResponseData.success(protocolComponentService.list(protocolComponentParam));
}
/**
* 协议组件创建
*/
@RequestMapping("/create")
public ResponseData create(@Validated(BaseEntity.Create.class) @RequestBody ProtocolComponentParam protocolComponentParam) {
int count = new QProtocolComponent().name.eq(protocolComponentParam.getName()).findCount();
if (count > 0) {
throw new ServiceException(BizExceptionEnum.PROTOCOL_COMPONENT_EXISTS);
}
return ResponseData.success(protocolComponentService.create(protocolComponentParam));
}
/**
* 协议组件修改
*/
@RequestMapping("/update")
public ResponseData update(@Validated(BaseEntity.Update.class) @RequestBody ProtocolComponentParam protocolComponentParam) {
int count = new QProtocolComponent().name.eq(protocolComponentParam.getName()).protocolComponentId.ne(protocolComponentParam.getProtocolComponentId()).findCount();
if (count > 0) {
throw new ServiceException(BizExceptionEnum.PROTOCOL_COMPONENT_EXISTS);
}
return ResponseData.success(protocolComponentService.update(protocolComponentParam));
}
/**
* 协议组件上传
*/
@RequestMapping("/upload")
public ResponseData upload(@RequestParam("file") MultipartFile file, @RequestParam("protocolComponentId") Long protocolComponentId, HttpServletRequest request) throws IOException, URISyntaxException {
ProtocolComponent protocolComponent = new QProtocolComponent().protocolComponentId.eq(protocolComponentId).findOne();
if (protocolComponent == null) {
throw new ServiceException(BizExceptionEnum.PROTOCOL_COMPONENT_NOT_EXISTS);
}
try {
zeusServer.upload("127.0.0.1", file, progress -> {
System.out.println("total bytes: " + progress.getTotalBytes()); // 文件大小
System.out.println("current bytes: " + progress.getCurrentBytes()); // 已上传字节数
System.out.println("progress: " + Math.round(progress.getRate() * 100) + "%"); // 已上传百分比
if (progress.isDone()) { // 是否上传完成
System.out.println("-------- Upload Completed! --------");
}
});
} catch (Exception e) {
e.printStackTrace();
}
protocolComponent.setStatus("1");
protocolComponent.setFileName(file.getOriginalFilename());
DB.update(protocolComponent);
return ResponseData.success();
}
/**
* 协议组件删除
*/
@RequestMapping("/delete")
public ResponseData delete(@Validated(BaseEntity.Delete.class) @RequestBody ProtocolComponentParam protocolComponentParam) {
protocolComponentService.delete(protocolComponentParam.getProtocolComponentIds());
return ResponseData.success(protocolComponentParam.getProtocolComponentIds());
}
/**
* 协议组件发布
*/
@RequestMapping("/publish")
@Transactional
public ResponseData publish(@RequestParam("protocolComponentId") Long protocolComponentId) {
ProtocolComponent protocolComponent = new QProtocolComponent().protocolComponentId.eq(protocolComponentId).findOne();
if (protocolComponent == null) {
throw new ServiceException(BizExceptionEnum.PROTOCOL_COMPONENT_NOT_EXISTS);
}
protocolComponent.setStatus("2");
DB.update(protocolComponent);
//TODO 调用服务发布
Map<String, String> params = new HashMap<>(1);
params.put("protocolComponentId", protocolComponent.getProtocolComponentId() + "");
params.put("fileName", protocolComponent.getFileName());
Forest.post("/protocol/component/installArk").host("127.0.0.1").port(12800).addBody(params, "text/html;charset=utf-8").execute();
return ResponseData.success();
}
/**
* 协议组件取消发布
*/
@RequestMapping("/unPublish")
@Transactional
public ResponseData unPublish(@RequestParam("protocolComponentId") Long protocolComponentId) {
ProtocolComponent protocolComponent = new QProtocolComponent().protocolComponentId.eq(protocolComponentId).findOne();
if (protocolComponent == null) {
throw new ServiceException(BizExceptionEnum.PROTOCOL_COMPONENT_NOT_EXISTS);
}
protocolComponent.setStatus("1");
DB.update(protocolComponent);
Map<String, String> params = new HashMap<>(1);
params.put("protocolComponentId", protocolComponent.getProtocolComponentId() + "");
Forest.post("/protocol/component/uninstallArk").host("127.0.0.1").port(12800).addBody(params, "text/html;charset=utf-8").execute();
return ResponseData.success();
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/protocol/controller/ProtocolComponentController.java
|
Java
|
gpl-3.0
| 6,927
|
package com.zmops.iot.web.protocol.controller;
import com.dtflys.forest.Forest;
import com.zmops.iot.domain.BaseEntity;
import com.zmops.iot.domain.protocol.ProtocolGateway;
import com.zmops.iot.domain.protocol.query.QProtocolComponent;
import com.zmops.iot.domain.protocol.query.QProtocolGateway;
import com.zmops.iot.model.exception.ServiceException;
import com.zmops.iot.model.page.Pager;
import com.zmops.iot.model.response.ResponseData;
import com.zmops.iot.util.ToolUtil;
import com.zmops.iot.web.exception.enums.BizExceptionEnum;
import com.zmops.iot.web.protocol.dto.ProtocolGatewayDto;
import com.zmops.iot.web.protocol.dto.param.ProtocolGatewayParam;
import com.zmops.iot.web.protocol.service.ProtocolGatewayService;
import com.zmops.zeus.driver.service.ZeusServer;
import io.ebean.DB;
import io.ebean.annotation.Transactional;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import java.util.HashMap;
import java.util.Map;
/**
* 协议网关
*
* @author yefei
**/
@RestController
@RequestMapping("/protocol/gateway")
public class ProtocolGatewayController {
@Autowired
ProtocolGatewayService protocolGatewayService;
@Autowired
ZeusServer zeusServer;
/**
* 协议网关分页列表
*/
@RequestMapping("/getProtocolGatewayByPage")
public Pager<ProtocolGatewayDto> getProtocolGatewayByPage(@RequestBody ProtocolGatewayParam protocolGatewayParam) {
return protocolGatewayService.getProtocolGatewayByPage(protocolGatewayParam);
}
/**
* 协议网关列表
*/
@RequestMapping("/list")
public ResponseData list(@RequestBody ProtocolGatewayParam protocolGatewayParam) {
return ResponseData.success(protocolGatewayService.list(protocolGatewayParam));
}
/**
* 协议网关创建
*/
@RequestMapping("/create")
public ResponseData create(@Validated(BaseEntity.Create.class) @RequestBody ProtocolGatewayParam protocolGatewayParam) {
int count = new QProtocolGateway().name.eq(protocolGatewayParam.getName()).findCount();
if (count > 0) {
throw new ServiceException(BizExceptionEnum.PROTOCOL_COMPONENT_EXISTS);
}
count = new QProtocolGateway().protocolServiceId.eq(protocolGatewayParam.getProtocolServiceId()).findCount();
if (count > 0) {
throw new ServiceException(BizExceptionEnum.PROTOCOL_SERVICE_HAS_BIND_COMPONENT);
}
if(ToolUtil.isEmpty(protocolGatewayParam.getProtocolGatewayMqttList()) && ToolUtil.isEmpty(protocolGatewayParam.getProtocolComponentId())){
throw new ServiceException(BizExceptionEnum.PROTOCOL_GATEWAY_HAS_NOT_COMPONENT);
}
return ResponseData.success(protocolGatewayService.create(protocolGatewayParam));
}
/**
* 协议网关修改
*/
@RequestMapping("/update")
public ResponseData update(@Validated(BaseEntity.Update.class) @RequestBody ProtocolGatewayParam protocolGatewayParam) {
int count = new QProtocolGateway().name.eq(protocolGatewayParam.getName()).protocolGatewayId.ne(protocolGatewayParam.getProtocolGatewayId()).findCount();
if (count > 0) {
throw new ServiceException(BizExceptionEnum.PROTOCOL_COMPONENT_EXISTS);
}
count = new QProtocolGateway().protocolServiceId.eq(protocolGatewayParam.getProtocolServiceId()).protocolGatewayId.ne(protocolGatewayParam.getProtocolGatewayId()).findCount();
if (count > 0) {
throw new ServiceException(BizExceptionEnum.PROTOCOL_SERVICE_HAS_BIND_COMPONENT);
}
if(ToolUtil.isEmpty(protocolGatewayParam.getProtocolGatewayMqttList()) && ToolUtil.isEmpty(protocolGatewayParam.getProtocolComponentId())){
throw new ServiceException(BizExceptionEnum.PROTOCOL_GATEWAY_HAS_NOT_COMPONENT);
}
return ResponseData.success(protocolGatewayService.update(protocolGatewayParam));
}
/**
* 协议网关删除
*/
@RequestMapping("/delete")
public ResponseData delete(@Validated(BaseEntity.Delete.class) @RequestBody ProtocolGatewayParam protocolGatewayParam) {
protocolGatewayService.delete(protocolGatewayParam.getProtocolGatewayIds());
return ResponseData.success(protocolGatewayParam.getProtocolGatewayIds());
}
/**
* 协议网关启动
*/
@RequestMapping("/start")
@Transactional
public ResponseData start(@RequestParam("protocolGatewayId") Long protocolGatewayId) {
ProtocolGateway protocolGateway = new QProtocolGateway().protocolGatewayId.eq(protocolGatewayId).findOne();
if (protocolGateway == null) {
throw new ServiceException(BizExceptionEnum.PROTOCOL_GATEWAY_NOT_EXISTS);
}
protocolGateway.setStatus("0");
DB.update(protocolGateway);
Map<String, String> params = new HashMap<>(1);
params.put("routeId", protocolGatewayId + "");
Forest.post("/protocol/gateway/startRoute").host("127.0.0.1").port(12800).addBody(params,"text/html;charset=utf-8").execute();
return ResponseData.success();
}
/**
* 协议网关停止
*/
@RequestMapping("/stop")
@Transactional
public ResponseData stop(@RequestParam("protocolGatewayId") Long protocolGatewayId) {
ProtocolGateway protocolGateway = new QProtocolGateway().protocolGatewayId.eq(protocolGatewayId).findOne();
if (protocolGateway == null) {
throw new ServiceException(BizExceptionEnum.PROTOCOL_GATEWAY_NOT_EXISTS);
}
protocolGateway.setStatus("1");
DB.update(protocolGateway);
Map<String, String> params = new HashMap<>(1);
params.put("routeId", protocolGatewayId + "");
Forest.post("/protocol/gateway/stopRoute").host("127.0.0.1").port(12800).addBody(params,"text/html;charset=utf-8").execute();
return ResponseData.success();
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/protocol/controller/ProtocolGatewayController.java
|
Java
|
gpl-3.0
| 6,198
|
package com.zmops.iot.web.protocol.controller;
import com.zmops.iot.domain.BaseEntity;
import com.zmops.iot.domain.protocol.query.QProtocolService;
import com.zmops.iot.model.exception.ServiceException;
import com.zmops.iot.model.page.Pager;
import com.zmops.iot.model.response.ResponseData;
import com.zmops.iot.web.exception.enums.BizExceptionEnum;
import com.zmops.iot.web.protocol.dto.ProtocolServiceDto;
import com.zmops.iot.web.protocol.dto.param.ProtocolServiceParam;
import com.zmops.iot.web.protocol.service.ProtocolSvrService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* 协议服务
*
* @author yefei
**/
@RestController
@RequestMapping("/protocol/service")
public class ProtocolServiceController {
@Autowired
ProtocolSvrService protocolSvrService;
/**
* 协议服务分页列表
*/
@RequestMapping("/getProtocolServiceByPage")
public Pager<ProtocolServiceDto> getProtocolComponentByPage(@RequestBody ProtocolServiceParam protocolServiceParam) {
return protocolSvrService.getProtocolServiceByPage(protocolServiceParam);
}
/**
* 协议服务列表
*/
@RequestMapping("/list")
public ResponseData list(@RequestBody ProtocolServiceParam protocolServiceParam) {
return ResponseData.success(protocolSvrService.list(protocolServiceParam));
}
/**
* 协议服务创建
*/
@RequestMapping("/create")
public ResponseData create(@Validated(BaseEntity.Create.class) @RequestBody ProtocolServiceParam protocolServiceParam) {
int count = new QProtocolService().name.eq(protocolServiceParam.getName()).findCount();
if (count > 0) {
throw new ServiceException(BizExceptionEnum.PROTOCOL_SERVICE_EXISTS);
}
count = new QProtocolService().ip.eq(protocolServiceParam.getIp()).port.eq(protocolServiceParam.getPort()).findCount();
if (count > 0) {
throw new ServiceException(BizExceptionEnum.PROTOCOL_SERVICE_PORT_EXISTS);
}
return ResponseData.success(protocolSvrService.create(protocolServiceParam));
}
/**
* 协议服务修改
*/
@RequestMapping("/update")
public ResponseData update(@Validated(BaseEntity.Update.class) @RequestBody ProtocolServiceParam protocolServiceParam) {
int count = new QProtocolService().name.eq(protocolServiceParam.getName()).protocolServiceId.ne(protocolServiceParam.getProtocolServiceId()).findCount();
if (count > 0) {
throw new ServiceException(BizExceptionEnum.PROTOCOL_SERVICE_EXISTS);
}
count = new QProtocolService().ip.eq(protocolServiceParam.getIp()).port.eq(protocolServiceParam.getPort()).protocolServiceId.ne(protocolServiceParam.getProtocolServiceId()).findCount();
if (count > 0) {
throw new ServiceException(BizExceptionEnum.PROTOCOL_SERVICE_PORT_EXISTS);
}
return ResponseData.success(protocolSvrService.update(protocolServiceParam));
}
/**
* 协议服务删除
*/
@RequestMapping("/delete")
public ResponseData delete(@Validated(BaseEntity.Delete.class) @RequestBody ProtocolServiceParam protocolServiceParam) {
protocolSvrService.delete(protocolServiceParam.getProtocolServiceIds());
return ResponseData.success(protocolServiceParam.getProtocolServiceIds());
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/protocol/controller/ProtocolServiceController.java
|
Java
|
gpl-3.0
| 3,617
|
package com.zmops.iot.web.protocol.dto;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.zmops.iot.model.cache.filter.CachedValue;
import com.zmops.iot.model.cache.filter.CachedValueFilter;
import com.zmops.iot.model.cache.filter.DicType;
import lombok.Data;
import java.time.LocalDateTime;
/**
* @author yefei
**/
@Data
@JsonSerialize(using = CachedValueFilter.class)
public class ProtocolComponentDto {
private Long protocolComponentId;
private String name;
private String effectProxy;
@CachedValue(value = "PROTOCOL_COMPONENT_STATUS", fieldName = "statusName")
private String status;
private String remark;
private String fileName;
LocalDateTime createTime;
LocalDateTime updateTime;
@CachedValue(type = DicType.SysUserName, fieldName = "createUserName")
Long createUser;
@CachedValue(type = DicType.SysUserName, fieldName = "updateUserName")
Long updateUser;
@CachedValue(type = DicType.Tenant, fieldName = "tenantName")
Long tenantId;
private String uniqueId;
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/protocol/dto/ProtocolComponentDto.java
|
Java
|
gpl-3.0
| 1,069
|
package com.zmops.iot.web.protocol.dto;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.zmops.iot.domain.BaseEntity;
import com.zmops.iot.domain.protocol.ProtocolGatewayMqtt;
import com.zmops.iot.model.cache.filter.CachedValue;
import com.zmops.iot.model.cache.filter.CachedValueFilter;
import com.zmops.iot.model.cache.filter.DicType;
import lombok.Data;
import javax.validation.constraints.NotBlank;
import java.time.LocalDateTime;
import java.util.List;
/**
* @author yefei
**/
@Data
@JsonSerialize(using = CachedValueFilter.class)
public class ProtocolGatewayDto {
private Long protocolGatewayId;
@NotBlank(groups = {BaseEntity.Create.class})
private String name;
@CachedValue(value = "PROTOCOL_SERVICE_TYPE", fieldName = "protocolTypeName")
private String protocolType;
@CachedValue(type = DicType.ProtocolService, fieldName = "protocolServiceName")
private Long protocolServiceId;
@CachedValue(value = "PROTOCOL_GATEWAY_STATUS", fieldName = "statusName")
private String status;
private Long protocolComponentId;
private String remark;
private Integer qos;
LocalDateTime createTime;
LocalDateTime updateTime;
@CachedValue(type = DicType.SysUserName, fieldName = "createUserName")
Long createUser;
@CachedValue(type = DicType.SysUserName, fieldName = "updateUserName")
Long updateUser;
@CachedValue(type = DicType.Tenant, fieldName = "tenantName")
Long tenantId;
private List<ProtocolGatewayMqtt> protocolGatewayMqttList;
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/protocol/dto/ProtocolGatewayDto.java
|
Java
|
gpl-3.0
| 1,563
|
package com.zmops.iot.web.protocol.dto;
import lombok.Data;
import java.util.Map;
/**
* @author yefei
**/
@Data
public class ProtocolOption {
private String routeId;
private String protocol;
// private ProtocolAction action;
private Map<String, Object> options;
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/protocol/dto/ProtocolOption.java
|
Java
|
gpl-3.0
| 287
|
package com.zmops.iot.web.protocol.dto;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.zmops.iot.model.cache.filter.CachedValue;
import com.zmops.iot.model.cache.filter.CachedValueFilter;
import com.zmops.iot.model.cache.filter.DicType;
import lombok.Data;
import java.time.LocalDateTime;
/**
* @author yefei
**/
@Data
@JsonSerialize(using = CachedValueFilter.class)
public class ProtocolServiceDto {
private Long protocolServiceId;
private String name;
private String effectProxy;
@CachedValue(value = "PROTOCOL_TYPE", fieldName = "protocolTypeName")
private String protocolType;
private String remark;
private String url;
private String ip;
private Integer port;
private Integer msgLength;
private String clientId;
LocalDateTime createTime;
LocalDateTime updateTime;
@CachedValue(type = DicType.SysUserName, fieldName = "createUserName")
Long createUser;
@CachedValue(type = DicType.SysUserName, fieldName = "updateUserName")
Long updateUser;
@CachedValue(type = DicType.Tenant, fieldName = "tenantName")
Long tenantId;
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/protocol/dto/ProtocolServiceDto.java
|
Java
|
gpl-3.0
| 1,147
|
package com.zmops.iot.web.protocol.dto.param;
import com.zmops.iot.domain.BaseEntity;
import com.zmops.iot.web.sys.dto.param.BaseQueryParam;
import lombok.Data;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
import java.util.List;
/**
* @author yefei
**/
@Data
public class ProtocolComponentParam extends BaseQueryParam {
@NotNull(groups = BaseEntity.Update.class)
private Long protocolComponentId;
@NotBlank(groups = {BaseEntity.Create.class})
private String name;
private String effectProxy;
private String source;
private String status;
private String remark;
private Long tenantId;
private String fileName;
@NotNull(groups = BaseEntity.Delete.class)
private List<Long> protocolComponentIds;
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/protocol/dto/param/ProtocolComponentParam.java
|
Java
|
gpl-3.0
| 799
|
package com.zmops.iot.web.protocol.dto.param;
import com.zmops.iot.domain.BaseEntity;
import com.zmops.iot.domain.protocol.ProtocolGatewayMqtt;
import com.zmops.iot.web.sys.dto.param.BaseQueryParam;
import lombok.Data;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
import java.util.List;
/**
* @author yefei
**/
@Data
public class ProtocolGatewayParam extends BaseQueryParam {
@NotNull(groups = BaseEntity.Update.class)
private Long protocolGatewayId;
@NotBlank(groups = {BaseEntity.Create.class})
private String name;
private String protocolType;
@NotNull(groups = BaseEntity.Create.class)
private Long protocolServiceId;
private Long protocolComponentId;
private List<ProtocolGatewayMqtt> protocolGatewayMqttList;
private String remark;
private Long tenantId;
private Integer qos;
@NotNull(groups = BaseEntity.Delete.class)
private List<Long> protocolGatewayIds;
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/protocol/dto/param/ProtocolGatewayParam.java
|
Java
|
gpl-3.0
| 982
|
package com.zmops.iot.web.protocol.dto.param;
import com.zmops.iot.domain.BaseEntity;
import com.zmops.iot.web.sys.dto.param.BaseQueryParam;
import lombok.Data;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
import java.util.List;
/**
* @author yefei
**/
@Data
public class ProtocolServiceParam extends BaseQueryParam {
@NotNull(groups = BaseEntity.Update.class)
private Long protocolServiceId;
@NotBlank(groups = {BaseEntity.Create.class})
private String name;
private String effectProxy;
private String protocolType;
private String remark;
private Long tenantId;
private String url;
private String ip;
private Integer port;
private Integer msgLength;
private String clientId;
@NotNull(groups = BaseEntity.Delete.class)
private List<Long> protocolServiceIds;
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/protocol/dto/param/ProtocolServiceParam.java
|
Java
|
gpl-3.0
| 876
|
package com.zmops.iot.web.protocol.enums;
import lombok.Getter;
/**
* @author yefei
**/
public enum ProtocolEnum {
HttpServer("5","HttpServer"),
MqttClient("1","MqttClient"),
TcpServer("2","TcpServer"),
UdpServer("4","UdpServer"),
CoapServer("9","CoapServer"),
WebSocketServer("7","WebSocketServer");
@Getter
String code;
@Getter
String message;
ProtocolEnum(String code, String message) {
this.code = code;
this.message = message;
}
public static String getDescription(String status) {
if (status == null) {
return "";
} else {
for (ProtocolEnum s : ProtocolEnum.values()) {
if (s.getCode().equals(status)) {
return s.getMessage();
}
}
return "";
}
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/protocol/enums/ProtocolEnum.java
|
Java
|
gpl-3.0
| 857
|
package com.zmops.iot.web.protocol.service;
import cn.hutool.core.util.IdUtil;
import com.dtflys.forest.Forest;
import com.zmops.iot.domain.protocol.ProtocolComponent;
import com.zmops.iot.domain.protocol.query.QProtocolComponent;
import com.zmops.iot.domain.protocol.query.QProtocolGateway;
import com.zmops.iot.domain.protocol.query.QProtocolGatewayMqtt;
import com.zmops.iot.model.exception.ServiceException;
import com.zmops.iot.model.page.Pager;
import com.zmops.iot.util.ToolUtil;
import com.zmops.iot.web.exception.enums.BizExceptionEnum;
import com.zmops.iot.web.protocol.dto.ProtocolComponentDto;
import com.zmops.iot.web.protocol.dto.param.ProtocolComponentParam;
import io.ebean.DB;
import io.ebean.PagedList;
import io.ebean.annotation.Transactional;
import org.springframework.stereotype.Service;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* @author yefei
**/
@Service
public class ProtocolComponentService {
public Pager<ProtocolComponentDto> getProtocolComponentByPage(ProtocolComponentParam protocolComponentParam) {
QProtocolComponent qProtocolComponent = new QProtocolComponent();
if (ToolUtil.isNotEmpty(protocolComponentParam.getName())) {
qProtocolComponent.name.contains(protocolComponentParam.getName());
}
if (ToolUtil.isNotEmpty(protocolComponentParam.getStatus())) {
qProtocolComponent.status.eq(protocolComponentParam.getStatus());
}
PagedList<ProtocolComponent> pagedList = qProtocolComponent.setFirstRow((protocolComponentParam.getPage() - 1) * protocolComponentParam.getMaxRow())
.setMaxRows(protocolComponentParam.getMaxRow()).findPagedList();
List<ProtocolComponentDto> protocolComponentDtoList = ToolUtil.convertBean(pagedList.getList(), ProtocolComponentDto.class);
return new Pager<>(protocolComponentDtoList, pagedList.getTotalCount());
}
public List<ProtocolComponent> list(ProtocolComponentParam protocolComponentParam) {
QProtocolComponent qProtocolComponent = new QProtocolComponent();
qProtocolComponent.status.eq("2");
if (ToolUtil.isNotEmpty(protocolComponentParam.getName())) {
qProtocolComponent.name.contains(protocolComponentParam.getName());
}
if (ToolUtil.isNotEmpty(protocolComponentParam.getStatus())) {
qProtocolComponent.status.eq(protocolComponentParam.getStatus());
}
return qProtocolComponent.findList();
}
@Transactional
public ProtocolComponent create(ProtocolComponentParam protocolComponentParam) {
ProtocolComponent protocolComponent = new ProtocolComponent();
ToolUtil.copyProperties(protocolComponentParam, protocolComponent);
protocolComponent.setStatus("0");
protocolComponent.setUniqueId(IdUtil.getSnowflake().nextId() + "");
DB.insert(protocolComponent);
Map<String, String> params = new HashMap<>(1);
params.put("protocolComponentId", protocolComponent.getProtocolComponentId() + "");
params.put("uniqueId", protocolComponent.getUniqueId());
Forest.post("/protocol/component/saveProtocolComponent").host("127.0.0.1").port(12800).addBody(params, "text/html;charset=utf-8").execute();
return protocolComponent;
}
public ProtocolComponent update(ProtocolComponentParam protocolComponentParam) {
ProtocolComponent protocolComponent = new ProtocolComponent();
ToolUtil.copyProperties(protocolComponentParam, protocolComponent);
DB.update(protocolComponent);
return protocolComponent;
}
public void delete(List<Long> protocolComponentIds) {
int count = new QProtocolGateway().protocolComponentId.in(protocolComponentIds).findCount();
if (count > 0) {
throw new ServiceException(BizExceptionEnum.PROTOCOL_COMPONENT_HAS_BIND_GATEWAY);
}
count = new QProtocolGatewayMqtt().protocolComponentId.in(protocolComponentIds).findCount();
if (count > 0) {
throw new ServiceException(BizExceptionEnum.PROTOCOL_COMPONENT_HAS_BIND_GATEWAY);
}
new QProtocolComponent().protocolComponentId.in(protocolComponentIds).delete();
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/protocol/service/ProtocolComponentService.java
|
Java
|
gpl-3.0
| 4,248
|
package com.zmops.iot.web.protocol.service;
import com.alibaba.fastjson.JSON;
import com.dtflys.forest.Forest;
import com.zmops.iot.domain.protocol.ProtocolGateway;
import com.zmops.iot.domain.protocol.ProtocolGatewayMqtt;
import com.zmops.iot.domain.protocol.ProtocolService;
import com.zmops.iot.domain.protocol.query.QProtocolGateway;
import com.zmops.iot.domain.protocol.query.QProtocolGatewayMqtt;
import com.zmops.iot.domain.protocol.query.QProtocolService;
import com.zmops.iot.model.page.Pager;
import com.zmops.iot.util.ToolUtil;
import com.zmops.iot.web.protocol.dto.ProtocolGatewayDto;
import com.zmops.iot.web.protocol.dto.param.ProtocolGatewayParam;
import com.zmops.iot.web.protocol.enums.ProtocolEnum;
import io.ebean.DB;
import io.ebean.PagedList;
import io.ebean.annotation.Transactional;
import org.springframework.stereotype.Service;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
/**
* @author yefei
**/
@Service
public class ProtocolGatewayService {
public Pager<ProtocolGatewayDto> getProtocolGatewayByPage(ProtocolGatewayParam protocolGatewayParam) {
QProtocolGateway qProtocolGateway = new QProtocolGateway();
if (ToolUtil.isNotEmpty(protocolGatewayParam.getName())) {
qProtocolGateway.name.contains(protocolGatewayParam.getName());
}
if (ToolUtil.isNotEmpty(protocolGatewayParam.getProtocolType())) {
qProtocolGateway.protocolType.eq(protocolGatewayParam.getProtocolType());
}
PagedList<ProtocolGateway> pagedList = qProtocolGateway.setFirstRow((protocolGatewayParam.getPage() - 1) * protocolGatewayParam.getMaxRow())
.setMaxRows(protocolGatewayParam.getMaxRow()).findPagedList();
List<ProtocolGatewayDto> protocolGatewayDtoList = ToolUtil.convertBean(pagedList.getList(), ProtocolGatewayDto.class);
//关联mqtt协议组件
List<Long> ids = protocolGatewayDtoList.parallelStream().map(ProtocolGatewayDto::getProtocolGatewayId).collect(Collectors.toList());
List<ProtocolGatewayMqtt> topicList = new QProtocolGatewayMqtt().protocolGatewayId.in(ids).findList();
Map<Long, List<ProtocolGatewayMqtt>> topicMap = topicList.parallelStream().collect(Collectors.groupingBy(ProtocolGatewayMqtt::getProtocolGatewayId));
protocolGatewayDtoList.forEach(protocolGatewayDto -> {
if (ToolUtil.isNotEmpty(topicMap.get(protocolGatewayDto.getProtocolGatewayId()))) {
protocolGatewayDto.setProtocolGatewayMqttList(topicMap.get(protocolGatewayDto.getProtocolGatewayId()));
}
});
return new Pager<>(protocolGatewayDtoList, pagedList.getTotalCount());
}
public List<ProtocolGateway> list(ProtocolGatewayParam protocolGatewayParam) {
QProtocolGateway qProtocolGateway = new QProtocolGateway();
if (ToolUtil.isNotEmpty(protocolGatewayParam.getName())) {
qProtocolGateway.name.contains(protocolGatewayParam.getName());
}
if (ToolUtil.isNotEmpty(protocolGatewayParam.getProtocolType())) {
qProtocolGateway.protocolType.eq(protocolGatewayParam.getProtocolType());
}
return qProtocolGateway.findList();
}
@Transactional
public ProtocolGateway create(ProtocolGatewayParam protocolGatewayParam) {
ProtocolGateway protocolGateway = new ProtocolGateway();
ToolUtil.copyProperties(protocolGatewayParam, protocolGateway);
protocolGateway.setStatus("0");
DB.insert(protocolGateway);
saveMqtt(protocolGatewayParam.getProtocolGatewayMqttList(), protocolGateway.getProtocolGatewayId());
Map<String, Object> option = initOptionMap(protocolGatewayParam);
// ProtocolOption protocolOption = new ProtocolOption();
// protocolOption.setRouteId(ProtocolGateway.getProtocolGatewayId() + "");
// protocolOption.setProtocol(ProtocolEnum.getDescription(protocolGatewayParam.getProtocolType()));
// protocolOption.setOptions(option);
Map<String, Object> params = new HashMap<>(7);
params.put("routeId", protocolGateway.getProtocolGatewayId() + "");
params.put("name", protocolGateway.getName());
params.put("protocolServiceId", protocolGatewayParam.getProtocolServiceId() + "");
params.put("protocolComponentId", protocolGatewayParam.getProtocolComponentId() + "");
params.put("status", protocolGateway.getStatus());
params.put("protocol", ProtocolEnum.getDescription(protocolGatewayParam.getProtocolType()));
params.put("option", JSON.toJSONString(option));
params.put("mqttList", JSON.toJSONString(protocolGatewayParam.getProtocolGatewayMqttList()));
Forest.post("/protocol/gateway/createProtocolGateway").host("127.0.0.1").port(12800).addBody(params, "text/html;charset=utf-8").execute();
return protocolGateway;
}
private Map<String, Object> initOptionMap(ProtocolGatewayParam protocolGatewayParam) {
Map<String, Object> option = new HashMap<>(3);
ProtocolService protocolService = new QProtocolService().protocolServiceId.eq(protocolGatewayParam.getProtocolServiceId()).findOne();
option.put("hostIp", protocolService.getIp());
option.put("port", protocolService.getPort());
if (ToolUtil.isNotEmpty(protocolGatewayParam.getProtocolGatewayMqttList())) {
String topics = protocolGatewayParam.getProtocolGatewayMqttList().parallelStream().map(ProtocolGatewayMqtt::getTopic).collect(Collectors.joining(","));
option.put("topicNames", topics);
}
option.put("port", protocolService.getPort());
option.put("mqttList", protocolGatewayParam.getProtocolGatewayMqttList());
return option;
}
@Transactional
public ProtocolGateway update(ProtocolGatewayParam protocolGatewayParam) {
ProtocolGateway protocolGateway = new ProtocolGateway();
ToolUtil.copyProperties(protocolGatewayParam, protocolGateway);
DB.update(protocolGateway);
new QProtocolGatewayMqtt().protocolGatewayId.eq(protocolGatewayParam.getProtocolGatewayId()).delete();
saveMqtt(protocolGatewayParam.getProtocolGatewayMqttList(), protocolGatewayParam.getProtocolGatewayId());
return protocolGateway;
}
private void saveMqtt(List<ProtocolGatewayMqtt> protocolGatewayMqtts, Long protocolGatewayId) {
if (ToolUtil.isNotEmpty(protocolGatewayMqtts)) {
List<ProtocolGatewayMqtt> protocolGatewayMqttList = new ArrayList<>();
protocolGatewayMqtts.forEach(mqtt -> {
mqtt.setProtocolGatewayId(protocolGatewayId);
protocolGatewayMqttList.add(mqtt);
});
DB.insertAll(protocolGatewayMqttList);
}
}
public void delete(List<Long> protocolGatewayIds) {
// int count = new QProtocolGateway().protocolServiceId.in(protocolServiceIds).findCount();
// if (count > 0) {
// throw new ServiceException(BizExceptionEnum.PROTOCOL_SERVICE_HAS_BIND_GATEWAY);
// }
new QProtocolGateway().protocolGatewayId.in(protocolGatewayIds).delete();
new QProtocolGatewayMqtt().protocolGatewayId.in(protocolGatewayIds).delete();
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/protocol/service/ProtocolGatewayService.java
|
Java
|
gpl-3.0
| 7,327
|
package com.zmops.iot.web.protocol.service;
import com.dtflys.forest.Forest;
import com.zmops.iot.domain.protocol.ProtocolService;
import com.zmops.iot.domain.protocol.query.QProtocolGateway;
import com.zmops.iot.domain.protocol.query.QProtocolService;
import com.zmops.iot.model.exception.ServiceException;
import com.zmops.iot.model.page.Pager;
import com.zmops.iot.util.DefinitionsUtil;
import com.zmops.iot.util.ToolUtil;
import com.zmops.iot.web.exception.enums.BizExceptionEnum;
import com.zmops.iot.web.protocol.dto.ProtocolServiceDto;
import com.zmops.iot.web.protocol.dto.param.ProtocolServiceParam;
import com.zmops.iot.web.protocol.enums.ProtocolEnum;
import io.ebean.DB;
import io.ebean.PagedList;
import io.ebean.annotation.Transactional;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Service;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
/**
* @author yefei
**/
@Service
public class ProtocolSvrService implements CommandLineRunner {
public Pager<ProtocolServiceDto> getProtocolServiceByPage(ProtocolServiceParam protocolServiceParam) {
QProtocolService qProtocolService = new QProtocolService();
if (ToolUtil.isNotEmpty(protocolServiceParam.getName())) {
qProtocolService.name.contains(protocolServiceParam.getName());
}
if (ToolUtil.isNotEmpty(protocolServiceParam.getProtocolType())) {
qProtocolService.protocolType.eq(protocolServiceParam.getProtocolType());
}
PagedList<ProtocolService> pagedList = qProtocolService.setFirstRow((protocolServiceParam.getPage() - 1) * protocolServiceParam.getMaxRow())
.setMaxRows(protocolServiceParam.getMaxRow()).findPagedList();
List<ProtocolServiceDto> protocolComponentDtoList = ToolUtil.convertBean(pagedList.getList(), ProtocolServiceDto.class);
return new Pager<>(protocolComponentDtoList, pagedList.getTotalCount());
}
public List<ProtocolService> list(ProtocolServiceParam protocolServiceParam) {
QProtocolService qProtocolService = new QProtocolService();
if (ToolUtil.isNotEmpty(protocolServiceParam.getName())) {
qProtocolService.name.contains(protocolServiceParam.getName());
}
if (ToolUtil.isNotEmpty(protocolServiceParam.getProtocolType())) {
qProtocolService.protocolType.eq(protocolServiceParam.getProtocolType());
}
return qProtocolService.findList();
}
@Transactional
public ProtocolService create(ProtocolServiceParam protocolServiceParam) {
ProtocolService ProtocolService = new ProtocolService();
ToolUtil.copyProperties(protocolServiceParam, ProtocolService);
DB.insert(ProtocolService);
Map<String, String> params = new HashMap<>(1);
params.put("protocolServiceId", ProtocolService.getProtocolServiceId() + "");
params.put("name", ProtocolService.getName());
params.put("url", ProtocolService.getUrl());
params.put("ip", ProtocolService.getIp());
params.put("port", ProtocolService.getPort() + "");
params.put("msgLength", ProtocolService.getMsgLength() + "");
params.put("clientId", ProtocolService.getClientId());
params.put("protocol", ProtocolEnum.getDescription(ProtocolService.getProtocolType()));
params.put("remark", ProtocolService.getRemark());
Forest.post("/protocol/service/saveProtocolService").host("127.0.0.1").port(12800).addBody(params, "text/html;charset=utf-8").execute();
updateProtocolServiceEvent();
return ProtocolService;
}
@Transactional
public ProtocolService update(ProtocolServiceParam protocolServiceParam) {
ProtocolService ProtocolService = new ProtocolService();
ToolUtil.copyProperties(protocolServiceParam, ProtocolService);
DB.update(ProtocolService);
Map<String, String> params = new HashMap<>(1);
params.put("protocolServiceId", ProtocolService.getProtocolServiceId() + "");
params.put("name", ProtocolService.getName());
params.put("url", ProtocolService.getUrl());
params.put("ip", ProtocolService.getIp());
params.put("port", ProtocolService.getPort() + "");
params.put("msgLength", ProtocolService.getMsgLength() + "");
params.put("clientId", ProtocolService.getClientId());
params.put("protocol", ProtocolEnum.getDescription(ProtocolService.getProtocolType()));
params.put("remark", ProtocolService.getRemark());
Forest.post("/protocol/service/updateProtocolService").host("127.0.0.1").port(12800).addBody(params, "text/html;charset=utf-8").execute();
updateProtocolServiceEvent();
return ProtocolService;
}
public void delete(List<Long> protocolServiceIds) {
int count = new QProtocolGateway().protocolServiceId.in(protocolServiceIds).findCount();
if (count > 0) {
throw new ServiceException(BizExceptionEnum.PROTOCOL_SERVICE_HAS_BIND_GATEWAY);
}
new QProtocolService().protocolServiceId.in(protocolServiceIds).delete();
updateProtocolServiceEvent();
}
public void updateProtocolServiceEvent() {
List<ProtocolService> serviceList = new QProtocolService().findList();
Map<Long, String> map = serviceList.parallelStream().collect(Collectors.toMap(ProtocolService::getProtocolServiceId, ProtocolService::getName, (a, b) -> a));
DefinitionsUtil.updateProtocolServiceCache(map);
}
@Override
public void run(String... args) throws Exception {
//updateProtocolServiceEvent();
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/protocol/service/ProtocolSvrService.java
|
Java
|
gpl-3.0
| 5,706
|
package com.zmops.iot.web.proxy.controller;
import com.zmops.iot.domain.BaseEntity;
import com.zmops.iot.domain.proxy.query.QProxy;
import com.zmops.iot.model.exception.ServiceException;
import com.zmops.iot.model.page.Pager;
import com.zmops.iot.model.response.ResponseData;
import com.zmops.iot.web.exception.enums.BizExceptionEnum;
import com.zmops.iot.web.proxy.dto.ProxyDto;
import com.zmops.iot.web.proxy.dto.param.ProxyParam;
import com.zmops.iot.web.proxy.service.ProxyService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* @author yefei
* <p>
* 代理服务
*/
@RestController
@RequestMapping("/proxy")
public class ProxyController {
@Autowired
ProxyService proxyService;
/**
* 代理服务分页列表
*/
@RequestMapping("/getProxyByPage")
public Pager<ProxyDto> getProxyByPage(@RequestBody ProxyParam proxyParam) {
return proxyService.getProxyByPage(proxyParam);
}
/**
* 代理服务列表
*/
@RequestMapping("/list")
public ResponseData list(@RequestBody ProxyParam proxyParam) {
return ResponseData.success(proxyService.list(proxyParam));
}
/**
* 代理服务创建
*/
@RequestMapping("/create")
public ResponseData create(@Validated(BaseEntity.Create.class) @RequestBody ProxyDto proxyDto) {
int count = new QProxy().name.eq(proxyDto.getName()).findCount();
if (count > 0) {
throw new ServiceException(BizExceptionEnum.PROXY_EXISTS);
}
return ResponseData.success(proxyService.create(proxyDto));
}
/**
* 代理服务修改
*/
@RequestMapping("/update")
public ResponseData update(@Validated(BaseEntity.Update.class) @RequestBody ProxyDto proxyDto) {
int count = new QProxy().name.eq(proxyDto.getName()).id.ne(proxyDto.getId()).findCount();
if (count > 0) {
throw new ServiceException(BizExceptionEnum.PROXY_EXISTS);
}
return ResponseData.success(proxyService.update(proxyDto));
}
/**
* 代理服务删除
*/
@RequestMapping("/delete")
public ResponseData delete(@Validated(BaseEntity.Delete.class) @RequestBody ProxyDto proxyDto) {
proxyService.delete(proxyDto.getIds());
return ResponseData.success(proxyDto.getIds());
}
/**
* 监控信息
*/
@RequestMapping("/monitor/info")
public ResponseData monitorInfo() {
return ResponseData.success(proxyService.monitorInfo());
}
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/proxy/controller/ProxyController.java
|
Java
|
gpl-3.0
| 2,765
|
package com.zmops.iot.web.proxy.dto;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.zmops.iot.domain.BaseEntity;
import com.zmops.iot.model.cache.filter.CachedValue;
import com.zmops.iot.model.cache.filter.CachedValueFilter;
import com.zmops.iot.model.cache.filter.DicType;
import lombok.Data;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
import java.time.LocalDateTime;
import java.util.List;
/**
* @author yefei
**/
@Data
@JsonSerialize(using = CachedValueFilter.class)
public class ProxyDto {
@NotNull(groups = BaseEntity.Update.class)
private Long id;
@NotBlank(groups = BaseEntity.Create.class)
private String name;
private String mode;
private String address;
private String remark;
private Integer tlsAccept;
private String lastAccess;
private String autoCompress;
private String zbxId;
LocalDateTime createTime;
LocalDateTime updateTime;
@CachedValue(type = DicType.SysUserName, fieldName = "createUserName")
Long createUser;
@CachedValue(type = DicType.SysUserName, fieldName = "updateUserName")
Long updateUser;
@CachedValue(type = DicType.Tenant, fieldName = "tenantName")
Long tenantId;
@NotNull(groups = BaseEntity.Delete.class)
private List<Long> ids;
}
|
2301_81045437/zeus-iot
|
zeus-webapp/src/main/java/com/zmops/iot/web/proxy/dto/ProxyDto.java
|
Java
|
gpl-3.0
| 1,346
|