diff --git a/ems-admin/src/main/java/com/xzzn/web/controller/ems/MqttMessageController.java b/ems-admin/src/main/java/com/xzzn/web/controller/ems/MqttMessageController.java index 6fac929..a68f394 100644 --- a/ems-admin/src/main/java/com/xzzn/web/controller/ems/MqttMessageController.java +++ b/ems-admin/src/main/java/com/xzzn/web/controller/ems/MqttMessageController.java @@ -2,6 +2,7 @@ package com.xzzn.web.controller.ems; import com.xzzn.ems.service.IDDSDataProcessService; import com.xzzn.ems.service.IEmsMqttMessageService; +import com.xzzn.ems.service.IFXXAlarmDataProcessService; import com.xzzn.ems.service.IFXXDataProcessService; import com.xzzn.framework.manager.MqttLifecycleManager; import com.xzzn.framework.web.service.MqttPublisher; @@ -35,6 +36,9 @@ public class MqttMessageController implements MqttPublisher, MqttSubscriber { @Autowired private IDDSDataProcessService dDSDataProcessService; + + @Autowired + private IFXXAlarmDataProcessService fXXAlarmDataProcessService; @Autowired public MqttMessageController(MqttLifecycleManager mqttLifecycleManager) { this.mqttLifecycleManager = mqttLifecycleManager; @@ -96,7 +100,7 @@ public class MqttMessageController implements MqttPublisher, MqttSubscriber { try { // 业务处理逻辑 if (topic.startsWith("021_FXX")) { - fXXDataProcessService.handleFxAlarmData(payload); + fXXAlarmDataProcessService.handleFxAlarmData(payload); } emsMqttMessageService.insertMqttOriginalMessage(topic,payload); diff --git a/ems-system/src/main/java/com/xzzn/ems/domain/EmsClusterAlarmData.java b/ems-system/src/main/java/com/xzzn/ems/domain/EmsClusterAlarmData.java new file mode 100644 index 0000000..d550741 --- /dev/null +++ b/ems-system/src/main/java/com/xzzn/ems/domain/EmsClusterAlarmData.java @@ -0,0 +1,1410 @@ +package com.xzzn.ems.domain; + +import java.util.Date; +import com.fasterxml.jackson.annotation.JsonFormat; +import com.xzzn.common.core.domain.BaseEntity; +import org.apache.commons.lang3.builder.ToStringBuilder; +import org.apache.commons.lang3.builder.ToStringStyle; +import com.xzzn.common.annotation.Excel; + +/** + * bmsc告警数据对象 ems_cluster_alarm_data + * + * @author xzzn + * @date 2025-10-22 + */ +public class EmsClusterAlarmData extends BaseEntity +{ + private static final long serialVersionUID = 1L; + + /** 记录唯一ID */ + private Long id; + + /** 数据采集时间 */ + @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss") + @Excel(name = "数据采集时间", width = 30, dateFormat = "yyyy-MM-dd HH:mm:ss") + private Date dataTimestamp; + + /** 站点ID */ + @Excel(name = "站点ID") + private String siteId; + + /** 设备唯一标识符 */ + @Excel(name = "设备唯一标识符") + private String deviceId; + + /** 簇1主控通讯失联（0=正常，1=异常） */ + @Excel(name = "簇1主控通讯失联", readConverterExp = "0==正常，1=异常") + private Integer c1zktxsl; + + /** 簇1端电压欠压轻度告警 */ + @Excel(name = "簇1端电压欠压轻度告警") + private Integer c1ddyqyqdgj; + + /** 簇1端电压欠压中度告警 */ + @Excel(name = "簇1端电压欠压中度告警") + private Integer c1ddyqyzdgj; + + /** 簇1端电压欠压重度告警 */ + @Excel(name = "簇1端电压欠压重度告警") + private Integer c1ddyqyzzdgj; + + /** 簇1端电压过压轻度告警 */ + @Excel(name = "簇1端电压过压轻度告警") + private Integer c1ddygyqdgj; + + /** 簇1端电压过压中度告警 */ + @Excel(name = "簇1端电压过压中度告警") + private Integer c1ddygyzdgj; + + /** 簇1端电压过压重度告警 */ + @Excel(name = "簇1端电压过压重度告警") + private Integer c1ddygyzzdgj; + + /** 簇1端电流轻度告警 */ + @Excel(name = "簇1端电流轻度告警") + private Integer c1ddlqdgj; + + /** 簇1端电流中度告警 */ + @Excel(name = "簇1端电流中度告警") + private Integer c1ddlzdgj; + + /** 簇1端电流重度告警 */ + @Excel(name = "簇1端电流重度告警") + private Integer c1ddlzzdgj; + + /** 簇1单体欠压轻度告警 */ + @Excel(name = "簇1单体欠压轻度告警") + private Integer c1dtqyqdgj; + + /** 簇1单体欠压中度告警 */ + @Excel(name = "簇1单体欠压中度告警") + private Integer c1dtqyzdgj; + + /** 簇1单体欠压重度告警 */ + @Excel(name = "簇1单体欠压重度告警") + private Integer c1dtqyzzdgj; + + /** 簇1单体过压轻度告警 */ + @Excel(name = "簇1单体过压轻度告警") + private Integer c1dtgyqdgj; + + /** 簇1单体过压中度告警 */ + @Excel(name = "簇1单体过压中度告警") + private Integer c1dtgyzdgj; + + /** 簇1单体过压重度告警 */ + @Excel(name = "簇1单体过压重度告警") + private Integer c1dtgyzzdgj; + + /** 簇1单体欠温轻度告警 */ + @Excel(name = "簇1单体欠温轻度告警") + private Integer c1dtqwqdgj; + + /** 簇1单体欠温中度告警 */ + @Excel(name = "簇1单体欠温中度告警") + private Integer c1dtqwzdgj; + + /** 簇1单体欠温重度告警 */ + @Excel(name = "簇1单体欠温重度告警") + private Integer c1dtqwzzdgj; + + /** 簇1单体过温轻度告警 */ + @Excel(name = "簇1单体过温轻度告警") + private Integer c1dtgwqdgj; + + /** 簇1单体过温中度告警 */ + @Excel(name = "簇1单体过温中度告警") + private Integer c1dtgwzdgj; + + /** 簇1单体过温重度告警 */ + @Excel(name = "簇1单体过温重度告警") + private Integer c1dtgwzzdgj; + + /** 簇1单体SOC低轻度告警 */ + @Excel(name = "簇1单体SOC低轻度告警") + private Integer c1socdqdgj; + + /** 簇1单体SOC低中度告警 */ + @Excel(name = "簇1单体SOC低中度告警") + private Integer c1socdzdgj; + + /** 簇1单体SOC低重度告警 */ + @Excel(name = "簇1单体SOC低重度告警") + private Integer c1socdzzdgj; + + /** 簇1单体SOC高轻度告警 */ + @Excel(name = "簇1单体SOC高轻度告警") + private Integer c1socgqdgj; + + /** 簇1单体SOC高中度告警 */ + @Excel(name = "簇1单体SOC高中度告警") + private Integer c1socgzdgj; + + /** 簇1单体SOC高重度告警 */ + @Excel(name = "簇1单体SOC高重度告警") + private Integer c1socgzzdgj; + + /** 簇1单体SOH低轻度告警 */ + @Excel(name = "簇1单体SOH低轻度告警") + private Integer c1sohdqdgj; + + /** 簇1单体SOH低中度告警 */ + @Excel(name = "簇1单体SOH低中度告警") + private Integer c1sohdzdgj; + + /** 簇1单体SOH低重度告警 */ + @Excel(name = "簇1单体SOH低重度告警") + private Integer c1sohdzzdgj; + + /** 簇1单体压差轻度告警 */ + @Excel(name = "簇1单体压差轻度告警") + private Integer c1dtycqdgj; + + /** 簇1单体压差中度告警 */ + @Excel(name = "簇1单体压差中度告警") + private Integer c1dtyczdgj; + + /** 簇1单体压差重度告警 */ + @Excel(name = "簇1单体压差重度告警") + private Integer c1dtyczzdgj; + + /** 簇1单体温差轻度告警 */ + @Excel(name = "簇1单体温差轻度告警") + private Integer c1dtwcqdgj; + + /** 簇1单体温差中度告警 */ + @Excel(name = "簇1单体温差中度告警") + private Integer c1dtwczdgj; + + /** 簇1单体温差重度告警 */ + @Excel(name = "簇1单体温差重度告警") + private Integer c1dtwczzdgj; + + /** 簇1从控1通讯失联 */ + @Excel(name = "簇1从控1通讯失联") + private Integer c1ck1txsl; + + /** 簇1从控2通讯失联 */ + @Excel(name = "簇1从控2通讯失联") + private Integer c1ck2txsl; + + /** 簇1从控3通讯失联 */ + @Excel(name = "簇1从控3通讯失联") + private Integer c1ck3txsl; + + /** 簇1从控4通讯失联 */ + @Excel(name = "簇1从控4通讯失联") + private Integer c1ck4txsl; + + /** 簇1从控5通讯失联 */ + @Excel(name = "簇1从控5通讯失联") + private Integer c1ck5txsl; + + /** 簇1从控6通讯失联 */ + @Excel(name = "簇1从控6通讯失联") + private Integer c1ck6txsl; + + /** 簇1从控7通讯失联 */ + @Excel(name = "簇1从控7通讯失联") + private Integer c1ck7txsl; + + /** 簇1从控8通讯失联 */ + @Excel(name = "簇1从控8通讯失联") + private Integer c1ck8txsl; + + /** 簇1从控9通讯失联 */ + @Excel(name = "簇1从控9通讯失联") + private Integer c1ck9txsl; + + /** 簇1从控10通讯失联 */ + @Excel(name = "簇1从控10通讯失联") + private Integer c1ck10txsl; + + /** 簇1从控11通讯失联 */ + @Excel(name = "簇1从控11通讯失联") + private Integer c1ck11txsl; + + /** 簇1从控12通讯失联 */ + @Excel(name = "簇1从控12通讯失联") + private Integer c1ck12txsl; + + /** 簇1从控13通讯失联 */ + @Excel(name = "簇1从控13通讯失联") + private Integer c1ck13txsl; + + /** 簇1从控14通讯失联 */ + @Excel(name = "簇1从控14通讯失联") + private Integer c1ck14txsl; + + /** 簇1从控15通讯失联 */ + @Excel(name = "簇1从控15通讯失联") + private Integer c1ck15txsl; + + /** 簇1从控16通讯失联 */ + @Excel(name = "簇1从控16通讯失联") + private Integer c1ck16txsl; + + /** 簇1从控17通讯失联 */ + @Excel(name = "簇1从控17通讯失联") + private Integer c1ck17txsl; + + /** 簇1从控18通讯失联 */ + @Excel(name = "簇1从控18通讯失联") + private Integer c1ck18txsl; + + /** 簇1从控19通讯失联 */ + @Excel(name = "簇1从控19通讯失联") + private Integer c1ck19txsl; + + /** 簇1从控20通讯失联 */ + @Excel(name = "簇1从控20通讯失联") + private Integer c1ck20txsl; + + /** 簇1从控21通讯失联 */ + @Excel(name = "簇1从控21通讯失联") + private Integer c1ck21txsl; + + /** 簇1从控22通讯失联 */ + @Excel(name = "簇1从控22通讯失联") + private Integer c1ck22txsl; + + /** 簇1从控23通讯失联 */ + @Excel(name = "簇1从控23通讯失联") + private Integer c1ck23txsl; + + /** 簇1从控24通讯失联 */ + @Excel(name = "簇1从控24通讯失联") + private Integer c1ck24txsl; + + /** 簇1从控25通讯失联 */ + @Excel(name = "簇1从控25通讯失联") + private Integer c1ck25txsl; + + /** 簇1从控26通讯失联 */ + @Excel(name = "簇1从控26通讯失联") + private Integer c1ck26txsl; + + /** 簇1从控27通讯失联 */ + @Excel(name = "簇1从控27通讯失联") + private Integer c1ck27txsl; + + /** 簇1从控28通讯失联 */ + @Excel(name = "簇1从控28通讯失联") + private Integer c1ck28txsl; + + /** 簇1从控29通讯失联 */ + @Excel(name = "簇1从控29通讯失联") + private Integer c1ck29txsl; + + /** 簇1从控30通讯失联 */ + @Excel(name = "簇1从控30通讯失联") + private Integer c1ck30txsl; + + /** 簇1从控31通讯失联 */ + @Excel(name = "簇1从控31通讯失联") + private Integer c1ck31txsl; + + /** 簇1从控32通讯失联 */ + @Excel(name = "簇1从控32通讯失联") + private Integer c1ck32txsl; + + /** 簇1从控33通讯失联 */ + @Excel(name = "簇1从控33通讯失联") + private Integer c1ck33txsl; + + /** 簇1从控34通讯失联 */ + @Excel(name = "簇1从控34通讯失联") + private Integer c1ck34txsl; + + /** 簇1从控35通讯失联 */ + @Excel(name = "簇1从控35通讯失联") + private Integer c1ck35txsl; + + /** 簇1从控36通讯失联 */ + @Excel(name = "簇1从控36通讯失联") + private Integer c1ck36txsl; + + /** 簇1从控37通讯失联 */ + @Excel(name = "簇1从控37通讯失联") + private Integer c1ck37txsl; + + /** 簇1从控38通讯失联 */ + @Excel(name = "簇1从控38通讯失联") + private Integer c1ck38txsl; + + /** 簇1从控39通讯失联 */ + @Excel(name = "簇1从控39通讯失联") + private Integer c1ck39txsl; + + /** 簇1从控40通讯失联 */ + @Excel(name = "簇1从控40通讯失联") + private Integer c1ck40txsl; + + /** 簇1端子温度过高轻度告警 */ + @Excel(name = "簇1端子温度过高轻度告警") + private Integer c1dzwdggqdgj; + + /** 簇1端子温度过高中度告警 */ + @Excel(name = "簇1端子温度过高中度告警") + private Integer c1dzwdggzdgj; + + /** 簇1端子温度过高重度告警 */ + @Excel(name = "簇1端子温度过高重度告警") + private Integer c1dzwdggzzdgj; + + /** 簇1模块电压过高轻度告警 */ + @Excel(name = "簇1模块电压过高轻度告警") + private Integer c1mkdyggqdgj; + + /** 簇1模块电压过高中度告警 */ + @Excel(name = "簇1模块电压过高中度告警") + private Integer c1mkdyggzdgj; + + /** 簇1模块电压过高重度告警 */ + @Excel(name = "簇1模块电压过高重度告警") + private Integer c1mkdyggzzdgj; + + /** 簇1模块电压过低轻度告警 */ + @Excel(name = "簇1模块电压过低轻度告警") + private Integer c1mkdygdqdgj; + + /** 簇1模块电压过低中度告警 */ + @Excel(name = "簇1模块电压过低中度告警") + private Integer c1mkdygdzdgj; + + /** 簇1模块电压过低重度告警 */ + @Excel(name = "簇1模块电压过低重度告警") + private Integer c1mkdygdzzdgj; + + /** 簇1电压采集故障 */ + @Excel(name = "簇1电压采集故障") + private Integer c1dycjgz; + + /** 簇1温度采集故障 */ + @Excel(name = "簇1温度采集故障") + private Integer c1wdcjgz; + + public void setId(Long id) + { + this.id = id; + } + + public Long getId() + { + return id; + } + + public void setDataTimestamp(Date dataTimestamp) + { + this.dataTimestamp = dataTimestamp; + } + + public Date getDataTimestamp() + { + return dataTimestamp; + } + + public void setSiteId(String siteId) + { + this.siteId = siteId; + } + + public String getSiteId() + { + return siteId; + } + + public void setDeviceId(String deviceId) + { + this.deviceId = deviceId; + } + + public String getDeviceId() + { + return deviceId; + } + + public void setC1zktxsl(Integer c1zktxsl) + { + this.c1zktxsl = c1zktxsl; + } + + public Integer getC1zktxsl() + { + return c1zktxsl; + } + + public void setC1ddyqyqdgj(Integer c1ddyqyqdgj) + { + this.c1ddyqyqdgj = c1ddyqyqdgj; + } + + public Integer getC1ddyqyqdgj() + { + return c1ddyqyqdgj; + } + + public void setC1ddyqyzdgj(Integer c1ddyqyzdgj) + { + this.c1ddyqyzdgj = c1ddyqyzdgj; + } + + public Integer getC1ddyqyzdgj() + { + return c1ddyqyzdgj; + } + + public void setC1ddyqyzzdgj(Integer c1ddyqyzzdgj) + { + this.c1ddyqyzzdgj = c1ddyqyzzdgj; + } + + public Integer getC1ddyqyzzdgj() + { + return c1ddyqyzzdgj; + } + + public void setC1ddygyqdgj(Integer c1ddygyqdgj) + { + this.c1ddygyqdgj = c1ddygyqdgj; + } + + public Integer getC1ddygyqdgj() + { + return c1ddygyqdgj; + } + + public void setC1ddygyzdgj(Integer c1ddygyzdgj) + { + this.c1ddygyzdgj = c1ddygyzdgj; + } + + public Integer getC1ddygyzdgj() + { + return c1ddygyzdgj; + } + + public void setC1ddygyzzdgj(Integer c1ddygyzzdgj) + { + this.c1ddygyzzdgj = c1ddygyzzdgj; + } + + public Integer getC1ddygyzzdgj() + { + return c1ddygyzzdgj; + } + + public void setC1ddlqdgj(Integer c1ddlqdgj) + { + this.c1ddlqdgj = c1ddlqdgj; + } + + public Integer getC1ddlqdgj() + { + return c1ddlqdgj; + } + + public void setC1ddlzdgj(Integer c1ddlzdgj) + { + this.c1ddlzdgj = c1ddlzdgj; + } + + public Integer getC1ddlzdgj() + { + return c1ddlzdgj; + } + + public void setC1ddlzzdgj(Integer c1ddlzzdgj) + { + this.c1ddlzzdgj = c1ddlzzdgj; + } + + public Integer getC1ddlzzdgj() + { + return c1ddlzzdgj; + } + + public void setC1dtqyqdgj(Integer c1dtqyqdgj) + { + this.c1dtqyqdgj = c1dtqyqdgj; + } + + public Integer getC1dtqyqdgj() + { + return c1dtqyqdgj; + } + + public void setC1dtqyzdgj(Integer c1dtqyzdgj) + { + this.c1dtqyzdgj = c1dtqyzdgj; + } + + public Integer getC1dtqyzdgj() + { + return c1dtqyzdgj; + } + + public void setC1dtqyzzdgj(Integer c1dtqyzzdgj) + { + this.c1dtqyzzdgj = c1dtqyzzdgj; + } + + public Integer getC1dtqyzzdgj() + { + return c1dtqyzzdgj; + } + + public void setC1dtgyqdgj(Integer c1dtgyqdgj) + { + this.c1dtgyqdgj = c1dtgyqdgj; + } + + public Integer getC1dtgyqdgj() + { + return c1dtgyqdgj; + } + + public void setC1dtgyzdgj(Integer c1dtgyzdgj) + { + this.c1dtgyzdgj = c1dtgyzdgj; + } + + public Integer getC1dtgyzdgj() + { + return c1dtgyzdgj; + } + + public void setC1dtgyzzdgj(Integer c1dtgyzzdgj) + { + this.c1dtgyzzdgj = c1dtgyzzdgj; + } + + public Integer getC1dtgyzzdgj() + { + return c1dtgyzzdgj; + } + + public void setC1dtqwqdgj(Integer c1dtqwqdgj) + { + this.c1dtqwqdgj = c1dtqwqdgj; + } + + public Integer getC1dtqwqdgj() + { + return c1dtqwqdgj; + } + + public void setC1dtqwzdgj(Integer c1dtqwzdgj) + { + this.c1dtqwzdgj = c1dtqwzdgj; + } + + public Integer getC1dtqwzdgj() + { + return c1dtqwzdgj; + } + + public void setC1dtqwzzdgj(Integer c1dtqwzzdgj) + { + this.c1dtqwzzdgj = c1dtqwzzdgj; + } + + public Integer getC1dtqwzzdgj() + { + return c1dtqwzzdgj; + } + + public void setC1dtgwqdgj(Integer c1dtgwqdgj) + { + this.c1dtgwqdgj = c1dtgwqdgj; + } + + public Integer getC1dtgwqdgj() + { + return c1dtgwqdgj; + } + + public void setC1dtgwzdgj(Integer c1dtgwzdgj) + { + this.c1dtgwzdgj = c1dtgwzdgj; + } + + public Integer getC1dtgwzdgj() + { + return c1dtgwzdgj; + } + + public void setC1dtgwzzdgj(Integer c1dtgwzzdgj) + { + this.c1dtgwzzdgj = c1dtgwzzdgj; + } + + public Integer getC1dtgwzzdgj() + { + return c1dtgwzzdgj; + } + + public void setC1socdqdgj(Integer c1socdqdgj) + { + this.c1socdqdgj = c1socdqdgj; + } + + public Integer getC1socdqdgj() + { + return c1socdqdgj; + } + + public void setC1socdzdgj(Integer c1socdzdgj) + { + this.c1socdzdgj = c1socdzdgj; + } + + public Integer getC1socdzdgj() + { + return c1socdzdgj; + } + + public void setC1socdzzdgj(Integer c1socdzzdgj) + { + this.c1socdzzdgj = c1socdzzdgj; + } + + public Integer getC1socdzzdgj() + { + return c1socdzzdgj; + } + + public void setC1socgqdgj(Integer c1socgqdgj) + { + this.c1socgqdgj = c1socgqdgj; + } + + public Integer getC1socgqdgj() + { + return c1socgqdgj; + } + + public void setC1socgzdgj(Integer c1socgzdgj) + { + this.c1socgzdgj = c1socgzdgj; + } + + public Integer getC1socgzdgj() + { + return c1socgzdgj; + } + + public void setC1socgzzdgj(Integer c1socgzzdgj) + { + this.c1socgzzdgj = c1socgzzdgj; + } + + public Integer getC1socgzzdgj() + { + return c1socgzzdgj; + } + + public void setC1sohdqdgj(Integer c1sohdqdgj) + { + this.c1sohdqdgj = c1sohdqdgj; + } + + public Integer getC1sohdqdgj() + { + return c1sohdqdgj; + } + + public void setC1sohdzdgj(Integer c1sohdzdgj) + { + this.c1sohdzdgj = c1sohdzdgj; + } + + public Integer getC1sohdzdgj() + { + return c1sohdzdgj; + } + + public void setC1sohdzzdgj(Integer c1sohdzzdgj) + { + this.c1sohdzzdgj = c1sohdzzdgj; + } + + public Integer getC1sohdzzdgj() + { + return c1sohdzzdgj; + } + + public void setC1dtycqdgj(Integer c1dtycqdgj) + { + this.c1dtycqdgj = c1dtycqdgj; + } + + public Integer getC1dtycqdgj() + { + return c1dtycqdgj; + } + + public void setC1dtyczdgj(Integer c1dtyczdgj) + { + this.c1dtyczdgj = c1dtyczdgj; + } + + public Integer getC1dtyczdgj() + { + return c1dtyczdgj; + } + + public void setC1dtyczzdgj(Integer c1dtyczzdgj) + { + this.c1dtyczzdgj = c1dtyczzdgj; + } + + public Integer getC1dtyczzdgj() + { + return c1dtyczzdgj; + } + + public void setC1dtwcqdgj(Integer c1dtwcqdgj) + { + this.c1dtwcqdgj = c1dtwcqdgj; + } + + public Integer getC1dtwcqdgj() + { + return c1dtwcqdgj; + } + + public void setC1dtwczdgj(Integer c1dtwczdgj) + { + this.c1dtwczdgj = c1dtwczdgj; + } + + public Integer getC1dtwczdgj() + { + return c1dtwczdgj; + } + + public void setC1dtwczzdgj(Integer c1dtwczzdgj) + { + this.c1dtwczzdgj = c1dtwczzdgj; + } + + public Integer getC1dtwczzdgj() + { + return c1dtwczzdgj; + } + + public void setC1ck1txsl(Integer c1ck1txsl) + { + this.c1ck1txsl = c1ck1txsl; + } + + public Integer getC1ck1txsl() + { + return c1ck1txsl; + } + + public void setC1ck2txsl(Integer c1ck2txsl) + { + this.c1ck2txsl = c1ck2txsl; + } + + public Integer getC1ck2txsl() + { + return c1ck2txsl; + } + + public void setC1ck3txsl(Integer c1ck3txsl) + { + this.c1ck3txsl = c1ck3txsl; + } + + public Integer getC1ck3txsl() + { + return c1ck3txsl; + } + + public void setC1ck4txsl(Integer c1ck4txsl) + { + this.c1ck4txsl = c1ck4txsl; + } + + public Integer getC1ck4txsl() + { + return c1ck4txsl; + } + + public void setC1ck5txsl(Integer c1ck5txsl) + { + this.c1ck5txsl = c1ck5txsl; + } + + public Integer getC1ck5txsl() + { + return c1ck5txsl; + } + + public void setC1ck6txsl(Integer c1ck6txsl) + { + this.c1ck6txsl = c1ck6txsl; + } + + public Integer getC1ck6txsl() + { + return c1ck6txsl; + } + + public void setC1ck7txsl(Integer c1ck7txsl) + { + this.c1ck7txsl = c1ck7txsl; + } + + public Integer getC1ck7txsl() + { + return c1ck7txsl; + } + + public void setC1ck8txsl(Integer c1ck8txsl) + { + this.c1ck8txsl = c1ck8txsl; + } + + public Integer getC1ck8txsl() + { + return c1ck8txsl; + } + + public void setC1ck9txsl(Integer c1ck9txsl) + { + this.c1ck9txsl = c1ck9txsl; + } + + public Integer getC1ck9txsl() + { + return c1ck9txsl; + } + + public void setC1ck10txsl(Integer c1ck10txsl) + { + this.c1ck10txsl = c1ck10txsl; + } + + public Integer getC1ck10txsl() + { + return c1ck10txsl; + } + + public void setC1ck11txsl(Integer c1ck11txsl) + { + this.c1ck11txsl = c1ck11txsl; + } + + public Integer getC1ck11txsl() + { + return c1ck11txsl; + } + + public void setC1ck12txsl(Integer c1ck12txsl) + { + this.c1ck12txsl = c1ck12txsl; + } + + public Integer getC1ck12txsl() + { + return c1ck12txsl; + } + + public void setC1ck13txsl(Integer c1ck13txsl) + { + this.c1ck13txsl = c1ck13txsl; + } + + public Integer getC1ck13txsl() + { + return c1ck13txsl; + } + + public void setC1ck14txsl(Integer c1ck14txsl) + { + this.c1ck14txsl = c1ck14txsl; + } + + public Integer getC1ck14txsl() + { + return c1ck14txsl; + } + + public void setC1ck15txsl(Integer c1ck15txsl) + { + this.c1ck15txsl = c1ck15txsl; + } + + public Integer getC1ck15txsl() + { + return c1ck15txsl; + } + + public void setC1ck16txsl(Integer c1ck16txsl) + { + this.c1ck16txsl = c1ck16txsl; + } + + public Integer getC1ck16txsl() + { + return c1ck16txsl; + } + + public void setC1ck17txsl(Integer c1ck17txsl) + { + this.c1ck17txsl = c1ck17txsl; + } + + public Integer getC1ck17txsl() + { + return c1ck17txsl; + } + + public void setC1ck18txsl(Integer c1ck18txsl) + { + this.c1ck18txsl = c1ck18txsl; + } + + public Integer getC1ck18txsl() + { + return c1ck18txsl; + } + + public void setC1ck19txsl(Integer c1ck19txsl) + { + this.c1ck19txsl = c1ck19txsl; + } + + public Integer getC1ck19txsl() + { + return c1ck19txsl; + } + + public void setC1ck20txsl(Integer c1ck20txsl) + { + this.c1ck20txsl = c1ck20txsl; + } + + public Integer getC1ck20txsl() + { + return c1ck20txsl; + } + + public void setC1ck21txsl(Integer c1ck21txsl) + { + this.c1ck21txsl = c1ck21txsl; + } + + public Integer getC1ck21txsl() + { + return c1ck21txsl; + } + + public void setC1ck22txsl(Integer c1ck22txsl) + { + this.c1ck22txsl = c1ck22txsl; + } + + public Integer getC1ck22txsl() + { + return c1ck22txsl; + } + + public void setC1ck23txsl(Integer c1ck23txsl) + { + this.c1ck23txsl = c1ck23txsl; + } + + public Integer getC1ck23txsl() + { + return c1ck23txsl; + } + + public void setC1ck24txsl(Integer c1ck24txsl) + { + this.c1ck24txsl = c1ck24txsl; + } + + public Integer getC1ck24txsl() + { + return c1ck24txsl; + } + + public void setC1ck25txsl(Integer c1ck25txsl) + { + this.c1ck25txsl = c1ck25txsl; + } + + public Integer getC1ck25txsl() + { + return c1ck25txsl; + } + + public void setC1ck26txsl(Integer c1ck26txsl) + { + this.c1ck26txsl = c1ck26txsl; + } + + public Integer getC1ck26txsl() + { + return c1ck26txsl; + } + + public void setC1ck27txsl(Integer c1ck27txsl) + { + this.c1ck27txsl = c1ck27txsl; + } + + public Integer getC1ck27txsl() + { + return c1ck27txsl; + } + + public void setC1ck28txsl(Integer c1ck28txsl) + { + this.c1ck28txsl = c1ck28txsl; + } + + public Integer getC1ck28txsl() + { + return c1ck28txsl; + } + + public void setC1ck29txsl(Integer c1ck29txsl) + { + this.c1ck29txsl = c1ck29txsl; + } + + public Integer getC1ck29txsl() + { + return c1ck29txsl; + } + + public void setC1ck30txsl(Integer c1ck30txsl) + { + this.c1ck30txsl = c1ck30txsl; + } + + public Integer getC1ck30txsl() + { + return c1ck30txsl; + } + + public void setC1ck31txsl(Integer c1ck31txsl) + { + this.c1ck31txsl = c1ck31txsl; + } + + public Integer getC1ck31txsl() + { + return c1ck31txsl; + } + + public void setC1ck32txsl(Integer c1ck32txsl) + { + this.c1ck32txsl = c1ck32txsl; + } + + public Integer getC1ck32txsl() + { + return c1ck32txsl; + } + + public void setC1ck33txsl(Integer c1ck33txsl) + { + this.c1ck33txsl = c1ck33txsl; + } + + public Integer getC1ck33txsl() + { + return c1ck33txsl; + } + + public void setC1ck34txsl(Integer c1ck34txsl) + { + this.c1ck34txsl = c1ck34txsl; + } + + public Integer getC1ck34txsl() + { + return c1ck34txsl; + } + + public void setC1ck35txsl(Integer c1ck35txsl) + { + this.c1ck35txsl = c1ck35txsl; + } + + public Integer getC1ck35txsl() + { + return c1ck35txsl; + } + + public void setC1ck36txsl(Integer c1ck36txsl) + { + this.c1ck36txsl = c1ck36txsl; + } + + public Integer getC1ck36txsl() + { + return c1ck36txsl; + } + + public void setC1ck37txsl(Integer c1ck37txsl) + { + this.c1ck37txsl = c1ck37txsl; + } + + public Integer getC1ck37txsl() + { + return c1ck37txsl; + } + + public void setC1ck38txsl(Integer c1ck38txsl) + { + this.c1ck38txsl = c1ck38txsl; + } + + public Integer getC1ck38txsl() + { + return c1ck38txsl; + } + + public void setC1ck39txsl(Integer c1ck39txsl) + { + this.c1ck39txsl = c1ck39txsl; + } + + public Integer getC1ck39txsl() + { + return c1ck39txsl; + } + + public void setC1ck40txsl(Integer c1ck40txsl) + { + this.c1ck40txsl = c1ck40txsl; + } + + public Integer getC1ck40txsl() + { + return c1ck40txsl; + } + + public void setC1dzwdggqdgj(Integer c1dzwdggqdgj) + { + this.c1dzwdggqdgj = c1dzwdggqdgj; + } + + public Integer getC1dzwdggqdgj() + { + return c1dzwdggqdgj; + } + + public void setC1dzwdggzdgj(Integer c1dzwdggzdgj) + { + this.c1dzwdggzdgj = c1dzwdggzdgj; + } + + public Integer getC1dzwdggzdgj() + { + return c1dzwdggzdgj; + } + + public void setC1dzwdggzzdgj(Integer c1dzwdggzzdgj) + { + this.c1dzwdggzzdgj = c1dzwdggzzdgj; + } + + public Integer getC1dzwdggzzdgj() + { + return c1dzwdggzzdgj; + } + + public void setC1mkdyggqdgj(Integer c1mkdyggqdgj) + { + this.c1mkdyggqdgj = c1mkdyggqdgj; + } + + public Integer getC1mkdyggqdgj() + { + return c1mkdyggqdgj; + } + + public void setC1mkdyggzdgj(Integer c1mkdyggzdgj) + { + this.c1mkdyggzdgj = c1mkdyggzdgj; + } + + public Integer getC1mkdyggzdgj() + { + return c1mkdyggzdgj; + } + + public void setC1mkdyggzzdgj(Integer c1mkdyggzzdgj) + { + this.c1mkdyggzzdgj = c1mkdyggzzdgj; + } + + public Integer getC1mkdyggzzdgj() + { + return c1mkdyggzzdgj; + } + + public void setC1mkdygdqdgj(Integer c1mkdygdqdgj) + { + this.c1mkdygdqdgj = c1mkdygdqdgj; + } + + public Integer getC1mkdygdqdgj() + { + return c1mkdygdqdgj; + } + + public void setC1mkdygdzdgj(Integer c1mkdygdzdgj) + { + this.c1mkdygdzdgj = c1mkdygdzdgj; + } + + public Integer getC1mkdygdzdgj() + { + return c1mkdygdzdgj; + } + + public void setC1mkdygdzzdgj(Integer c1mkdygdzzdgj) + { + this.c1mkdygdzzdgj = c1mkdygdzzdgj; + } + + public Integer getC1mkdygdzzdgj() + { + return c1mkdygdzzdgj; + } + + public void setC1dycjgz(Integer c1dycjgz) + { + this.c1dycjgz = c1dycjgz; + } + + public Integer getC1dycjgz() + { + return c1dycjgz; + } + + public void setC1wdcjgz(Integer c1wdcjgz) + { + this.c1wdcjgz = c1wdcjgz; + } + + public Integer getC1wdcjgz() + { + return c1wdcjgz; + } + + @Override + public String toString() { + return new ToStringBuilder(this,ToStringStyle.MULTI_LINE_STYLE) + .append("id", getId()) + .append("dataTimestamp", getDataTimestamp()) + .append("siteId", getSiteId()) + .append("deviceId", getDeviceId()) + .append("c1zktxsl", getC1zktxsl()) + .append("c1ddyqyqdgj", getC1ddyqyqdgj()) + .append("c1ddyqyzdgj", getC1ddyqyzdgj()) + .append("c1ddyqyzzdgj", getC1ddyqyzzdgj()) + .append("c1ddygyqdgj", getC1ddygyqdgj()) + .append("c1ddygyzdgj", getC1ddygyzdgj()) + .append("c1ddygyzzdgj", getC1ddygyzzdgj()) + .append("c1ddlqdgj", getC1ddlqdgj()) + .append("c1ddlzdgj", getC1ddlzdgj()) + .append("c1ddlzzdgj", getC1ddlzzdgj()) + .append("c1dtqyqdgj", getC1dtqyqdgj()) + .append("c1dtqyzdgj", getC1dtqyzdgj()) + .append("c1dtqyzzdgj", getC1dtqyzzdgj()) + .append("c1dtgyqdgj", getC1dtgyqdgj()) + .append("c1dtgyzdgj", getC1dtgyzdgj()) + .append("c1dtgyzzdgj", getC1dtgyzzdgj()) + .append("c1dtqwqdgj", getC1dtqwqdgj()) + .append("c1dtqwzdgj", getC1dtqwzdgj()) + .append("c1dtqwzzdgj", getC1dtqwzzdgj()) + .append("c1dtgwqdgj", getC1dtgwqdgj()) + .append("c1dtgwzdgj", getC1dtgwzdgj()) + .append("c1dtgwzzdgj", getC1dtgwzzdgj()) + .append("c1socdqdgj", getC1socdqdgj()) + .append("c1socdzdgj", getC1socdzdgj()) + .append("c1socdzzdgj", getC1socdzzdgj()) + .append("c1socgqdgj", getC1socgqdgj()) + .append("c1socgzdgj", getC1socgzdgj()) + .append("c1socgzzdgj", getC1socgzzdgj()) + .append("c1sohdqdgj", getC1sohdqdgj()) + .append("c1sohdzdgj", getC1sohdzdgj()) + .append("c1sohdzzdgj", getC1sohdzzdgj()) + .append("c1dtycqdgj", getC1dtycqdgj()) + .append("c1dtyczdgj", getC1dtyczdgj()) + .append("c1dtyczzdgj", getC1dtyczzdgj()) + .append("c1dtwcqdgj", getC1dtwcqdgj()) + .append("c1dtwczdgj", getC1dtwczdgj()) + .append("c1dtwczzdgj", getC1dtwczzdgj()) + .append("c1ck1txsl", getC1ck1txsl()) + .append("c1ck2txsl", getC1ck2txsl()) + .append("c1ck3txsl", getC1ck3txsl()) + .append("c1ck4txsl", getC1ck4txsl()) + .append("c1ck5txsl", getC1ck5txsl()) + .append("c1ck6txsl", getC1ck6txsl()) + .append("c1ck7txsl", getC1ck7txsl()) + .append("c1ck8txsl", getC1ck8txsl()) + .append("c1ck9txsl", getC1ck9txsl()) + .append("c1ck10txsl", getC1ck10txsl()) + .append("c1ck11txsl", getC1ck11txsl()) + .append("c1ck12txsl", getC1ck12txsl()) + .append("c1ck13txsl", getC1ck13txsl()) + .append("c1ck14txsl", getC1ck14txsl()) + .append("c1ck15txsl", getC1ck15txsl()) + .append("c1ck16txsl", getC1ck16txsl()) + .append("c1ck17txsl", getC1ck17txsl()) + .append("c1ck18txsl", getC1ck18txsl()) + .append("c1ck19txsl", getC1ck19txsl()) + .append("c1ck20txsl", getC1ck20txsl()) + .append("c1ck21txsl", getC1ck21txsl()) + .append("c1ck22txsl", getC1ck22txsl()) + .append("c1ck23txsl", getC1ck23txsl()) + .append("c1ck24txsl", getC1ck24txsl()) + .append("c1ck25txsl", getC1ck25txsl()) + .append("c1ck26txsl", getC1ck26txsl()) + .append("c1ck27txsl", getC1ck27txsl()) + .append("c1ck28txsl", getC1ck28txsl()) + .append("c1ck29txsl", getC1ck29txsl()) + .append("c1ck30txsl", getC1ck30txsl()) + .append("c1ck31txsl", getC1ck31txsl()) + .append("c1ck32txsl", getC1ck32txsl()) + .append("c1ck33txsl", getC1ck33txsl()) + .append("c1ck34txsl", getC1ck34txsl()) + .append("c1ck35txsl", getC1ck35txsl()) + .append("c1ck36txsl", getC1ck36txsl()) + .append("c1ck37txsl", getC1ck37txsl()) + .append("c1ck38txsl", getC1ck38txsl()) + .append("c1ck39txsl", getC1ck39txsl()) + .append("c1ck40txsl", getC1ck40txsl()) + .append("c1dzwdggqdgj", getC1dzwdggqdgj()) + .append("c1dzwdggzdgj", getC1dzwdggzdgj()) + .append("c1dzwdggzzdgj", getC1dzwdggzzdgj()) + .append("c1mkdyggqdgj", getC1mkdyggqdgj()) + .append("c1mkdyggzdgj", getC1mkdyggzdgj()) + .append("c1mkdyggzzdgj", getC1mkdyggzzdgj()) + .append("c1mkdygdqdgj", getC1mkdygdqdgj()) + .append("c1mkdygdzdgj", getC1mkdygdzdgj()) + .append("c1mkdygdzzdgj", getC1mkdygdzzdgj()) + .append("c1dycjgz", getC1dycjgz()) + .append("c1wdcjgz", getC1wdcjgz()) + .append("createBy", getCreateBy()) + .append("createTime", getCreateTime()) + .append("updateBy", getUpdateBy()) + .append("updateTime", getUpdateTime()) + .append("remark", getRemark()) + .toString(); + } +} diff --git a/ems-system/src/main/java/com/xzzn/ems/domain/EmsCoolingAlarmData.java b/ems-system/src/main/java/com/xzzn/ems/domain/EmsCoolingAlarmData.java new file mode 100644 index 0000000..9ae72ef --- /dev/null +++ b/ems-system/src/main/java/com/xzzn/ems/domain/EmsCoolingAlarmData.java @@ -0,0 +1,795 @@ +package com.xzzn.ems.domain; + +import java.util.Date; +import com.fasterxml.jackson.annotation.JsonFormat; +import com.xzzn.common.core.domain.BaseEntity; +import org.apache.commons.lang3.builder.ToStringBuilder; +import org.apache.commons.lang3.builder.ToStringStyle; +import com.xzzn.common.annotation.Excel; + +/** + * ZSLQ告警故障数据对象 ems_cooling_alarm_data + * + * @author xzzn + * @date 2025-10-22 + */ +public class EmsCoolingAlarmData extends BaseEntity +{ + private static final long serialVersionUID = 1L; + + /** 记录唯一ID */ + private Long id; + + /** 数据采集时间 */ + @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss") + @Excel(name = "数据采集时间", width = 30, dateFormat = "yyyy-MM-dd HH:mm:ss") + private Date dataTimestamp; + + /** 站点ID */ + @Excel(name = "站点ID") + private String siteId; + + /** 设备唯一标识符 */ + @Excel(name = "设备唯一标识符") + private String deviceId; + + /** */ + @Excel(name = "") + private Integer lsjyx; + + /** */ + @Excel(name = "") + private Integer pqdcfyx; + + /** */ + @Excel(name = "") + private Integer djrq2yx; + + /** */ + @Excel(name = "") + private Integer djrq1yx; + + /** */ + @Excel(name = "") + private Integer bqbyx; + + /** */ + @Excel(name = "") + private Integer bsbyx; + + /** */ + @Excel(name = "") + private Integer zxhbyx; + + /** */ + @Excel(name = "") + private Integer sltzgz; + + /** */ + @Excel(name = "") + private Integer slzhyj; + + /** */ + @Excel(name = "") + private Integer slxtyctzxh; + + /** */ + @Excel(name = "") + private Integer slxtycqdxh; + + /** */ + @Excel(name = "") + private Integer slxtyckz; + + /** */ + @Excel(name = "") + private Integer slxtbdkz; + + /** */ + @Excel(name = "") + private Integer slxtzdms; + + /** */ + @Excel(name = "") + private Integer slxtsdms; + + /** */ + @Excel(name = "") + private Integer hsylcdyj; + + /** */ + @Excel(name = "") + private Integer hsyldyj; + + /** */ + @Excel(name = "") + private Integer gsylcgyj; + + /** */ + @Excel(name = "") + private Integer gsylgyj; + + /** */ + @Excel(name = "") + private Integer gsylcdyj; + + /** */ + @Excel(name = "") + private Integer gsyldyj; + + /** */ + @Excel(name = "") + private Integer hcgywg; + + /** */ + @Excel(name = "") + private Integer hcgywcdtz; + + /** */ + @Excel(name = "") + private Integer hcgywd; + + /** */ + @Excel(name = "") + private Integer hcgylg; + + /** */ + @Excel(name = "") + private Integer hcgyld; + + /** */ + @Excel(name = "") + private Integer lysylgyj; + + /** $column.columnComment */ + @Excel(name = "${comment}", readConverterExp = "$column.readConverterExp()") + private Integer lysyldyj; + + /** */ + @Excel(name = "") + private Integer hswdcgyj; + + /** */ + @Excel(name = "") + private Integer hswdgyj; + + /** */ + @Excel(name = "") + private Integer gswdcgtz; + + /** */ + @Excel(name = "") + private Integer gswdgyj; + + /** */ + @Excel(name = "") + private Integer gswddyj; + + /** */ + @Excel(name = "") + private Integer ddf2gz; + + /** */ + @Excel(name = "") + private Integer ddf1gz; + + /** */ + @Excel(name = "") + private Integer lyswdbsqyJ; + + /** */ + @Excel(name = "") + private Integer hsylbsqyJ; + + /** */ + @Excel(name = "") + private Integer gsylbsqyJ; + + /** */ + @Excel(name = "") + private Integer hswdbsqyJ; + + /** */ + @Excel(name = "") + private Integer gswdbsqgztz; + + /** */ + @Excel(name = "") + private Integer lsjgz; + + /** */ + @Excel(name = "") + private Integer djrq2gz; + + /** */ + @Excel(name = "") + private Integer djrq1gz; + + /** */ + @Excel(name = "") + private Integer bqbgz; + + /** */ + @Excel(name = "") + private Integer bsbgz; + + /** */ + @Excel(name = "") + private Integer xhbgz; + + /** */ + @Excel(name = "") + private Integer zdygz; + + public void setId(Long id) + { + this.id = id; + } + + public Long getId() + { + return id; + } + + public void setDataTimestamp(Date dataTimestamp) + { + this.dataTimestamp = dataTimestamp; + } + + public Date getDataTimestamp() + { + return dataTimestamp; + } + + public void setSiteId(String siteId) + { + this.siteId = siteId; + } + + public String getSiteId() + { + return siteId; + } + + public void setDeviceId(String deviceId) + { + this.deviceId = deviceId; + } + + public String getDeviceId() + { + return deviceId; + } + + public void setLsjyx(Integer lsjyx) + { + this.lsjyx = lsjyx; + } + + public Integer getLsjyx() + { + return lsjyx; + } + + public void setPqdcfyx(Integer pqdcfyx) + { + this.pqdcfyx = pqdcfyx; + } + + public Integer getPqdcfyx() + { + return pqdcfyx; + } + + public void setDjrq2yx(Integer djrq2yx) + { + this.djrq2yx = djrq2yx; + } + + public Integer getDjrq2yx() + { + return djrq2yx; + } + + public void setDjrq1yx(Integer djrq1yx) + { + this.djrq1yx = djrq1yx; + } + + public Integer getDjrq1yx() + { + return djrq1yx; + } + + public void setBqbyx(Integer bqbyx) + { + this.bqbyx = bqbyx; + } + + public Integer getBqbyx() + { + return bqbyx; + } + + public void setBsbyx(Integer bsbyx) + { + this.bsbyx = bsbyx; + } + + public Integer getBsbyx() + { + return bsbyx; + } + + public void setZxhbyx(Integer zxhbyx) + { + this.zxhbyx = zxhbyx; + } + + public Integer getZxhbyx() + { + return zxhbyx; + } + + public void setSltzgz(Integer sltzgz) + { + this.sltzgz = sltzgz; + } + + public Integer getSltzgz() + { + return sltzgz; + } + + public void setSlzhyj(Integer slzhyj) + { + this.slzhyj = slzhyj; + } + + public Integer getSlzhyj() + { + return slzhyj; + } + + public void setSlxtyctzxh(Integer slxtyctzxh) + { + this.slxtyctzxh = slxtyctzxh; + } + + public Integer getSlxtyctzxh() + { + return slxtyctzxh; + } + + public void setSlxtycqdxh(Integer slxtycqdxh) + { + this.slxtycqdxh = slxtycqdxh; + } + + public Integer getSlxtycqdxh() + { + return slxtycqdxh; + } + + public void setSlxtyckz(Integer slxtyckz) + { + this.slxtyckz = slxtyckz; + } + + public Integer getSlxtyckz() + { + return slxtyckz; + } + + public void setSlxtbdkz(Integer slxtbdkz) + { + this.slxtbdkz = slxtbdkz; + } + + public Integer getSlxtbdkz() + { + return slxtbdkz; + } + + public void setSlxtzdms(Integer slxtzdms) + { + this.slxtzdms = slxtzdms; + } + + public Integer getSlxtzdms() + { + return slxtzdms; + } + + public void setSlxtsdms(Integer slxtsdms) + { + this.slxtsdms = slxtsdms; + } + + public Integer getSlxtsdms() + { + return slxtsdms; + } + + public void setHsylcdyj(Integer hsylcdyj) + { + this.hsylcdyj = hsylcdyj; + } + + public Integer getHsylcdyj() + { + return hsylcdyj; + } + + public void setHsyldyj(Integer hsyldyj) + { + this.hsyldyj = hsyldyj; + } + + public Integer getHsyldyj() + { + return hsyldyj; + } + + public void setGsylcgyj(Integer gsylcgyj) + { + this.gsylcgyj = gsylcgyj; + } + + public Integer getGsylcgyj() + { + return gsylcgyj; + } + + public void setGsylgyj(Integer gsylgyj) + { + this.gsylgyj = gsylgyj; + } + + public Integer getGsylgyj() + { + return gsylgyj; + } + + public void setGsylcdyj(Integer gsylcdyj) + { + this.gsylcdyj = gsylcdyj; + } + + public Integer getGsylcdyj() + { + return gsylcdyj; + } + + public void setGsyldyj(Integer gsyldyj) + { + this.gsyldyj = gsyldyj; + } + + public Integer getGsyldyj() + { + return gsyldyj; + } + + public void setHcgywg(Integer hcgywg) + { + this.hcgywg = hcgywg; + } + + public Integer getHcgywg() + { + return hcgywg; + } + + public void setHcgywcdtz(Integer hcgywcdtz) + { + this.hcgywcdtz = hcgywcdtz; + } + + public Integer getHcgywcdtz() + { + return hcgywcdtz; + } + + public void setHcgywd(Integer hcgywd) + { + this.hcgywd = hcgywd; + } + + public Integer getHcgywd() + { + return hcgywd; + } + + public void setHcgylg(Integer hcgylg) + { + this.hcgylg = hcgylg; + } + + public Integer getHcgylg() + { + return hcgylg; + } + + public void setHcgyld(Integer hcgyld) + { + this.hcgyld = hcgyld; + } + + public Integer getHcgyld() + { + return hcgyld; + } + + public void setLysylgyj(Integer lysylgyj) + { + this.lysylgyj = lysylgyj; + } + + public Integer getLysylgyj() + { + return lysylgyj; + } + + public void setLysyldyj(Integer lysyldyj) + { + this.lysyldyj = lysyldyj; + } + + public Integer getLysyldyj() + { + return lysyldyj; + } + + public void setHswdcgyj(Integer hswdcgyj) + { + this.hswdcgyj = hswdcgyj; + } + + public Integer getHswdcgyj() + { + return hswdcgyj; + } + + public void setHswdgyj(Integer hswdgyj) + { + this.hswdgyj = hswdgyj; + } + + public Integer getHswdgyj() + { + return hswdgyj; + } + + public void setGswdcgtz(Integer gswdcgtz) + { + this.gswdcgtz = gswdcgtz; + } + + public Integer getGswdcgtz() + { + return gswdcgtz; + } + + public void setGswdgyj(Integer gswdgyj) + { + this.gswdgyj = gswdgyj; + } + + public Integer getGswdgyj() + { + return gswdgyj; + } + + public void setGswddyj(Integer gswddyj) + { + this.gswddyj = gswddyj; + } + + public Integer getGswddyj() + { + return gswddyj; + } + + public void setDdf2gz(Integer ddf2gz) + { + this.ddf2gz = ddf2gz; + } + + public Integer getDdf2gz() + { + return ddf2gz; + } + + public void setDdf1gz(Integer ddf1gz) + { + this.ddf1gz = ddf1gz; + } + + public Integer getDdf1gz() + { + return ddf1gz; + } + + public void setLyswdbsqyJ(Integer lyswdbsqyJ) + { + this.lyswdbsqyJ = lyswdbsqyJ; + } + + public Integer getLyswdbsqyJ() + { + return lyswdbsqyJ; + } + + public void setHsylbsqyJ(Integer hsylbsqyJ) + { + this.hsylbsqyJ = hsylbsqyJ; + } + + public Integer getHsylbsqyJ() + { + return hsylbsqyJ; + } + + public void setGsylbsqyJ(Integer gsylbsqyJ) + { + this.gsylbsqyJ = gsylbsqyJ; + } + + public Integer getGsylbsqyJ() + { + return gsylbsqyJ; + } + + public void setHswdbsqyJ(Integer hswdbsqyJ) + { + this.hswdbsqyJ = hswdbsqyJ; + } + + public Integer getHswdbsqyJ() + { + return hswdbsqyJ; + } + + public void setGswdbsqgztz(Integer gswdbsqgztz) + { + this.gswdbsqgztz = gswdbsqgztz; + } + + public Integer getGswdbsqgztz() + { + return gswdbsqgztz; + } + + public void setLsjgz(Integer lsjgz) + { + this.lsjgz = lsjgz; + } + + public Integer getLsjgz() + { + return lsjgz; + } + + public void setDjrq2gz(Integer djrq2gz) + { + this.djrq2gz = djrq2gz; + } + + public Integer getDjrq2gz() + { + return djrq2gz; + } + + public void setDjrq1gz(Integer djrq1gz) + { + this.djrq1gz = djrq1gz; + } + + public Integer getDjrq1gz() + { + return djrq1gz; + } + + public void setBqbgz(Integer bqbgz) + { + this.bqbgz = bqbgz; + } + + public Integer getBqbgz() + { + return bqbgz; + } + + public void setBsbgz(Integer bsbgz) + { + this.bsbgz = bsbgz; + } + + public Integer getBsbgz() + { + return bsbgz; + } + + public void setXhbgz(Integer xhbgz) + { + this.xhbgz = xhbgz; + } + + public Integer getXhbgz() + { + return xhbgz; + } + + public void setZdygz(Integer zdygz) + { + this.zdygz = zdygz; + } + + public Integer getZdygz() + { + return zdygz; + } + + @Override + public String toString() { + return new ToStringBuilder(this,ToStringStyle.MULTI_LINE_STYLE) + .append("id", getId()) + .append("dataTimestamp", getDataTimestamp()) + .append("siteId", getSiteId()) + .append("deviceId", getDeviceId()) + .append("lsjyx", getLsjyx()) + .append("pqdcfyx", getPqdcfyx()) + .append("djrq2yx", getDjrq2yx()) + .append("djrq1yx", getDjrq1yx()) + .append("bqbyx", getBqbyx()) + .append("bsbyx", getBsbyx()) + .append("zxhbyx", getZxhbyx()) + .append("sltzgz", getSltzgz()) + .append("slzhyj", getSlzhyj()) + .append("slxtyctzxh", getSlxtyctzxh()) + .append("slxtycqdxh", getSlxtycqdxh()) + .append("slxtyckz", getSlxtyckz()) + .append("slxtbdkz", getSlxtbdkz()) + .append("slxtzdms", getSlxtzdms()) + .append("slxtsdms", getSlxtsdms()) + .append("hsylcdyj", getHsylcdyj()) + .append("hsyldyj", getHsyldyj()) + .append("gsylcgyj", getGsylcgyj()) + .append("gsylgyj", getGsylgyj()) + .append("gsylcdyj", getGsylcdyj()) + .append("gsyldyj", getGsyldyj()) + .append("hcgywg", getHcgywg()) + .append("hcgywcdtz", getHcgywcdtz()) + .append("hcgywd", getHcgywd()) + .append("hcgylg", getHcgylg()) + .append("hcgyld", getHcgyld()) + .append("lysylgyj", getLysylgyj()) + .append("lysyldyj", getLysyldyj()) + .append("hswdcgyj", getHswdcgyj()) + .append("hswdgyj", getHswdgyj()) + .append("gswdcgtz", getGswdcgtz()) + .append("gswdgyj", getGswdgyj()) + .append("gswddyj", getGswddyj()) + .append("ddf2gz", getDdf2gz()) + .append("ddf1gz", getDdf1gz()) + .append("lyswdbsqyJ", getLyswdbsqyJ()) + .append("hsylbsqyJ", getHsylbsqyJ()) + .append("gsylbsqyJ", getGsylbsqyJ()) + .append("hswdbsqyJ", getHswdbsqyJ()) + .append("gswdbsqgztz", getGswdbsqgztz()) + .append("lsjgz", getLsjgz()) + .append("djrq2gz", getDjrq2gz()) + .append("djrq1gz", getDjrq1gz()) + .append("bqbgz", getBqbgz()) + .append("bsbgz", getBsbgz()) + .append("xhbgz", getXhbgz()) + .append("zdygz", getZdygz()) + .append("createBy", getCreateBy()) + .append("createTime", getCreateTime()) + .append("updateBy", getUpdateBy()) + .append("updateTime", getUpdateTime()) + .append("remark", getRemark()) + .toString(); + } +} diff --git a/ems-system/src/main/java/com/xzzn/ems/domain/EmsPcsAlarmData.java b/ems-system/src/main/java/com/xzzn/ems/domain/EmsPcsAlarmData.java new file mode 100644 index 0000000..bc10122 --- /dev/null +++ b/ems-system/src/main/java/com/xzzn/ems/domain/EmsPcsAlarmData.java @@ -0,0 +1,1545 @@ +package com.xzzn.ems.domain; + +import java.util.Date; +import com.fasterxml.jackson.annotation.JsonFormat; +import com.xzzn.common.core.domain.BaseEntity; +import org.apache.commons.lang3.builder.ToStringBuilder; +import org.apache.commons.lang3.builder.ToStringStyle; +import com.xzzn.common.annotation.Excel; + +/** + * pcs设备告警故障数据对象 ems_pcs_alarm_data + * + * @author xzzn + * @date 2025-10-22 + */ +public class EmsPcsAlarmData extends BaseEntity +{ + private static final long serialVersionUID = 1L; + + /** 记录唯一ID */ + private Long id; + + /** 数据采集时间 */ + @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss") + @Excel(name = "数据采集时间", width = 30, dateFormat = "yyyy-MM-dd HH:mm:ss") + private Date dataTimestamp; + + /** 站点ID */ + @Excel(name = "站点ID") + private String siteId; + + /** 设备唯一标识符 */ + @Excel(name = "设备唯一标识符") + private String deviceId; + + /** 故障标志（0-正常，1-故障） */ + @Excel(name = "故障标志", readConverterExp = "0=-正常，1-故障") + private Integer gzbz; + + /** 绝缘阻抗异常（0-正常，1-异常） */ + @Excel(name = "绝缘阻抗异常", readConverterExp = "0=-正常，1-异常") + private Integer jyzkyc; + + /** 交流漏电流异常（0-正常，1-异常） */ + @Excel(name = "交流漏电流异常", readConverterExp = "0=-正常，1-异常") + private Integer jlllyc; + + /** 直流过压（0-正常，1-异常） */ + @Excel(name = "直流过压", readConverterExp = "0=-正常，1-异常") + private Integer zlgv; + + /** 电网过压异常（0-正常，1-异常） */ + @Excel(name = "电网过压异常", readConverterExp = "0=-正常，1-异常") + private Integer dwgyyc; + + /** 电网欠压异常（0-正常，1-异常） */ + @Excel(name = "电网欠压异常", readConverterExp = "0=-正常，1-异常") + private Integer dwqyyc; + + /** 电网过频异常（0-正常，1-异常） */ + @Excel(name = "电网过频异常", readConverterExp = "0=-正常，1-异常") + private Integer dwgpyc; + + /** 电网欠频异常（0-正常，1-异常） */ + @Excel(name = "电网欠频异常", readConverterExp = "0=-正常，1-异常") + private Integer dwqpyc; + + /** 功率模块过温（0-正常，1-异常） */ + @Excel(name = "功率模块过温", readConverterExp = "0=-正常，1-异常") + private Integer glmkgw; + + /** 电网相序异常（0-正常，1-异常） */ + @Excel(name = "电网相序异常", readConverterExp = "0=-正常，1-异常") + private Integer dwxxyc; + + /** 逆变软件过流（0-正常，1-异常） */ + @Excel(name = "逆变软件过流", readConverterExp = "0=-正常，1-异常") + private Integer nbrjgl; + + /** 直流软启动异常（0-正常，1-异常） */ + @Excel(name = "直流软启动异常", readConverterExp = "0=-正常，1-异常") + private Integer zlrqdyc; + + /** 直流开关异常（0-正常，1-异常） */ + @Excel(name = "直流开关异常", readConverterExp = "0=-正常，1-异常") + private Integer zlkgwc; + + /** 交流风机异常（0-正常，1-异常） */ + @Excel(name = "交流风机异常", readConverterExp = "0=-正常，1-异常") + private Integer jlfjyc; + + /** 交流开关异常（0-正常，1-异常） */ + @Excel(name = "交流开关异常", readConverterExp = "0=-正常，1-异常") + private Integer jlkgwc; + + /** 温度开关异常（0-正常，1-异常） */ + @Excel(name = "温度开关异常", readConverterExp = "0=-正常，1-异常") + private Integer wdkgwc; + + /** 内部异常（0-正常，1-异常） */ + @Excel(name = "内部异常", readConverterExp = "0=-正常，1-异常") + private Integer nbyc; + + /** 机内过温（0-正常，1-异常） */ + @Excel(name = "机内过温", readConverterExp = "0=-正常，1-异常") + private Integer jngw; + + /** 交流软启动异常（0-正常，1-异常） */ + @Excel(name = "交流软启动异常", readConverterExp = "0=-正常，1-异常") + private Integer jlrqdyc; + + /** 热交换机异常（0-正常，1-异常） */ + @Excel(name = "热交换机异常", readConverterExp = "0=-正常，1-异常") + private Integer rjhjyc; + + /** 交流防雷器异常（0-正常，1-异常） */ + @Excel(name = "交流防雷器异常", readConverterExp = "0=-正常，1-异常") + private Integer jlflqyc; + + /** 内部急停（0-正常，1-触发） */ + @Excel(name = "内部急停", readConverterExp = "0=-正常，1-触发") + private Integer nbjt; + + /** 外部急停（0-正常，1-触发） */ + @Excel(name = "外部急停", readConverterExp = "0=-正常，1-触发") + private Integer wbjt; + + /** 母线电压不符合开机条件（0-符合，1-不符合） */ + @Excel(name = "母线电压不符合开机条件", readConverterExp = "0=-符合，1-不符合") + private Integer mxdbyfhkjtj; + + /** 母线电流过流（0-正常，1-过流） */ + @Excel(name = "母线电流过流", readConverterExp = "0=-正常，1-过流") + private Integer mxdlgl; + + /** 零偏校准异常（0-正常，1-异常） */ + @Excel(name = "零偏校准异常", readConverterExp = "0=-正常，1-异常") + private Integer lpjzyc; + + /** 门禁告警（0-正常，1-告警） */ + @Excel(name = "门禁告警", readConverterExp = "0=-正常，1-告警") + private Integer mjgj; + + /** 锁相异常（0-正常，1-异常） */ + @Excel(name = "锁相异常", readConverterExp = "0=-正常，1-异常") + private Integer sxyc; + + /** 直流防雷器异常（0-正常，1-异常） */ + @Excel(name = "直流防雷器异常", readConverterExp = "0=-正常，1-异常") + private Integer zlflqyc; + + /** 智能电表通信异常（0-正常，1-异常） */ + @Excel(name = "智能电表通信异常", readConverterExp = "0=-正常，1-异常") + private Integer zndbtxyc; + + /** 逆变硬件过流（0-正常，1-过流） */ + @Excel(name = "逆变硬件过流", readConverterExp = "0=-正常，1-过流") + private Integer nbyjgl; + + /** 驱动异常（0-正常，1-异常） */ + @Excel(name = "驱动异常", readConverterExp = "0=-正常，1-异常") + private Integer qdyc; + + /** ID冲突（0-正常，1-冲突） */ + @Excel(name = "ID冲突", readConverterExp = "0=-正常，1-冲突") + private Integer idct; + + /** 信息共享CAN通信异常（0-正常，1-异常） */ + @Excel(name = "信息共享CAN通信异常", readConverterExp = "0=-正常，1-异常") + private Integer xxgxctxvc; + + /** 并机通信线异常（0-正常，1-异常） */ + @Excel(name = "并机通信线异常", readConverterExp = "0=-正常，1-异常") + private Integer bjtxxyc; + + /** 同步CAN通信异常（0-正常，1-异常） */ + @Excel(name = "同步CAN通信异常", readConverterExp = "0=-正常，1-异常") + private Integer tbctxvc; + + /** 直流电弧异常（0-正常，1-异常） */ + @Excel(name = "直流电弧异常", readConverterExp = "0=-正常，1-异常") + private Integer zldhyc; + + /** 零序过流（0-正常，1-过流） */ + @Excel(name = "零序过流", readConverterExp = "0=-正常，1-过流") + private Integer lxgl; + + /** 直流主接触器异常（0-正常，1-异常） */ + @Excel(name = "直流主接触器异常", readConverterExp = "0=-正常，1-异常") + private Integer zlzjcqyc; + + /** 烟雾告警（0-正常，1-告警） */ + @Excel(name = "烟雾告警", readConverterExp = "0=-正常，1-告警") + private Integer ywgj; + + /** 并机通信异常（0-正常，1-异常） */ + @Excel(name = "并机通信异常", readConverterExp = "0=-正常，1-异常") + private Integer bjtxyc; + + /** HMI CAN通信异常（0-正常，1-异常） */ + @Excel(name = "HMI CAN通信异常", readConverterExp = "0=-正常，1-异常") + private Integer hmictxyc; + + /** 机型设置错误（0-正确，1-错误） */ + @Excel(name = "机型设置错误", readConverterExp = "0=-正确，1-错误") + private Integer jxszcw; + + /** HMI 485通信异常（0-正常，1-异常） */ + @Excel(name = "HMI 485通信异常", readConverterExp = "0=-正常，1-异常") + private Integer hmi485txyc; + + /** 远程通信异常（0-正常，1-异常） */ + @Excel(name = "远程通信异常", readConverterExp = "0=-正常，1-异常") + private Integer yctxyc; + + /** 故障总（0-无故障，1-有故障） */ + @Excel(name = "故障总", readConverterExp = "0=-无故障，1-有故障") + private Integer gzz; + + /** 告警总（0-无告警，1-有告警） */ + @Excel(name = "告警总", readConverterExp = "0=-无告警，1-有告警") + private Integer gjz; + + /** 直流并联模式设置错误（0-正确，1-错误） */ + @Excel(name = "直流并联模式设置错误", readConverterExp = "0=-正确，1-错误") + private Integer zlblmsszcw; + + /** 系统参数不匹配（0-匹配，1-不匹配） */ + @Excel(name = "系统参数不匹配", readConverterExp = "0=-匹配，1-不匹配") + private Integer xtcsbpp; + + /** 电网电压不平衡告警（0-正常，1-告警） */ + @Excel(name = "电网电压不平衡告警", readConverterExp = "0=-正常，1-告警") + private Integer dwdybphgj; + + /** 低电压穿越运行（0-未运行，1-运行中） */ + @Excel(name = "低电压穿越运行", readConverterExp = "0=-未运行，1-运行中") + private Integer ddycyyx; + + /** 高电压穿越运行（0-未运行，1-运行中） */ + @Excel(name = "高电压穿越运行", readConverterExp = "0=-未运行，1-运行中") + private Integer gdycyyx; + + /** 直流风机异常（0-正常，1-异常） */ + @Excel(name = "直流风机异常", readConverterExp = "0=-正常，1-异常") + private Integer zlfjyc; + + /** 散热器温度开关异常（0-正常，1-异常） */ + @Excel(name = "散热器温度开关异常", readConverterExp = "0=-正常，1-异常") + private Integer srqwdkgwc; + + /** 外部温度开关异常（0-正常，1-异常） */ + @Excel(name = "外部温度开关异常", readConverterExp = "0=-正常，1-异常") + private Integer wbwdkgwc; + + /** 辅源变压器温度开关异常（0-正常，1-异常） */ + @Excel(name = "辅源变压器温度开关异常", readConverterExp = "0=-正常，1-异常") + private Integer fybyqwdkgwc; + + /** 电感温度开关异常（0-正常，1-异常） */ + @Excel(name = "电感温度开关异常", readConverterExp = "0=-正常，1-异常") + private Integer dgwdkgwc; + + /** 正极接地异常（0-正常，1-异常） */ + @Excel(name = "正极接地异常", readConverterExp = "0=-正常，1-异常") + private Integer zjjdvc; + + /** 负极接地异常（0-正常，1-异常） */ + @Excel(name = "负极接地异常", readConverterExp = "0=-正常，1-异常") + private Integer fjjdvc; + + /** 交流接地异常（0-正常，1-异常） */ + @Excel(name = "交流接地异常", readConverterExp = "0=-正常，1-异常") + private Integer jljdvc; + + /** 并网接地异常（0-正常，1-异常） */ + @Excel(name = "并网接地异常", readConverterExp = "0=-正常，1-异常") + private Integer bwjdvc; + + /** BMS急停（0-正常，1-触发） */ + @Excel(name = "BMS急停", readConverterExp = "0=-正常，1-触发") + private Integer bmsjt; + + /** 空空换热器异常（0-正常，1-异常） */ + @Excel(name = "空空换热器异常", readConverterExp = "0=-正常，1-异常") + private Integer kkhrqyc; + + /** 电网过欠频待机告警（0-正常，1-告警） */ + @Excel(name = "电网过欠频待机告警", readConverterExp = "0=-正常，1-告警") + private Integer dwgqpdjgj; + + /** 功率模块过温告警（0-正常，1-告警） */ + @Excel(name = "功率模块过温告警", readConverterExp = "0=-正常，1-告警") + private Integer glmkgwgJ; + + /** 电池过压（0-正常，1-过压） */ + @Excel(name = "电池过压", readConverterExp = "0=-正常，1-过压") + private Integer dcgy; + + /** 电池轻载欠压（0-正常，1-欠压） */ + @Excel(name = "电池轻载欠压", readConverterExp = "0=-正常，1-欠压") + private Integer dcqzqy; + + /** 直流过流（0-正常，1-过流） */ + @Excel(name = "直流过流", readConverterExp = "0=-正常，1-过流") + private Integer zlgl; + + /** 输出电压异常（0-正常，1-异常） */ + @Excel(name = "输出电压异常", readConverterExp = "0=-正常，1-异常") + private Integer scdyyc; + + /** 输出电压不符合离网条件（0-符合，1-不符合） */ + @Excel(name = "输出电压不符合离网条件", readConverterExp = "0=-符合，1-不符合") + private Integer scdybfhlwtj; + + /** 过载保护（0-未触发，1-已触发） */ + @Excel(name = "过载保护", readConverterExp = "0=-未触发，1-已触发") + private Integer gzbh; + + /** 短路保护（0-未触发，1-已触发） */ + @Excel(name = "短路保护", readConverterExp = "0=-未触发，1-已触发") + private Integer dlbh; + + /** 内部风机异常（0-正常，1-异常） */ + @Excel(name = "内部风机异常", readConverterExp = "0=-正常，1-异常") + private Integer nbfjyc; + + /** 直流保险丝异常（0-正常，1-异常） */ + @Excel(name = "直流保险丝异常", readConverterExp = "0=-正常，1-异常") + private Integer zlbxsyc; + + /** 电池重载欠压（0-正常，1-欠压） */ + @Excel(name = "电池重载欠压", readConverterExp = "0=-正常，1-欠压") + private Integer dczzqy; + + /** 电池低压告警（0-正常，1-告警） */ + @Excel(name = "电池低压告警", readConverterExp = "0=-正常，1-告警") + private Integer dcdygj; + + /** 外部风机异常（0-正常，1-异常） */ + @Excel(name = "外部风机异常", readConverterExp = "0=-正常，1-异常") + private Integer wbfjyc; + + /** 电池反接（0-正常，1-反接） */ + @Excel(name = "电池反接", readConverterExp = "0=-正常，1-反接") + private Integer dcfj; + + /** 电池电压不符合充电条件（0-符合，1-不符合） */ + @Excel(name = "电池电压不符合充电条件", readConverterExp = "0=-符合，1-不符合") + private Integer dcdybfhcdtj; + + /** 过载告警（0-正常，1-告警） */ + @Excel(name = "过载告警", readConverterExp = "0=-正常，1-告警") + private Integer gzgJ; + + /** 直流电弧模块通信异常（0-正常，1-异常） */ + @Excel(name = "直流电弧模块通信异常", readConverterExp = "0=-正常，1-异常") + private Integer zldhmktxyc; + + /** BMS系统故障（0-正常，1-故障） */ + @Excel(name = "BMS系统故障", readConverterExp = "0=-正常，1-故障") + private Integer bmsxtgz; + + /** BMS通信异常（0-正常，1-异常） */ + @Excel(name = "BMS通信异常", readConverterExp = "0=-正常，1-异常") + private Integer bmstxyc; + + /** BMS干接点异常（0-正常，1-异常） */ + @Excel(name = "BMS干接点异常", readConverterExp = "0=-正常，1-异常") + private Integer bmsgjdyc; + + /** BMS禁充（0-允许，1-禁止） */ + @Excel(name = "BMS禁充", readConverterExp = "0=-允许，1-禁止") + private Integer bmsjc; + + /** BMS禁放（0-允许，1-禁止） */ + @Excel(name = "BMS禁放", readConverterExp = "0=-允许，1-禁止") + private Integer bmsjf; + + /** BMS待机（0-运行，1-待机） */ + @Excel(name = "BMS待机", readConverterExp = "0=-运行，1-待机") + private Integer bmsdj; + + /** BMS告警（0-正常，1-告警） */ + @Excel(name = "BMS告警", readConverterExp = "0=-正常，1-告警") + private Integer bmsgj; + + /** 电感风机异常（0-正常，1-异常） */ + @Excel(name = "电感风机异常", readConverterExp = "0=-正常，1-异常") + private Integer dgfjyc; + + /** 散热器过温告警（0-正常，1-告警） */ + @Excel(name = "散热器过温告警", readConverterExp = "0=-正常，1-告警") + private Integer srqgwgj; + + /** 故障总2（0-无故障，1-有故障） */ + @Excel(name = "故障总2", readConverterExp = "0=-无故障，1-有故障") + private Integer gzz2; + + /** 告警总2（0-无告警，1-有告警） */ + @Excel(name = "告警总2", readConverterExp = "0=-无告警，1-有告警") + private Integer gjz2; + + /** 交流风机寿命异常（0-正常，1-异常） */ + @Excel(name = "交流风机寿命异常", readConverterExp = "0=-正常，1-异常") + private Integer jlfjsmyc; + + /** 直流风机寿命异常（0-正常，1-异常） */ + @Excel(name = "直流风机寿命异常", readConverterExp = "0=-正常，1-异常") + private Integer zlfjsmyc; + + /** 交流开关寿命异常（0-正常，1-异常） */ + @Excel(name = "交流开关寿命异常", readConverterExp = "0=-正常，1-异常") + private Integer jlkgSmyc; + + /** 直流开关寿命异常（0-正常，1-异常） */ + @Excel(name = "直流开关寿命异常", readConverterExp = "0=-正常，1-异常") + private Integer zlkgSmyc; + + /** 液冷机组异常（0-正常，1-异常） */ + @Excel(name = "液冷机组异常", readConverterExp = "0=-正常，1-异常") + private Integer yljzyc; + + public void setId(Long id) + { + this.id = id; + } + + public Long getId() + { + return id; + } + + public void setDataTimestamp(Date dataTimestamp) + { + this.dataTimestamp = dataTimestamp; + } + + public Date getDataTimestamp() + { + return dataTimestamp; + } + + public void setSiteId(String siteId) + { + this.siteId = siteId; + } + + public String getSiteId() + { + return siteId; + } + + public void setDeviceId(String deviceId) + { + this.deviceId = deviceId; + } + + public String getDeviceId() + { + return deviceId; + } + + public void setGzbz(Integer gzbz) + { + this.gzbz = gzbz; + } + + public Integer getGzbz() + { + return gzbz; + } + + public void setJyzkyc(Integer jyzkyc) + { + this.jyzkyc = jyzkyc; + } + + public Integer getJyzkyc() + { + return jyzkyc; + } + + public void setJlllyc(Integer jlllyc) + { + this.jlllyc = jlllyc; + } + + public Integer getJlllyc() + { + return jlllyc; + } + + public void setZlgv(Integer zlgv) + { + this.zlgv = zlgv; + } + + public Integer getZlgv() + { + return zlgv; + } + + public void setDwgyyc(Integer dwgyyc) + { + this.dwgyyc = dwgyyc; + } + + public Integer getDwgyyc() + { + return dwgyyc; + } + + public void setDwqyyc(Integer dwqyyc) + { + this.dwqyyc = dwqyyc; + } + + public Integer getDwqyyc() + { + return dwqyyc; + } + + public void setDwgpyc(Integer dwgpyc) + { + this.dwgpyc = dwgpyc; + } + + public Integer getDwgpyc() + { + return dwgpyc; + } + + public void setDwqpyc(Integer dwqpyc) + { + this.dwqpyc = dwqpyc; + } + + public Integer getDwqpyc() + { + return dwqpyc; + } + + public void setGlmkgw(Integer glmkgw) + { + this.glmkgw = glmkgw; + } + + public Integer getGlmkgw() + { + return glmkgw; + } + + public void setDwxxyc(Integer dwxxyc) + { + this.dwxxyc = dwxxyc; + } + + public Integer getDwxxyc() + { + return dwxxyc; + } + + public void setNbrjgl(Integer nbrjgl) + { + this.nbrjgl = nbrjgl; + } + + public Integer getNbrjgl() + { + return nbrjgl; + } + + public void setZlrqdyc(Integer zlrqdyc) + { + this.zlrqdyc = zlrqdyc; + } + + public Integer getZlrqdyc() + { + return zlrqdyc; + } + + public void setZlkgwc(Integer zlkgwc) + { + this.zlkgwc = zlkgwc; + } + + public Integer getZlkgwc() + { + return zlkgwc; + } + + public void setJlfjyc(Integer jlfjyc) + { + this.jlfjyc = jlfjyc; + } + + public Integer getJlfjyc() + { + return jlfjyc; + } + + public void setJlkgwc(Integer jlkgwc) + { + this.jlkgwc = jlkgwc; + } + + public Integer getJlkgwc() + { + return jlkgwc; + } + + public void setWdkgwc(Integer wdkgwc) + { + this.wdkgwc = wdkgwc; + } + + public Integer getWdkgwc() + { + return wdkgwc; + } + + public void setNbyc(Integer nbyc) + { + this.nbyc = nbyc; + } + + public Integer getNbyc() + { + return nbyc; + } + + public void setJngw(Integer jngw) + { + this.jngw = jngw; + } + + public Integer getJngw() + { + return jngw; + } + + public void setJlrqdyc(Integer jlrqdyc) + { + this.jlrqdyc = jlrqdyc; + } + + public Integer getJlrqdyc() + { + return jlrqdyc; + } + + public void setRjhjyc(Integer rjhjyc) + { + this.rjhjyc = rjhjyc; + } + + public Integer getRjhjyc() + { + return rjhjyc; + } + + public void setJlflqyc(Integer jlflqyc) + { + this.jlflqyc = jlflqyc; + } + + public Integer getJlflqyc() + { + return jlflqyc; + } + + public void setNbjt(Integer nbjt) + { + this.nbjt = nbjt; + } + + public Integer getNbjt() + { + return nbjt; + } + + public void setWbjt(Integer wbjt) + { + this.wbjt = wbjt; + } + + public Integer getWbjt() + { + return wbjt; + } + + public void setMxdbyfhkjtj(Integer mxdbyfhkjtj) + { + this.mxdbyfhkjtj = mxdbyfhkjtj; + } + + public Integer getMxdbyfhkjtj() + { + return mxdbyfhkjtj; + } + + public void setMxdlgl(Integer mxdlgl) + { + this.mxdlgl = mxdlgl; + } + + public Integer getMxdlgl() + { + return mxdlgl; + } + + public void setLpjzyc(Integer lpjzyc) + { + this.lpjzyc = lpjzyc; + } + + public Integer getLpjzyc() + { + return lpjzyc; + } + + public void setMjgj(Integer mjgj) + { + this.mjgj = mjgj; + } + + public Integer getMjgj() + { + return mjgj; + } + + public void setSxyc(Integer sxyc) + { + this.sxyc = sxyc; + } + + public Integer getSxyc() + { + return sxyc; + } + + public void setZlflqyc(Integer zlflqyc) + { + this.zlflqyc = zlflqyc; + } + + public Integer getZlflqyc() + { + return zlflqyc; + } + + public void setZndbtxyc(Integer zndbtxyc) + { + this.zndbtxyc = zndbtxyc; + } + + public Integer getZndbtxyc() + { + return zndbtxyc; + } + + public void setNbyjgl(Integer nbyjgl) + { + this.nbyjgl = nbyjgl; + } + + public Integer getNbyjgl() + { + return nbyjgl; + } + + public void setQdyc(Integer qdyc) + { + this.qdyc = qdyc; + } + + public Integer getQdyc() + { + return qdyc; + } + + public void setIdct(Integer idct) + { + this.idct = idct; + } + + public Integer getIdct() + { + return idct; + } + + public void setXxgxctxvc(Integer xxgxctxvc) + { + this.xxgxctxvc = xxgxctxvc; + } + + public Integer getXxgxctxvc() + { + return xxgxctxvc; + } + + public void setBjtxxyc(Integer bjtxxyc) + { + this.bjtxxyc = bjtxxyc; + } + + public Integer getBjtxxyc() + { + return bjtxxyc; + } + + public void setTbctxvc(Integer tbctxvc) + { + this.tbctxvc = tbctxvc; + } + + public Integer getTbctxvc() + { + return tbctxvc; + } + + public void setZldhyc(Integer zldhyc) + { + this.zldhyc = zldhyc; + } + + public Integer getZldhyc() + { + return zldhyc; + } + + public void setLxgl(Integer lxgl) + { + this.lxgl = lxgl; + } + + public Integer getLxgl() + { + return lxgl; + } + + public void setZlzjcqyc(Integer zlzjcqyc) + { + this.zlzjcqyc = zlzjcqyc; + } + + public Integer getZlzjcqyc() + { + return zlzjcqyc; + } + + public void setYwgj(Integer ywgj) + { + this.ywgj = ywgj; + } + + public Integer getYwgj() + { + return ywgj; + } + + public void setBjtxyc(Integer bjtxyc) + { + this.bjtxyc = bjtxyc; + } + + public Integer getBjtxyc() + { + return bjtxyc; + } + + public void setHmictxyc(Integer hmictxyc) + { + this.hmictxyc = hmictxyc; + } + + public Integer getHmictxyc() + { + return hmictxyc; + } + + public void setJxszcw(Integer jxszcw) + { + this.jxszcw = jxszcw; + } + + public Integer getJxszcw() + { + return jxszcw; + } + + public void setHmi485txyc(Integer hmi485txyc) + { + this.hmi485txyc = hmi485txyc; + } + + public Integer getHmi485txyc() + { + return hmi485txyc; + } + + public void setYctxyc(Integer yctxyc) + { + this.yctxyc = yctxyc; + } + + public Integer getYctxyc() + { + return yctxyc; + } + + public void setGzz(Integer gzz) + { + this.gzz = gzz; + } + + public Integer getGzz() + { + return gzz; + } + + public void setGjz(Integer gjz) + { + this.gjz = gjz; + } + + public Integer getGjz() + { + return gjz; + } + + public void setZlblmsszcw(Integer zlblmsszcw) + { + this.zlblmsszcw = zlblmsszcw; + } + + public Integer getZlblmsszcw() + { + return zlblmsszcw; + } + + public void setXtcsbpp(Integer xtcsbpp) + { + this.xtcsbpp = xtcsbpp; + } + + public Integer getXtcsbpp() + { + return xtcsbpp; + } + + public void setDwdybphgj(Integer dwdybphgj) + { + this.dwdybphgj = dwdybphgj; + } + + public Integer getDwdybphgj() + { + return dwdybphgj; + } + + public void setDdycyyx(Integer ddycyyx) + { + this.ddycyyx = ddycyyx; + } + + public Integer getDdycyyx() + { + return ddycyyx; + } + + public void setGdycyyx(Integer gdycyyx) + { + this.gdycyyx = gdycyyx; + } + + public Integer getGdycyyx() + { + return gdycyyx; + } + + public void setZlfjyc(Integer zlfjyc) + { + this.zlfjyc = zlfjyc; + } + + public Integer getZlfjyc() + { + return zlfjyc; + } + + public void setSrqwdkgwc(Integer srqwdkgwc) + { + this.srqwdkgwc = srqwdkgwc; + } + + public Integer getSrqwdkgwc() + { + return srqwdkgwc; + } + + public void setWbwdkgwc(Integer wbwdkgwc) + { + this.wbwdkgwc = wbwdkgwc; + } + + public Integer getWbwdkgwc() + { + return wbwdkgwc; + } + + public void setFybyqwdkgwc(Integer fybyqwdkgwc) + { + this.fybyqwdkgwc = fybyqwdkgwc; + } + + public Integer getFybyqwdkgwc() + { + return fybyqwdkgwc; + } + + public void setDgwdkgwc(Integer dgwdkgwc) + { + this.dgwdkgwc = dgwdkgwc; + } + + public Integer getDgwdkgwc() + { + return dgwdkgwc; + } + + public void setZjjdvc(Integer zjjdvc) + { + this.zjjdvc = zjjdvc; + } + + public Integer getZjjdvc() + { + return zjjdvc; + } + + public void setFjjdvc(Integer fjjdvc) + { + this.fjjdvc = fjjdvc; + } + + public Integer getFjjdvc() + { + return fjjdvc; + } + + public void setJljdvc(Integer jljdvc) + { + this.jljdvc = jljdvc; + } + + public Integer getJljdvc() + { + return jljdvc; + } + + public void setBwjdvc(Integer bwjdvc) + { + this.bwjdvc = bwjdvc; + } + + public Integer getBwjdvc() + { + return bwjdvc; + } + + public void setBmsjt(Integer bmsjt) + { + this.bmsjt = bmsjt; + } + + public Integer getBmsjt() + { + return bmsjt; + } + + public void setKkhrqyc(Integer kkhrqyc) + { + this.kkhrqyc = kkhrqyc; + } + + public Integer getKkhrqyc() + { + return kkhrqyc; + } + + public void setDwgqpdjgj(Integer dwgqpdjgj) + { + this.dwgqpdjgj = dwgqpdjgj; + } + + public Integer getDwgqpdjgj() + { + return dwgqpdjgj; + } + + public void setGlmkgwgJ(Integer glmkgwgJ) + { + this.glmkgwgJ = glmkgwgJ; + } + + public Integer getGlmkgwgJ() + { + return glmkgwgJ; + } + + public void setDcgy(Integer dcgy) + { + this.dcgy = dcgy; + } + + public Integer getDcgy() + { + return dcgy; + } + + public void setDcqzqy(Integer dcqzqy) + { + this.dcqzqy = dcqzqy; + } + + public Integer getDcqzqy() + { + return dcqzqy; + } + + public void setZlgl(Integer zlgl) + { + this.zlgl = zlgl; + } + + public Integer getZlgl() + { + return zlgl; + } + + public void setScdyyc(Integer scdyyc) + { + this.scdyyc = scdyyc; + } + + public Integer getScdyyc() + { + return scdyyc; + } + + public void setScdybfhlwtj(Integer scdybfhlwtj) + { + this.scdybfhlwtj = scdybfhlwtj; + } + + public Integer getScdybfhlwtj() + { + return scdybfhlwtj; + } + + public void setGzbh(Integer gzbh) + { + this.gzbh = gzbh; + } + + public Integer getGzbh() + { + return gzbh; + } + + public void setDlbh(Integer dlbh) + { + this.dlbh = dlbh; + } + + public Integer getDlbh() + { + return dlbh; + } + + public void setNbfjyc(Integer nbfjyc) + { + this.nbfjyc = nbfjyc; + } + + public Integer getNbfjyc() + { + return nbfjyc; + } + + public void setZlbxsyc(Integer zlbxsyc) + { + this.zlbxsyc = zlbxsyc; + } + + public Integer getZlbxsyc() + { + return zlbxsyc; + } + + public void setDczzqy(Integer dczzqy) + { + this.dczzqy = dczzqy; + } + + public Integer getDczzqy() + { + return dczzqy; + } + + public void setDcdygj(Integer dcdygj) + { + this.dcdygj = dcdygj; + } + + public Integer getDcdygj() + { + return dcdygj; + } + + public void setWbfjyc(Integer wbfjyc) + { + this.wbfjyc = wbfjyc; + } + + public Integer getWbfjyc() + { + return wbfjyc; + } + + public void setDcfj(Integer dcfj) + { + this.dcfj = dcfj; + } + + public Integer getDcfj() + { + return dcfj; + } + + public void setDcdybfhcdtj(Integer dcdybfhcdtj) + { + this.dcdybfhcdtj = dcdybfhcdtj; + } + + public Integer getDcdybfhcdtj() + { + return dcdybfhcdtj; + } + + public void setGzgJ(Integer gzgJ) + { + this.gzgJ = gzgJ; + } + + public Integer getGzgJ() + { + return gzgJ; + } + + public void setZldhmktxyc(Integer zldhmktxyc) + { + this.zldhmktxyc = zldhmktxyc; + } + + public Integer getZldhmktxyc() + { + return zldhmktxyc; + } + + public void setBmsxtgz(Integer bmsxtgz) + { + this.bmsxtgz = bmsxtgz; + } + + public Integer getBmsxtgz() + { + return bmsxtgz; + } + + public void setBmstxyc(Integer bmstxyc) + { + this.bmstxyc = bmstxyc; + } + + public Integer getBmstxyc() + { + return bmstxyc; + } + + public void setBmsgjdyc(Integer bmsgjdyc) + { + this.bmsgjdyc = bmsgjdyc; + } + + public Integer getBmsgjdyc() + { + return bmsgjdyc; + } + + public void setBmsjc(Integer bmsjc) + { + this.bmsjc = bmsjc; + } + + public Integer getBmsjc() + { + return bmsjc; + } + + public void setBmsjf(Integer bmsjf) + { + this.bmsjf = bmsjf; + } + + public Integer getBmsjf() + { + return bmsjf; + } + + public void setBmsdj(Integer bmsdj) + { + this.bmsdj = bmsdj; + } + + public Integer getBmsdj() + { + return bmsdj; + } + + public void setBmsgj(Integer bmsgj) + { + this.bmsgj = bmsgj; + } + + public Integer getBmsgj() + { + return bmsgj; + } + + public void setDgfjyc(Integer dgfjyc) + { + this.dgfjyc = dgfjyc; + } + + public Integer getDgfjyc() + { + return dgfjyc; + } + + public void setSrqgwgj(Integer srqgwgj) + { + this.srqgwgj = srqgwgj; + } + + public Integer getSrqgwgj() + { + return srqgwgj; + } + + public void setGzz2(Integer gzz2) + { + this.gzz2 = gzz2; + } + + public Integer getGzz2() + { + return gzz2; + } + + public void setGjz2(Integer gjz2) + { + this.gjz2 = gjz2; + } + + public Integer getGjz2() + { + return gjz2; + } + + public void setJlfjsmyc(Integer jlfjsmyc) + { + this.jlfjsmyc = jlfjsmyc; + } + + public Integer getJlfjsmyc() + { + return jlfjsmyc; + } + + public void setZlfjsmyc(Integer zlfjsmyc) + { + this.zlfjsmyc = zlfjsmyc; + } + + public Integer getZlfjsmyc() + { + return zlfjsmyc; + } + + public void setJlkgSmyc(Integer jlkgSmyc) + { + this.jlkgSmyc = jlkgSmyc; + } + + public Integer getJlkgSmyc() + { + return jlkgSmyc; + } + + public void setZlkgSmyc(Integer zlkgSmyc) + { + this.zlkgSmyc = zlkgSmyc; + } + + public Integer getZlkgSmyc() + { + return zlkgSmyc; + } + + public void setYljzyc(Integer yljzyc) + { + this.yljzyc = yljzyc; + } + + public Integer getYljzyc() + { + return yljzyc; + } + + @Override + public String toString() { + return new ToStringBuilder(this,ToStringStyle.MULTI_LINE_STYLE) + .append("id", getId()) + .append("dataTimestamp", getDataTimestamp()) + .append("siteId", getSiteId()) + .append("deviceId", getDeviceId()) + .append("gzbz", getGzbz()) + .append("jyzkyc", getJyzkyc()) + .append("jlllyc", getJlllyc()) + .append("zlgv", getZlgv()) + .append("dwgyyc", getDwgyyc()) + .append("dwqyyc", getDwqyyc()) + .append("dwgpyc", getDwgpyc()) + .append("dwqpyc", getDwqpyc()) + .append("glmkgw", getGlmkgw()) + .append("dwxxyc", getDwxxyc()) + .append("nbrjgl", getNbrjgl()) + .append("zlrqdyc", getZlrqdyc()) + .append("zlkgwc", getZlkgwc()) + .append("jlfjyc", getJlfjyc()) + .append("jlkgwc", getJlkgwc()) + .append("wdkgwc", getWdkgwc()) + .append("nbyc", getNbyc()) + .append("jngw", getJngw()) + .append("jlrqdyc", getJlrqdyc()) + .append("rjhjyc", getRjhjyc()) + .append("jlflqyc", getJlflqyc()) + .append("nbjt", getNbjt()) + .append("wbjt", getWbjt()) + .append("mxdbyfhkjtj", getMxdbyfhkjtj()) + .append("mxdlgl", getMxdlgl()) + .append("lpjzyc", getLpjzyc()) + .append("mjgj", getMjgj()) + .append("sxyc", getSxyc()) + .append("zlflqyc", getZlflqyc()) + .append("zndbtxyc", getZndbtxyc()) + .append("nbyjgl", getNbyjgl()) + .append("qdyc", getQdyc()) + .append("idct", getIdct()) + .append("xxgxctxvc", getXxgxctxvc()) + .append("bjtxxyc", getBjtxxyc()) + .append("tbctxvc", getTbctxvc()) + .append("zldhyc", getZldhyc()) + .append("lxgl", getLxgl()) + .append("zlzjcqyc", getZlzjcqyc()) + .append("ywgj", getYwgj()) + .append("bjtxyc", getBjtxyc()) + .append("hmictxyc", getHmictxyc()) + .append("jxszcw", getJxszcw()) + .append("hmi485txyc", getHmi485txyc()) + .append("yctxyc", getYctxyc()) + .append("gzz", getGzz()) + .append("gjz", getGjz()) + .append("zlblmsszcw", getZlblmsszcw()) + .append("xtcsbpp", getXtcsbpp()) + .append("dwdybphgj", getDwdybphgj()) + .append("ddycyyx", getDdycyyx()) + .append("gdycyyx", getGdycyyx()) + .append("zlfjyc", getZlfjyc()) + .append("srqwdkgwc", getSrqwdkgwc()) + .append("wbwdkgwc", getWbwdkgwc()) + .append("fybyqwdkgwc", getFybyqwdkgwc()) + .append("dgwdkgwc", getDgwdkgwc()) + .append("zjjdvc", getZjjdvc()) + .append("fjjdvc", getFjjdvc()) + .append("jljdvc", getJljdvc()) + .append("bwjdvc", getBwjdvc()) + .append("bmsjt", getBmsjt()) + .append("kkhrqyc", getKkhrqyc()) + .append("dwgqpdjgj", getDwgqpdjgj()) + .append("glmkgwgJ", getGlmkgwgJ()) + .append("dcgy", getDcgy()) + .append("dcqzqy", getDcqzqy()) + .append("zlgl", getZlgl()) + .append("scdyyc", getScdyyc()) + .append("scdybfhlwtj", getScdybfhlwtj()) + .append("gzbh", getGzbh()) + .append("dlbh", getDlbh()) + .append("nbfjyc", getNbfjyc()) + .append("zlbxsyc", getZlbxsyc()) + .append("dczzqy", getDczzqy()) + .append("dcdygj", getDcdygj()) + .append("wbfjyc", getWbfjyc()) + .append("dcfj", getDcfj()) + .append("dcdybfhcdtj", getDcdybfhcdtj()) + .append("gzgJ", getGzgJ()) + .append("zldhmktxyc", getZldhmktxyc()) + .append("bmsxtgz", getBmsxtgz()) + .append("bmstxyc", getBmstxyc()) + .append("bmsgjdyc", getBmsgjdyc()) + .append("bmsjc", getBmsjc()) + .append("bmsjf", getBmsjf()) + .append("bmsdj", getBmsdj()) + .append("bmsgj", getBmsgj()) + .append("dgfjyc", getDgfjyc()) + .append("srqgwgj", getSrqgwgj()) + .append("gzz2", getGzz2()) + .append("gjz2", getGjz2()) + .append("jlfjsmyc", getJlfjsmyc()) + .append("zlfjsmyc", getZlfjsmyc()) + .append("jlkgSmyc", getJlkgSmyc()) + .append("zlkgSmyc", getZlkgSmyc()) + .append("yljzyc", getYljzyc()) + .append("createBy", getCreateBy()) + .append("createTime", getCreateTime()) + .append("updateBy", getUpdateBy()) + .append("updateTime", getUpdateTime()) + .append("remark", getRemark()) + .toString(); + } +} diff --git a/ems-system/src/main/java/com/xzzn/ems/domain/EmsStackAlarmData.java b/ems-system/src/main/java/com/xzzn/ems/domain/EmsStackAlarmData.java new file mode 100644 index 0000000..a3201a8 --- /dev/null +++ b/ems-system/src/main/java/com/xzzn/ems/domain/EmsStackAlarmData.java @@ -0,0 +1,1545 @@ +package com.xzzn.ems.domain; + +import java.util.Date; +import com.fasterxml.jackson.annotation.JsonFormat; +import com.xzzn.common.core.domain.BaseEntity; +import org.apache.commons.lang3.builder.ToStringBuilder; +import org.apache.commons.lang3.builder.ToStringStyle; +import com.xzzn.common.annotation.Excel; + +/** + * bmsd告警数据对象 ems_stack_alarm_data + * + * @author xzzn + * @date 2025-10-22 + */ +public class EmsStackAlarmData extends BaseEntity +{ + private static final long serialVersionUID = 1L; + + /** */ + private Long id; + + /** 数据采集时间 */ + @JsonFormat(pattern = "yyyy-MM-dd") + @Excel(name = "数据采集时间", width = 30, dateFormat = "yyyy-MM-dd") + private Date dataTimestamp; + + /** 站点id */ + @Excel(name = "站点id") + private String siteId; + + /** 设备唯一标识符 */ + @Excel(name = "设备唯一标识符") + private String deviceId; + + /** BMS故障状态（0=正常，1=故障） */ + @Excel(name = "BMS故障状态", readConverterExp = "0==正常，1=故障") + private Integer bmsgzzt; + + /** 禁充状态（0=允许充电，1=禁止充电） */ + @Excel(name = "禁充状态", readConverterExp = "0==允许充电，1=禁止充电") + private Integer jczt; + + /** 禁放状态（0=允许放电，1=禁止放电） */ + @Excel(name = "禁放状态", readConverterExp = "0==允许放电，1=禁止放电") + private Integer jfzt; + + /** 堆内各组端电压欠压轻度告警汇总（0=无告警，1=有告警） */ + @Excel(name = "堆内各组端电压欠压轻度告警汇总", readConverterExp = "0==无告警，1=有告警") + private Integer dngzddyqyqdgjhz; + + /** 堆内各组端电压欠压中度告警汇总（0=无告警，1=有告警） */ + @Excel(name = "堆内各组端电压欠压中度告警汇总", readConverterExp = "0==无告警，1=有告警") + private Integer dngzddyqyzdgjhz; + + /** 堆内各组端电压欠压重度告警汇总（0=无告警，1=有告警） */ + @Excel(name = "堆内各组端电压欠压重度告警汇总", readConverterExp = "0==无告警，1=有告警") + private Integer dngzddyqyzzdgjhz; + + /** 堆内各组端电压过压轻度告警汇总（0=无告警，1=有告警） */ + @Excel(name = "堆内各组端电压过压轻度告警汇总", readConverterExp = "0==无告警，1=有告警") + private Integer dngzddygyqdgjhz; + + /** 堆内各组端电压过压中度告警汇总（0=无告警，1=有告警） */ + @Excel(name = "堆内各组端电压过压中度告警汇总", readConverterExp = "0==无告警，1=有告警") + private Integer dngzddygyzdgjhz; + + /** 堆内各组端电压过压重度告警汇总（0=无告警，1=有告警） */ + @Excel(name = "堆内各组端电压过压重度告警汇总", readConverterExp = "0==无告警，1=有告警") + private Integer dngzddygyzzdgjhz; + + /** 堆内各组端过流轻度告警汇总（0=无告警，1=有告警） */ + @Excel(name = "堆内各组端过流轻度告警汇总", readConverterExp = "0==无告警，1=有告警") + private Integer dngzdglqdgjhz; + + /** 堆内各组端过流中度告警汇总（0=无告警，1=有告警） */ + @Excel(name = "堆内各组端过流中度告警汇总", readConverterExp = "0==无告警，1=有告警") + private Integer dngzdglzdgjhz; + + /** 堆内各组端过流重度告警汇总（0=无告警，1=有告警） */ + @Excel(name = "堆内各组端过流重度告警汇总", readConverterExp = "0==无告警，1=有告警") + private Integer dngzdglzzdgjhz; + + /** 堆内各组绝缘电阻低轻度告警汇总（0=无告警，1=有告警） */ + @Excel(name = "堆内各组绝缘电阻低轻度告警汇总", readConverterExp = "0==无告警，1=有告警") + private Integer dngzjydzdqdgjhz; + + /** 堆内各组绝缘电阻低中度告警汇总（0=无告警，1=有告警） */ + @Excel(name = "堆内各组绝缘电阻低中度告警汇总", readConverterExp = "0==无告警，1=有告警") + private Integer dngzjydzdzdgjhz; + + /** 堆内各组绝缘电阻低重度告警汇总（0=无告警，1=有告警） */ + @Excel(name = "堆内各组绝缘电阻低重度告警汇总", readConverterExp = "0==无告警，1=有告警") + private Integer dngzjydzdzzdgjhz; + + /** 堆内各组模块欠温度轻度告警汇总（0=无告警，1=有告警） */ + @Excel(name = "堆内各组模块欠温度轻度告警汇总", readConverterExp = "0==无告警，1=有告警") + private Integer dngzmkqwdqdgjhz; + + /** 堆内各组模块欠温度中度告警汇总（0=无告警，1=有告警） */ + @Excel(name = "堆内各组模块欠温度中度告警汇总", readConverterExp = "0==无告警，1=有告警") + private Integer dngzmkqwdzdgjhz; + + /** 堆内各组模块欠温度重度告警汇总（0=无告警，1=有告警） */ + @Excel(name = "堆内各组模块欠温度重度告警汇总", readConverterExp = "0==无告警，1=有告警") + private Integer dngzmkqwdzzdgjhz; + + /** 堆内各组模块过温度轻度告警汇总（0=无告警，1=有告警） */ + @Excel(name = "堆内各组模块过温度轻度告警汇总", readConverterExp = "0==无告警，1=有告警") + private Integer dngzmkgwdqdgjhz; + + /** 堆内各组模块过温度中度告警汇总（0=无告警，1=有告警） */ + @Excel(name = "堆内各组模块过温度中度告警汇总", readConverterExp = "0==无告警，1=有告警") + private Integer dngzmkgwdzdgjhz; + + /** 堆内各组模块过温度重度告警汇总（0=无告警，1=有告警） */ + @Excel(name = "堆内各组模块过温度重度告警汇总", readConverterExp = "0==无告警，1=有告警") + private Integer dngzmkgwdzzdgjhz; + + /** 堆内各单体过压轻微告警汇总（0=无告警，1=有告警） */ + @Excel(name = "堆内各单体过压轻微告警汇总", readConverterExp = "0==无告警，1=有告警") + private Integer dngdtgyqwgjhz; + + /** 堆内各单体过压中度告警汇总（0=无告警，1=有告警） */ + @Excel(name = "堆内各单体过压中度告警汇总", readConverterExp = "0==无告警，1=有告警") + private Integer dngdtgyzdgjhz; + + /** 堆内各单体过压严重告警汇总（0=无告警，1=有告警） */ + @Excel(name = "堆内各单体过压严重告警汇总", readConverterExp = "0==无告警，1=有告警") + private Integer dngdtgyyzgjhz; + + /** 堆内各单体欠压轻微告警汇总（0=无告警，1=有告警） */ + @Excel(name = "堆内各单体欠压轻微告警汇总", readConverterExp = "0==无告警，1=有告警") + private Integer dngdtqyqwgjhz; + + /** 堆内各单体欠压中度告警汇总（0=无告警，1=有告警） */ + @Excel(name = "堆内各单体欠压中度告警汇总", readConverterExp = "0==无告警，1=有告警") + private Integer dngdtqyzdgjhz; + + /** 堆内各单体欠压严重告警汇总（0=无告警，1=有告警） */ + @Excel(name = "堆内各单体欠压严重告警汇总", readConverterExp = "0==无告警，1=有告警") + private Integer dngdtqyyzgjhz; + + /** 堆内各单体压差轻微告警汇总（0=无告警，1=有告警） */ + @Excel(name = "堆内各单体压差轻微告警汇总", readConverterExp = "0==无告警，1=有告警") + private Integer dngdtycqwgjhz; + + /** 堆内各单体压差中度告警汇总（0=无告警，1=有告警） */ + @Excel(name = "堆内各单体压差中度告警汇总", readConverterExp = "0==无告警，1=有告警") + private Integer dngdtyczdgjhz; + + /** 堆内各单体压差严重告警汇总（0=无告警，1=有告警） */ + @Excel(name = "堆内各单体压差严重告警汇总", readConverterExp = "0==无告警，1=有告警") + private Integer dngdtycyzgjhz; + + /** 堆内各单体欠温轻微告警汇总（0=无告警，1=有告警） */ + @Excel(name = "堆内各单体欠温轻微告警汇总", readConverterExp = "0==无告警，1=有告警") + private Integer dngdtqwqwgjhz; + + /** 堆内各单体欠温中度告警汇总（0=无告警，1=有告警） */ + @Excel(name = "堆内各单体欠温中度告警汇总", readConverterExp = "0==无告警，1=有告警") + private Integer dngdtqwzdgjhz; + + /** 堆内各单体欠温严重告警汇总（0=无告警，1=有告警） */ + @Excel(name = "堆内各单体欠温严重告警汇总", readConverterExp = "0==无告警，1=有告警") + private Integer dngdtqwyzgjhz; + + /** 堆内各单体过温轻微告警汇总（0=无告警，1=有告警） */ + @Excel(name = "堆内各单体过温轻微告警汇总", readConverterExp = "0==无告警，1=有告警") + private Integer dngdtgwqwgjhz; + + /** 堆内各单体过温中度告警汇总（0=无告警，1=有告警） */ + @Excel(name = "堆内各单体过温中度告警汇总", readConverterExp = "0==无告警，1=有告警") + private Integer dngdtgwzdgjhz; + + /** 堆内各单体过温严重告警汇总（0=无告警，1=有告警） */ + @Excel(name = "堆内各单体过温严重告警汇总", readConverterExp = "0==无告警，1=有告警") + private Integer dngdtgwyzgjhz; + + /** 堆内各单体温差轻微告警汇总（0=无告警，1=有告警） */ + @Excel(name = "堆内各单体温差轻微告警汇总", readConverterExp = "0==无告警，1=有告警") + private Integer dngdtwcqwgjhz; + + /** 堆内各单体温差中度告警汇总（0=无告警，1=有告警） */ + @Excel(name = "堆内各单体温差中度告警汇总", readConverterExp = "0==无告警，1=有告警") + private Integer dngdtwczdgjhz; + + /** 堆内各单体温差严重告警汇总（0=无告警，1=有告警） */ + @Excel(name = "堆内各单体温差严重告警汇总", readConverterExp = "0==无告警，1=有告警") + private Integer dngdtwcyzgjhz; + + /** 堆内各单体 SOC 低轻微告警汇总（0=无告警，1=有告警） */ + @Excel(name = "堆内各单体 SOC 低轻微告警汇总", readConverterExp = "0==无告警，1=有告警") + private Integer dtsocdqwgjhz; + + /** 堆内各单体 SOC 低中度告警汇总（0=无告警，1=有告警） */ + @Excel(name = "堆内各单体 SOC 低中度告警汇总", readConverterExp = "0==无告警，1=有告警") + private Integer dtsocdzdgjhz; + + /** 堆内各单体 SOC 低严重告警汇总（0=无告警，1=有告警） */ + @Excel(name = "堆内各单体 SOC 低严重告警汇总", readConverterExp = "0==无告警，1=有告警") + private Integer dtsocdyzgjhz; + + /** 堆内各单体 SOC 高轻微告警汇总（0=无告警，1=有告警） */ + @Excel(name = "堆内各单体 SOC 高轻微告警汇总", readConverterExp = "0==无告警，1=有告警") + private Integer dtsocgqwgjhz; + + /** 堆内各单体 SOC 高中度告警汇总（0=无告警，1=有告警） */ + @Excel(name = "堆内各单体 SOC 高中度告警汇总", readConverterExp = "0==无告警，1=有告警") + private Integer dtsocgzdgjhz; + + /** 堆内各单体 SOC 高严重告警汇总（0=无告警，1=有告警） */ + @Excel(name = "堆内各单体 SOC 高严重告警汇总", readConverterExp = "0==无告警，1=有告警") + private Integer dtsocgyzgjhz; + + /** 堆内各单体 SOH 低轻微告警汇总（0=无告警，1=有告警） */ + @Excel(name = "堆内各单体 SOH 低轻微告警汇总", readConverterExp = "0==无告警，1=有告警") + private Integer dtsohdqwgjhz; + + /** 堆内各单体 SOH 低中度告警汇总（0=无告警，1=有告警） */ + @Excel(name = "堆内各单体 SOH 低中度告警汇总", readConverterExp = "0==无告警，1=有告警") + private Integer dtsohdzdgjhz; + + /** 堆内各单体 SOH 低严重告警汇总（0=无告警，1=有告警） */ + @Excel(name = "堆内各单体 SOH 低严重告警汇总", readConverterExp = "0==无告警，1=有告警") + private Integer dtsohdyzgjhz; + + /** 堆内各单体 SOH 高轻微告警汇总（0=无告警，1=有告警） */ + @Excel(name = "堆内各单体 SOH 高轻微告警汇总", readConverterExp = "0==无告警，1=有告警") + private Integer dtsohgqwgjhz; + + /** 堆内各单体 SOH 高中度告警汇总（0=无告警，1=有告警） */ + @Excel(name = "堆内各单体 SOH 高中度告警汇总", readConverterExp = "0==无告警，1=有告警") + private Integer dtsohgzdgjhz; + + /** 堆内各单体 SOH 高严重告警汇总（0=无告警，1=有告警） */ + @Excel(name = "堆内各单体 SOH 高严重告警汇总", readConverterExp = "0==无告警，1=有告警") + private Integer dtsohgyzgjhz; + + /** 堆内各主控失联汇总（0=正常，1=失联） */ + @Excel(name = "堆内各主控失联汇总", readConverterExp = "0==正常，1=失联") + private Integer dngzkslhz; + + /** 堆内各从控失联告警汇总（0=无告警，1=有告警） */ + @Excel(name = "堆内各从控失联告警汇总", readConverterExp = "0==无告警，1=有告警") + private Integer dngckslgjhz; + + /** 堆内各组电压异常（组间压差大于 20V）（0=正常，1=异常） */ + @Excel(name = "堆内各组电压异常", readConverterExp = "组=间压差大于,2=0V") + private Integer dngzdyyc; + + /** 堆内接触器断开异常（0=正常，1=异常） */ + @Excel(name = "堆内接触器断开异常", readConverterExp = "0==正常，1=异常") + private Integer dnjcqdkyc; + + /** 堆内接触器闭合异常（0=正常，1=异常） */ + @Excel(name = "堆内接触器闭合异常", readConverterExp = "0==正常，1=异常") + private Integer dnjcqbhyc; + + /** 充电禁止（0=允许，1=禁止） */ + @Excel(name = "充电禁止", readConverterExp = "0==允许，1=禁止") + private Integer cdjz; + + /** 放电禁止（0=允许，1=禁止） */ + @Excel(name = "放电禁止", readConverterExp = "0==允许，1=禁止") + private Integer fdjz; + + /** BMS 系统告警汇总（0=无告警，1=有告警） */ + @Excel(name = "BMS 系统告警汇总", readConverterExp = "0==无告警，1=有告警") + private Integer bmsxtgjhz; + + /** BMS 系统故障汇总（0=无故障，1=有故障） */ + @Excel(name = "BMS 系统故障汇总", readConverterExp = "0==无故障，1=有故障") + private Integer bmsxtgzhz; + + /** 输入 IN0（0=断开，1=闭合/有效） */ + @Excel(name = "输入 IN0", readConverterExp = "0==断开，1=闭合/有效") + private Integer srin0; + + /** 输入 IN1（0=断开，1=闭合/有效） */ + @Excel(name = "输入 IN1", readConverterExp = "0==断开，1=闭合/有效") + private Integer srin1; + + /** 输入 IN2（0=断开，1=闭合/有效） */ + @Excel(name = "输入 IN2", readConverterExp = "0==断开，1=闭合/有效") + private Integer srin2; + + /** 输入 IN3（0=断开，1=闭合/有效） */ + @Excel(name = "输入 IN3", readConverterExp = "0==断开，1=闭合/有效") + private Integer srin3; + + /** 预留/reserved */ + @Excel(name = "预留/reserved") + private Integer yl1; + + /** 预留/reserved */ + @Excel(name = "预留/reserved") + private Integer yl2; + + /** 预留/reserved */ + @Excel(name = "预留/reserved") + private Integer yl3; + + /** 预留/reserved */ + @Excel(name = "预留/reserved") + private Integer yl4; + + /** 预留/reserved */ + @Excel(name = "预留/reserved") + private Integer yl5; + + /** 预留/reserved */ + @Excel(name = "预留/reserved") + private Integer yl6; + + /** 预留/reserved */ + @Excel(name = "预留/reserved") + private Integer yl7; + + /** 预留/reserved */ + @Excel(name = "预留/reserved") + private Integer yl8; + + /** 堆内各端子过温轻微告警汇总（0=无告警，1=有告警） */ + @Excel(name = "堆内各端子过温轻微告警汇总", readConverterExp = "0==无告警，1=有告警") + private Integer dngdzgwqwgjhz; + + /** 堆内各端子过温中度告警汇总（0=无告警，1=有告警） */ + @Excel(name = "堆内各端子过温中度告警汇总", readConverterExp = "0==无告警，1=有告警") + private Integer dngdzgwzdgjhz; + + /** 堆内各端子过温重度告警汇总（0=无告警，1=有告警） */ + @Excel(name = "堆内各端子过温重度告警汇总", readConverterExp = "0==无告警，1=有告警") + private Integer dngdzgwzzdgjhz; + + /** 堆内模块电压过压轻微告警汇总（0=无告警，1=有告警） */ + @Excel(name = "堆内模块电压过压轻微告警汇总", readConverterExp = "0==无告警，1=有告警") + private Integer dnmkdygyqwgjhz; + + /** 堆内模块电压过压中度告警汇总（0=无告警，1=有告警） */ + @Excel(name = "堆内模块电压过压中度告警汇总", readConverterExp = "0==无告警，1=有告警") + private Integer dnmkdygyzdgjhz; + + /** 堆内模块电压过压严重告警汇总（0=无告警，1=有告警） */ + @Excel(name = "堆内模块电压过压严重告警汇总", readConverterExp = "0==无告警，1=有告警") + private Integer dnmkdygyyzgjhz; + + /** 堆内模块电压欠压轻微告警汇总（0=无告警，1=有告警） */ + @Excel(name = "堆内模块电压欠压轻微告警汇总", readConverterExp = "0==无告警，1=有告警") + private Integer dnmkdyqyqwgjhz; + + /** 堆内模块电压欠压中度告警汇总（0=无告警，1=有告警） */ + @Excel(name = "堆内模块电压欠压中度告警汇总", readConverterExp = "0==无告警，1=有告警") + private Integer dnmkdyqyzdgjhz; + + /** 堆内模块电压欠压严重告警汇总（0=无告警，1=有告警） */ + @Excel(name = "堆内模块电压欠压严重告警汇总", readConverterExp = "0==无告警，1=有告警") + private Integer dnmkdyqyyzgjhz; + + /** 电压采集失联（0=正常，1=失联） */ + @Excel(name = "电压采集失联", readConverterExp = "0==正常，1=失联") + private Integer dycjsl; + + /** 温度采集失联（0=正常，1=失联） */ + @Excel(name = "温度采集失联", readConverterExp = "0==正常，1=失联") + private Integer wdcjsl; + + /** DIDO-DI0（0=断开，1=闭合/有效） */ + @Excel(name = "DIDO-DI0", readConverterExp = "0==断开，1=闭合/有效") + private Integer didodi0; + + /** DIDO-DI1（0=断开，1=闭合/有效） */ + @Excel(name = "DIDO-DI1", readConverterExp = "0==断开，1=闭合/有效") + private Integer didodi1; + + /** DIDO-DI2（0=断开，1=闭合/有效） */ + @Excel(name = "DIDO-DI2", readConverterExp = "0==断开，1=闭合/有效") + private Integer didodi2; + + /** DIDO-DI3（0=断开，1=闭合/有效） */ + @Excel(name = "DIDO-DI3", readConverterExp = "0==断开，1=闭合/有效") + private Integer didodi3; + + /** DIDO-DI4（0=断开，1=闭合/有效） */ + @Excel(name = "DIDO-DI4", readConverterExp = "0==断开，1=闭合/有效") + private Integer didodi4; + + /** DIDO-DI5（0=断开，1=闭合/有效） */ + @Excel(name = "DIDO-DI5", readConverterExp = "0==断开，1=闭合/有效") + private Integer didodi5; + + /** DIDO-DI6（0=断开，1=闭合/有效） */ + @Excel(name = "DIDO-DI6", readConverterExp = "0==断开，1=闭合/有效") + private Integer didodi6; + + /** DIDO-DI7（0=断开，1=闭合/有效） */ + @Excel(name = "DIDO-DI7", readConverterExp = "0==断开，1=闭合/有效") + private Integer didodi7; + + /** DIDO-DI8（0=断开，1=闭合/有效） */ + @Excel(name = "DIDO-DI8", readConverterExp = "0==断开，1=闭合/有效") + private Integer didodi8; + + /** DIDO-DI9（0=断开，1=闭合/有效） */ + @Excel(name = "DIDO-DI9", readConverterExp = "0==断开，1=闭合/有效") + private Integer didodi9; + + /** DIDO-DI10（0=断开，1=闭合/有效） */ + @Excel(name = "DIDO-DI10", readConverterExp = "0==断开，1=闭合/有效") + private Integer didodi10; + + /** DIDO-DI11（0=断开，1=闭合/有效） */ + @Excel(name = "DIDO-DI11", readConverterExp = "0==断开，1=闭合/有效") + private Integer didodi11; + + /** DIDO-DI12（0=断开，1=闭合/有效） */ + @Excel(name = "DIDO-DI12", readConverterExp = "0==断开，1=闭合/有效") + private Integer didodi12; + + /** 空调-通信失联（0=正常，1=失联） */ + @Excel(name = "空调-通信失联", readConverterExp = "0==正常，1=失联") + private Integer kttxsl; + + public void setId(Long id) + { + this.id = id; + } + + public Long getId() + { + return id; + } + + public void setDataTimestamp(Date dataTimestamp) + { + this.dataTimestamp = dataTimestamp; + } + + public Date getDataTimestamp() + { + return dataTimestamp; + } + + public void setSiteId(String siteId) + { + this.siteId = siteId; + } + + public String getSiteId() + { + return siteId; + } + + public void setDeviceId(String deviceId) + { + this.deviceId = deviceId; + } + + public String getDeviceId() + { + return deviceId; + } + + public void setBmsgzzt(Integer bmsgzzt) + { + this.bmsgzzt = bmsgzzt; + } + + public Integer getBmsgzzt() + { + return bmsgzzt; + } + + public void setJczt(Integer jczt) + { + this.jczt = jczt; + } + + public Integer getJczt() + { + return jczt; + } + + public void setJfzt(Integer jfzt) + { + this.jfzt = jfzt; + } + + public Integer getJfzt() + { + return jfzt; + } + + public void setDngzddyqyqdgjhz(Integer dngzddyqyqdgjhz) + { + this.dngzddyqyqdgjhz = dngzddyqyqdgjhz; + } + + public Integer getDngzddyqyqdgjhz() + { + return dngzddyqyqdgjhz; + } + + public void setDngzddyqyzdgjhz(Integer dngzddyqyzdgjhz) + { + this.dngzddyqyzdgjhz = dngzddyqyzdgjhz; + } + + public Integer getDngzddyqyzdgjhz() + { + return dngzddyqyzdgjhz; + } + + public void setDngzddyqyzzdgjhz(Integer dngzddyqyzzdgjhz) + { + this.dngzddyqyzzdgjhz = dngzddyqyzzdgjhz; + } + + public Integer getDngzddyqyzzdgjhz() + { + return dngzddyqyzzdgjhz; + } + + public void setDngzddygyqdgjhz(Integer dngzddygyqdgjhz) + { + this.dngzddygyqdgjhz = dngzddygyqdgjhz; + } + + public Integer getDngzddygyqdgjhz() + { + return dngzddygyqdgjhz; + } + + public void setDngzddygyzdgjhz(Integer dngzddygyzdgjhz) + { + this.dngzddygyzdgjhz = dngzddygyzdgjhz; + } + + public Integer getDngzddygyzdgjhz() + { + return dngzddygyzdgjhz; + } + + public void setDngzddygyzzdgjhz(Integer dngzddygyzzdgjhz) + { + this.dngzddygyzzdgjhz = dngzddygyzzdgjhz; + } + + public Integer getDngzddygyzzdgjhz() + { + return dngzddygyzzdgjhz; + } + + public void setDngzdglqdgjhz(Integer dngzdglqdgjhz) + { + this.dngzdglqdgjhz = dngzdglqdgjhz; + } + + public Integer getDngzdglqdgjhz() + { + return dngzdglqdgjhz; + } + + public void setDngzdglzdgjhz(Integer dngzdglzdgjhz) + { + this.dngzdglzdgjhz = dngzdglzdgjhz; + } + + public Integer getDngzdglzdgjhz() + { + return dngzdglzdgjhz; + } + + public void setDngzdglzzdgjhz(Integer dngzdglzzdgjhz) + { + this.dngzdglzzdgjhz = dngzdglzzdgjhz; + } + + public Integer getDngzdglzzdgjhz() + { + return dngzdglzzdgjhz; + } + + public void setDngzjydzdqdgjhz(Integer dngzjydzdqdgjhz) + { + this.dngzjydzdqdgjhz = dngzjydzdqdgjhz; + } + + public Integer getDngzjydzdqdgjhz() + { + return dngzjydzdqdgjhz; + } + + public void setDngzjydzdzdgjhz(Integer dngzjydzdzdgjhz) + { + this.dngzjydzdzdgjhz = dngzjydzdzdgjhz; + } + + public Integer getDngzjydzdzdgjhz() + { + return dngzjydzdzdgjhz; + } + + public void setDngzjydzdzzdgjhz(Integer dngzjydzdzzdgjhz) + { + this.dngzjydzdzzdgjhz = dngzjydzdzzdgjhz; + } + + public Integer getDngzjydzdzzdgjhz() + { + return dngzjydzdzzdgjhz; + } + + public void setDngzmkqwdqdgjhz(Integer dngzmkqwdqdgjhz) + { + this.dngzmkqwdqdgjhz = dngzmkqwdqdgjhz; + } + + public Integer getDngzmkqwdqdgjhz() + { + return dngzmkqwdqdgjhz; + } + + public void setDngzmkqwdzdgjhz(Integer dngzmkqwdzdgjhz) + { + this.dngzmkqwdzdgjhz = dngzmkqwdzdgjhz; + } + + public Integer getDngzmkqwdzdgjhz() + { + return dngzmkqwdzdgjhz; + } + + public void setDngzmkqwdzzdgjhz(Integer dngzmkqwdzzdgjhz) + { + this.dngzmkqwdzzdgjhz = dngzmkqwdzzdgjhz; + } + + public Integer getDngzmkqwdzzdgjhz() + { + return dngzmkqwdzzdgjhz; + } + + public void setDngzmkgwdqdgjhz(Integer dngzmkgwdqdgjhz) + { + this.dngzmkgwdqdgjhz = dngzmkgwdqdgjhz; + } + + public Integer getDngzmkgwdqdgjhz() + { + return dngzmkgwdqdgjhz; + } + + public void setDngzmkgwdzdgjhz(Integer dngzmkgwdzdgjhz) + { + this.dngzmkgwdzdgjhz = dngzmkgwdzdgjhz; + } + + public Integer getDngzmkgwdzdgjhz() + { + return dngzmkgwdzdgjhz; + } + + public void setDngzmkgwdzzdgjhz(Integer dngzmkgwdzzdgjhz) + { + this.dngzmkgwdzzdgjhz = dngzmkgwdzzdgjhz; + } + + public Integer getDngzmkgwdzzdgjhz() + { + return dngzmkgwdzzdgjhz; + } + + public void setDngdtgyqwgjhz(Integer dngdtgyqwgjhz) + { + this.dngdtgyqwgjhz = dngdtgyqwgjhz; + } + + public Integer getDngdtgyqwgjhz() + { + return dngdtgyqwgjhz; + } + + public void setDngdtgyzdgjhz(Integer dngdtgyzdgjhz) + { + this.dngdtgyzdgjhz = dngdtgyzdgjhz; + } + + public Integer getDngdtgyzdgjhz() + { + return dngdtgyzdgjhz; + } + + public void setDngdtgyyzgjhz(Integer dngdtgyyzgjhz) + { + this.dngdtgyyzgjhz = dngdtgyyzgjhz; + } + + public Integer getDngdtgyyzgjhz() + { + return dngdtgyyzgjhz; + } + + public void setDngdtqyqwgjhz(Integer dngdtqyqwgjhz) + { + this.dngdtqyqwgjhz = dngdtqyqwgjhz; + } + + public Integer getDngdtqyqwgjhz() + { + return dngdtqyqwgjhz; + } + + public void setDngdtqyzdgjhz(Integer dngdtqyzdgjhz) + { + this.dngdtqyzdgjhz = dngdtqyzdgjhz; + } + + public Integer getDngdtqyzdgjhz() + { + return dngdtqyzdgjhz; + } + + public void setDngdtqyyzgjhz(Integer dngdtqyyzgjhz) + { + this.dngdtqyyzgjhz = dngdtqyyzgjhz; + } + + public Integer getDngdtqyyzgjhz() + { + return dngdtqyyzgjhz; + } + + public void setDngdtycqwgjhz(Integer dngdtycqwgjhz) + { + this.dngdtycqwgjhz = dngdtycqwgjhz; + } + + public Integer getDngdtycqwgjhz() + { + return dngdtycqwgjhz; + } + + public void setDngdtyczdgjhz(Integer dngdtyczdgjhz) + { + this.dngdtyczdgjhz = dngdtyczdgjhz; + } + + public Integer getDngdtyczdgjhz() + { + return dngdtyczdgjhz; + } + + public void setDngdtycyzgjhz(Integer dngdtycyzgjhz) + { + this.dngdtycyzgjhz = dngdtycyzgjhz; + } + + public Integer getDngdtycyzgjhz() + { + return dngdtycyzgjhz; + } + + public void setDngdtqwqwgjhz(Integer dngdtqwqwgjhz) + { + this.dngdtqwqwgjhz = dngdtqwqwgjhz; + } + + public Integer getDngdtqwqwgjhz() + { + return dngdtqwqwgjhz; + } + + public void setDngdtqwzdgjhz(Integer dngdtqwzdgjhz) + { + this.dngdtqwzdgjhz = dngdtqwzdgjhz; + } + + public Integer getDngdtqwzdgjhz() + { + return dngdtqwzdgjhz; + } + + public void setDngdtqwyzgjhz(Integer dngdtqwyzgjhz) + { + this.dngdtqwyzgjhz = dngdtqwyzgjhz; + } + + public Integer getDngdtqwyzgjhz() + { + return dngdtqwyzgjhz; + } + + public void setDngdtgwqwgjhz(Integer dngdtgwqwgjhz) + { + this.dngdtgwqwgjhz = dngdtgwqwgjhz; + } + + public Integer getDngdtgwqwgjhz() + { + return dngdtgwqwgjhz; + } + + public void setDngdtgwzdgjhz(Integer dngdtgwzdgjhz) + { + this.dngdtgwzdgjhz = dngdtgwzdgjhz; + } + + public Integer getDngdtgwzdgjhz() + { + return dngdtgwzdgjhz; + } + + public void setDngdtgwyzgjhz(Integer dngdtgwyzgjhz) + { + this.dngdtgwyzgjhz = dngdtgwyzgjhz; + } + + public Integer getDngdtgwyzgjhz() + { + return dngdtgwyzgjhz; + } + + public void setDngdtwcqwgjhz(Integer dngdtwcqwgjhz) + { + this.dngdtwcqwgjhz = dngdtwcqwgjhz; + } + + public Integer getDngdtwcqwgjhz() + { + return dngdtwcqwgjhz; + } + + public void setDngdtwczdgjhz(Integer dngdtwczdgjhz) + { + this.dngdtwczdgjhz = dngdtwczdgjhz; + } + + public Integer getDngdtwczdgjhz() + { + return dngdtwczdgjhz; + } + + public void setDngdtwcyzgjhz(Integer dngdtwcyzgjhz) + { + this.dngdtwcyzgjhz = dngdtwcyzgjhz; + } + + public Integer getDngdtwcyzgjhz() + { + return dngdtwcyzgjhz; + } + + public void setDtsocdqwgjhz(Integer dtsocdqwgjhz) + { + this.dtsocdqwgjhz = dtsocdqwgjhz; + } + + public Integer getDtsocdqwgjhz() + { + return dtsocdqwgjhz; + } + + public void setDtsocdzdgjhz(Integer dtsocdzdgjhz) + { + this.dtsocdzdgjhz = dtsocdzdgjhz; + } + + public Integer getDtsocdzdgjhz() + { + return dtsocdzdgjhz; + } + + public void setDtsocdyzgjhz(Integer dtsocdyzgjhz) + { + this.dtsocdyzgjhz = dtsocdyzgjhz; + } + + public Integer getDtsocdyzgjhz() + { + return dtsocdyzgjhz; + } + + public void setDtsocgqwgjhz(Integer dtsocgqwgjhz) + { + this.dtsocgqwgjhz = dtsocgqwgjhz; + } + + public Integer getDtsocgqwgjhz() + { + return dtsocgqwgjhz; + } + + public void setDtsocgzdgjhz(Integer dtsocgzdgjhz) + { + this.dtsocgzdgjhz = dtsocgzdgjhz; + } + + public Integer getDtsocgzdgjhz() + { + return dtsocgzdgjhz; + } + + public void setDtsocgyzgjhz(Integer dtsocgyzgjhz) + { + this.dtsocgyzgjhz = dtsocgyzgjhz; + } + + public Integer getDtsocgyzgjhz() + { + return dtsocgyzgjhz; + } + + public void setDtsohdqwgjhz(Integer dtsohdqwgjhz) + { + this.dtsohdqwgjhz = dtsohdqwgjhz; + } + + public Integer getDtsohdqwgjhz() + { + return dtsohdqwgjhz; + } + + public void setDtsohdzdgjhz(Integer dtsohdzdgjhz) + { + this.dtsohdzdgjhz = dtsohdzdgjhz; + } + + public Integer getDtsohdzdgjhz() + { + return dtsohdzdgjhz; + } + + public void setDtsohdyzgjhz(Integer dtsohdyzgjhz) + { + this.dtsohdyzgjhz = dtsohdyzgjhz; + } + + public Integer getDtsohdyzgjhz() + { + return dtsohdyzgjhz; + } + + public void setDtsohgqwgjhz(Integer dtsohgqwgjhz) + { + this.dtsohgqwgjhz = dtsohgqwgjhz; + } + + public Integer getDtsohgqwgjhz() + { + return dtsohgqwgjhz; + } + + public void setDtsohgzdgjhz(Integer dtsohgzdgjhz) + { + this.dtsohgzdgjhz = dtsohgzdgjhz; + } + + public Integer getDtsohgzdgjhz() + { + return dtsohgzdgjhz; + } + + public void setDtsohgyzgjhz(Integer dtsohgyzgjhz) + { + this.dtsohgyzgjhz = dtsohgyzgjhz; + } + + public Integer getDtsohgyzgjhz() + { + return dtsohgyzgjhz; + } + + public void setDngzkslhz(Integer dngzkslhz) + { + this.dngzkslhz = dngzkslhz; + } + + public Integer getDngzkslhz() + { + return dngzkslhz; + } + + public void setDngckslgjhz(Integer dngckslgjhz) + { + this.dngckslgjhz = dngckslgjhz; + } + + public Integer getDngckslgjhz() + { + return dngckslgjhz; + } + + public void setDngzdyyc(Integer dngzdyyc) + { + this.dngzdyyc = dngzdyyc; + } + + public Integer getDngzdyyc() + { + return dngzdyyc; + } + + public void setDnjcqdkyc(Integer dnjcqdkyc) + { + this.dnjcqdkyc = dnjcqdkyc; + } + + public Integer getDnjcqdkyc() + { + return dnjcqdkyc; + } + + public void setDnjcqbhyc(Integer dnjcqbhyc) + { + this.dnjcqbhyc = dnjcqbhyc; + } + + public Integer getDnjcqbhyc() + { + return dnjcqbhyc; + } + + public void setCdjz(Integer cdjz) + { + this.cdjz = cdjz; + } + + public Integer getCdjz() + { + return cdjz; + } + + public void setFdjz(Integer fdjz) + { + this.fdjz = fdjz; + } + + public Integer getFdjz() + { + return fdjz; + } + + public void setBmsxtgjhz(Integer bmsxtgjhz) + { + this.bmsxtgjhz = bmsxtgjhz; + } + + public Integer getBmsxtgjhz() + { + return bmsxtgjhz; + } + + public void setBmsxtgzhz(Integer bmsxtgzhz) + { + this.bmsxtgzhz = bmsxtgzhz; + } + + public Integer getBmsxtgzhz() + { + return bmsxtgzhz; + } + + public void setSrin0(Integer srin0) + { + this.srin0 = srin0; + } + + public Integer getSrin0() + { + return srin0; + } + + public void setSrin1(Integer srin1) + { + this.srin1 = srin1; + } + + public Integer getSrin1() + { + return srin1; + } + + public void setSrin2(Integer srin2) + { + this.srin2 = srin2; + } + + public Integer getSrin2() + { + return srin2; + } + + public void setSrin3(Integer srin3) + { + this.srin3 = srin3; + } + + public Integer getSrin3() + { + return srin3; + } + + public void setYl1(Integer yl1) + { + this.yl1 = yl1; + } + + public Integer getYl1() + { + return yl1; + } + + public void setYl2(Integer yl2) + { + this.yl2 = yl2; + } + + public Integer getYl2() + { + return yl2; + } + + public void setYl3(Integer yl3) + { + this.yl3 = yl3; + } + + public Integer getYl3() + { + return yl3; + } + + public void setYl4(Integer yl4) + { + this.yl4 = yl4; + } + + public Integer getYl4() + { + return yl4; + } + + public void setYl5(Integer yl5) + { + this.yl5 = yl5; + } + + public Integer getYl5() + { + return yl5; + } + + public void setYl6(Integer yl6) + { + this.yl6 = yl6; + } + + public Integer getYl6() + { + return yl6; + } + + public void setYl7(Integer yl7) + { + this.yl7 = yl7; + } + + public Integer getYl7() + { + return yl7; + } + + public void setYl8(Integer yl8) + { + this.yl8 = yl8; + } + + public Integer getYl8() + { + return yl8; + } + + public void setDngdzgwqwgjhz(Integer dngdzgwqwgjhz) + { + this.dngdzgwqwgjhz = dngdzgwqwgjhz; + } + + public Integer getDngdzgwqwgjhz() + { + return dngdzgwqwgjhz; + } + + public void setDngdzgwzdgjhz(Integer dngdzgwzdgjhz) + { + this.dngdzgwzdgjhz = dngdzgwzdgjhz; + } + + public Integer getDngdzgwzdgjhz() + { + return dngdzgwzdgjhz; + } + + public void setDngdzgwzzdgjhz(Integer dngdzgwzzdgjhz) + { + this.dngdzgwzzdgjhz = dngdzgwzzdgjhz; + } + + public Integer getDngdzgwzzdgjhz() + { + return dngdzgwzzdgjhz; + } + + public void setDnmkdygyqwgjhz(Integer dnmkdygyqwgjhz) + { + this.dnmkdygyqwgjhz = dnmkdygyqwgjhz; + } + + public Integer getDnmkdygyqwgjhz() + { + return dnmkdygyqwgjhz; + } + + public void setDnmkdygyzdgjhz(Integer dnmkdygyzdgjhz) + { + this.dnmkdygyzdgjhz = dnmkdygyzdgjhz; + } + + public Integer getDnmkdygyzdgjhz() + { + return dnmkdygyzdgjhz; + } + + public void setDnmkdygyyzgjhz(Integer dnmkdygyyzgjhz) + { + this.dnmkdygyyzgjhz = dnmkdygyyzgjhz; + } + + public Integer getDnmkdygyyzgjhz() + { + return dnmkdygyyzgjhz; + } + + public void setDnmkdyqyqwgjhz(Integer dnmkdyqyqwgjhz) + { + this.dnmkdyqyqwgjhz = dnmkdyqyqwgjhz; + } + + public Integer getDnmkdyqyqwgjhz() + { + return dnmkdyqyqwgjhz; + } + + public void setDnmkdyqyzdgjhz(Integer dnmkdyqyzdgjhz) + { + this.dnmkdyqyzdgjhz = dnmkdyqyzdgjhz; + } + + public Integer getDnmkdyqyzdgjhz() + { + return dnmkdyqyzdgjhz; + } + + public void setDnmkdyqyyzgjhz(Integer dnmkdyqyyzgjhz) + { + this.dnmkdyqyyzgjhz = dnmkdyqyyzgjhz; + } + + public Integer getDnmkdyqyyzgjhz() + { + return dnmkdyqyyzgjhz; + } + + public void setDycjsl(Integer dycjsl) + { + this.dycjsl = dycjsl; + } + + public Integer getDycjsl() + { + return dycjsl; + } + + public void setWdcjsl(Integer wdcjsl) + { + this.wdcjsl = wdcjsl; + } + + public Integer getWdcjsl() + { + return wdcjsl; + } + + public void setDidodi0(Integer didodi0) + { + this.didodi0 = didodi0; + } + + public Integer getDidodi0() + { + return didodi0; + } + + public void setDidodi1(Integer didodi1) + { + this.didodi1 = didodi1; + } + + public Integer getDidodi1() + { + return didodi1; + } + + public void setDidodi2(Integer didodi2) + { + this.didodi2 = didodi2; + } + + public Integer getDidodi2() + { + return didodi2; + } + + public void setDidodi3(Integer didodi3) + { + this.didodi3 = didodi3; + } + + public Integer getDidodi3() + { + return didodi3; + } + + public void setDidodi4(Integer didodi4) + { + this.didodi4 = didodi4; + } + + public Integer getDidodi4() + { + return didodi4; + } + + public void setDidodi5(Integer didodi5) + { + this.didodi5 = didodi5; + } + + public Integer getDidodi5() + { + return didodi5; + } + + public void setDidodi6(Integer didodi6) + { + this.didodi6 = didodi6; + } + + public Integer getDidodi6() + { + return didodi6; + } + + public void setDidodi7(Integer didodi7) + { + this.didodi7 = didodi7; + } + + public Integer getDidodi7() + { + return didodi7; + } + + public void setDidodi8(Integer didodi8) + { + this.didodi8 = didodi8; + } + + public Integer getDidodi8() + { + return didodi8; + } + + public void setDidodi9(Integer didodi9) + { + this.didodi9 = didodi9; + } + + public Integer getDidodi9() + { + return didodi9; + } + + public void setDidodi10(Integer didodi10) + { + this.didodi10 = didodi10; + } + + public Integer getDidodi10() + { + return didodi10; + } + + public void setDidodi11(Integer didodi11) + { + this.didodi11 = didodi11; + } + + public Integer getDidodi11() + { + return didodi11; + } + + public void setDidodi12(Integer didodi12) + { + this.didodi12 = didodi12; + } + + public Integer getDidodi12() + { + return didodi12; + } + + public void setKttxsl(Integer kttxsl) + { + this.kttxsl = kttxsl; + } + + public Integer getKttxsl() + { + return kttxsl; + } + + @Override + public String toString() { + return new ToStringBuilder(this,ToStringStyle.MULTI_LINE_STYLE) + .append("id", getId()) + .append("dataTimestamp", getDataTimestamp()) + .append("siteId", getSiteId()) + .append("deviceId", getDeviceId()) + .append("bmsgzzt", getBmsgzzt()) + .append("jczt", getJczt()) + .append("jfzt", getJfzt()) + .append("dngzddyqyqdgjhz", getDngzddyqyqdgjhz()) + .append("dngzddyqyzdgjhz", getDngzddyqyzdgjhz()) + .append("dngzddyqyzzdgjhz", getDngzddyqyzzdgjhz()) + .append("dngzddygyqdgjhz", getDngzddygyqdgjhz()) + .append("dngzddygyzdgjhz", getDngzddygyzdgjhz()) + .append("dngzddygyzzdgjhz", getDngzddygyzzdgjhz()) + .append("dngzdglqdgjhz", getDngzdglqdgjhz()) + .append("dngzdglzdgjhz", getDngzdglzdgjhz()) + .append("dngzdglzzdgjhz", getDngzdglzzdgjhz()) + .append("dngzjydzdqdgjhz", getDngzjydzdqdgjhz()) + .append("dngzjydzdzdgjhz", getDngzjydzdzdgjhz()) + .append("dngzjydzdzzdgjhz", getDngzjydzdzzdgjhz()) + .append("dngzmkqwdqdgjhz", getDngzmkqwdqdgjhz()) + .append("dngzmkqwdzdgjhz", getDngzmkqwdzdgjhz()) + .append("dngzmkqwdzzdgjhz", getDngzmkqwdzzdgjhz()) + .append("dngzmkgwdqdgjhz", getDngzmkgwdqdgjhz()) + .append("dngzmkgwdzdgjhz", getDngzmkgwdzdgjhz()) + .append("dngzmkgwdzzdgjhz", getDngzmkgwdzzdgjhz()) + .append("dngdtgyqwgjhz", getDngdtgyqwgjhz()) + .append("dngdtgyzdgjhz", getDngdtgyzdgjhz()) + .append("dngdtgyyzgjhz", getDngdtgyyzgjhz()) + .append("dngdtqyqwgjhz", getDngdtqyqwgjhz()) + .append("dngdtqyzdgjhz", getDngdtqyzdgjhz()) + .append("dngdtqyyzgjhz", getDngdtqyyzgjhz()) + .append("dngdtycqwgjhz", getDngdtycqwgjhz()) + .append("dngdtyczdgjhz", getDngdtyczdgjhz()) + .append("dngdtycyzgjhz", getDngdtycyzgjhz()) + .append("dngdtqwqwgjhz", getDngdtqwqwgjhz()) + .append("dngdtqwzdgjhz", getDngdtqwzdgjhz()) + .append("dngdtqwyzgjhz", getDngdtqwyzgjhz()) + .append("dngdtgwqwgjhz", getDngdtgwqwgjhz()) + .append("dngdtgwzdgjhz", getDngdtgwzdgjhz()) + .append("dngdtgwyzgjhz", getDngdtgwyzgjhz()) + .append("dngdtwcqwgjhz", getDngdtwcqwgjhz()) + .append("dngdtwczdgjhz", getDngdtwczdgjhz()) + .append("dngdtwcyzgjhz", getDngdtwcyzgjhz()) + .append("dtsocdqwgjhz", getDtsocdqwgjhz()) + .append("dtsocdzdgjhz", getDtsocdzdgjhz()) + .append("dtsocdyzgjhz", getDtsocdyzgjhz()) + .append("dtsocgqwgjhz", getDtsocgqwgjhz()) + .append("dtsocgzdgjhz", getDtsocgzdgjhz()) + .append("dtsocgyzgjhz", getDtsocgyzgjhz()) + .append("dtsohdqwgjhz", getDtsohdqwgjhz()) + .append("dtsohdzdgjhz", getDtsohdzdgjhz()) + .append("dtsohdyzgjhz", getDtsohdyzgjhz()) + .append("dtsohgqwgjhz", getDtsohgqwgjhz()) + .append("dtsohgzdgjhz", getDtsohgzdgjhz()) + .append("dtsohgyzgjhz", getDtsohgyzgjhz()) + .append("dngzkslhz", getDngzkslhz()) + .append("dngckslgjhz", getDngckslgjhz()) + .append("dngzdyyc", getDngzdyyc()) + .append("dnjcqdkyc", getDnjcqdkyc()) + .append("dnjcqbhyc", getDnjcqbhyc()) + .append("cdjz", getCdjz()) + .append("fdjz", getFdjz()) + .append("bmsxtgjhz", getBmsxtgjhz()) + .append("bmsxtgzhz", getBmsxtgzhz()) + .append("srin0", getSrin0()) + .append("srin1", getSrin1()) + .append("srin2", getSrin2()) + .append("srin3", getSrin3()) + .append("yl1", getYl1()) + .append("yl2", getYl2()) + .append("yl3", getYl3()) + .append("yl4", getYl4()) + .append("yl5", getYl5()) + .append("yl6", getYl6()) + .append("yl7", getYl7()) + .append("yl8", getYl8()) + .append("dngdzgwqwgjhz", getDngdzgwqwgjhz()) + .append("dngdzgwzdgjhz", getDngdzgwzdgjhz()) + .append("dngdzgwzzdgjhz", getDngdzgwzzdgjhz()) + .append("dnmkdygyqwgjhz", getDnmkdygyqwgjhz()) + .append("dnmkdygyzdgjhz", getDnmkdygyzdgjhz()) + .append("dnmkdygyyzgjhz", getDnmkdygyyzgjhz()) + .append("dnmkdyqyqwgjhz", getDnmkdyqyqwgjhz()) + .append("dnmkdyqyzdgjhz", getDnmkdyqyzdgjhz()) + .append("dnmkdyqyyzgjhz", getDnmkdyqyyzgjhz()) + .append("dycjsl", getDycjsl()) + .append("wdcjsl", getWdcjsl()) + .append("didodi0", getDidodi0()) + .append("didodi1", getDidodi1()) + .append("didodi2", getDidodi2()) + .append("didodi3", getDidodi3()) + .append("didodi4", getDidodi4()) + .append("didodi5", getDidodi5()) + .append("didodi6", getDidodi6()) + .append("didodi7", getDidodi7()) + .append("didodi8", getDidodi8()) + .append("didodi9", getDidodi9()) + .append("didodi10", getDidodi10()) + .append("didodi11", getDidodi11()) + .append("didodi12", getDidodi12()) + .append("kttxsl", getKttxsl()) + .append("createBy", getCreateBy()) + .append("createTime", getCreateTime()) + .append("updateBy", getUpdateBy()) + .append("updateTime", getUpdateTime()) + .append("remark", getRemark()) + .toString(); + } +} diff --git a/ems-system/src/main/java/com/xzzn/ems/mapper/EmsClusterAlarmDataMapper.java b/ems-system/src/main/java/com/xzzn/ems/mapper/EmsClusterAlarmDataMapper.java new file mode 100644 index 0000000..b02249c --- /dev/null +++ b/ems-system/src/main/java/com/xzzn/ems/mapper/EmsClusterAlarmDataMapper.java @@ -0,0 +1,61 @@ +package com.xzzn.ems.mapper; + +import java.util.List; +import com.xzzn.ems.domain.EmsClusterAlarmData; + +/** + * bmsc告警数据Mapper接口 + * + * @author xzzn + * @date 2025-10-22 + */ +public interface EmsClusterAlarmDataMapper +{ + /** + * 查询bmsc告警数据 + * + * @param id bmsc告警数据主键 + * @return bmsc告警数据 + */ + public EmsClusterAlarmData selectEmsClusterAlarmDataById(Long id); + + /** + * 查询bmsc告警数据列表 + * + * @param emsClusterAlarmData bmsc告警数据 + * @return bmsc告警数据集合 + */ + public List selectEmsClusterAlarmDataList(EmsClusterAlarmData emsClusterAlarmData); + + /** + * 新增bmsc告警数据 + * + * @param emsClusterAlarmData bmsc告警数据 + * @return 结果 + */ + public int insertEmsClusterAlarmData(EmsClusterAlarmData emsClusterAlarmData); + + /** + * 修改bmsc告警数据 + * + * @param emsClusterAlarmData bmsc告警数据 + * @return 结果 + */ + public int updateEmsClusterAlarmData(EmsClusterAlarmData emsClusterAlarmData); + + /** + * 删除bmsc告警数据 + * + * @param id bmsc告警数据主键 + * @return 结果 + */ + public int deleteEmsClusterAlarmDataById(Long id); + + /** + * 批量删除bmsc告警数据 + * + * @param ids 需要删除的数据主键集合 + * @return 结果 + */ + public int deleteEmsClusterAlarmDataByIds(Long[] ids); +} diff --git a/ems-system/src/main/java/com/xzzn/ems/mapper/EmsCoolingAlarmDataMapper.java b/ems-system/src/main/java/com/xzzn/ems/mapper/EmsCoolingAlarmDataMapper.java new file mode 100644 index 0000000..778354b --- /dev/null +++ b/ems-system/src/main/java/com/xzzn/ems/mapper/EmsCoolingAlarmDataMapper.java @@ -0,0 +1,61 @@ +package com.xzzn.ems.mapper; + +import java.util.List; +import com.xzzn.ems.domain.EmsCoolingAlarmData; + +/** + * ZSLQ告警故障数据Mapper接口 + * + * @author xzzn + * @date 2025-10-22 + */ +public interface EmsCoolingAlarmDataMapper +{ + /** + * 查询ZSLQ告警故障数据 + * + * @param id ZSLQ告警故障数据主键 + * @return ZSLQ告警故障数据 + */ + public EmsCoolingAlarmData selectEmsCoolingAlarmDataById(Long id); + + /** + * 查询ZSLQ告警故障数据列表 + * + * @param emsCoolingAlarmData ZSLQ告警故障数据 + * @return ZSLQ告警故障数据集合 + */ + public List selectEmsCoolingAlarmDataList(EmsCoolingAlarmData emsCoolingAlarmData); + + /** + * 新增ZSLQ告警故障数据 + * + * @param emsCoolingAlarmData ZSLQ告警故障数据 + * @return 结果 + */ + public int insertEmsCoolingAlarmData(EmsCoolingAlarmData emsCoolingAlarmData); + + /** + * 修改ZSLQ告警故障数据 + * + * @param emsCoolingAlarmData ZSLQ告警故障数据 + * @return 结果 + */ + public int updateEmsCoolingAlarmData(EmsCoolingAlarmData emsCoolingAlarmData); + + /** + * 删除ZSLQ告警故障数据 + * + * @param id ZSLQ告警故障数据主键 + * @return 结果 + */ + public int deleteEmsCoolingAlarmDataById(Long id); + + /** + * 批量删除ZSLQ告警故障数据 + * + * @param ids 需要删除的数据主键集合 + * @return 结果 + */ + public int deleteEmsCoolingAlarmDataByIds(Long[] ids); +} diff --git a/ems-system/src/main/java/com/xzzn/ems/mapper/EmsPcsAlarmDataMapper.java b/ems-system/src/main/java/com/xzzn/ems/mapper/EmsPcsAlarmDataMapper.java new file mode 100644 index 0000000..82b96c7 --- /dev/null +++ b/ems-system/src/main/java/com/xzzn/ems/mapper/EmsPcsAlarmDataMapper.java @@ -0,0 +1,61 @@ +package com.xzzn.ems.mapper; + +import java.util.List; +import com.xzzn.ems.domain.EmsPcsAlarmData; + +/** + * pcs设备告警故障数据Mapper接口 + * + * @author xzzn + * @date 2025-10-22 + */ +public interface EmsPcsAlarmDataMapper +{ + /** + * 查询pcs设备告警故障数据 + * + * @param id pcs设备告警故障数据主键 + * @return pcs设备告警故障数据 + */ + public EmsPcsAlarmData selectEmsPcsAlarmDataById(Long id); + + /** + * 查询pcs设备告警故障数据列表 + * + * @param emsPcsAlarmData pcs设备告警故障数据 + * @return pcs设备告警故障数据集合 + */ + public List selectEmsPcsAlarmDataList(EmsPcsAlarmData emsPcsAlarmData); + + /** + * 新增pcs设备告警故障数据 + * + * @param emsPcsAlarmData pcs设备告警故障数据 + * @return 结果 + */ + public int insertEmsPcsAlarmData(EmsPcsAlarmData emsPcsAlarmData); + + /** + * 修改pcs设备告警故障数据 + * + * @param emsPcsAlarmData pcs设备告警故障数据 + * @return 结果 + */ + public int updateEmsPcsAlarmData(EmsPcsAlarmData emsPcsAlarmData); + + /** + * 删除pcs设备告警故障数据 + * + * @param id pcs设备告警故障数据主键 + * @return 结果 + */ + public int deleteEmsPcsAlarmDataById(Long id); + + /** + * 批量删除pcs设备告警故障数据 + * + * @param ids 需要删除的数据主键集合 + * @return 结果 + */ + public int deleteEmsPcsAlarmDataByIds(Long[] ids); +} diff --git a/ems-system/src/main/java/com/xzzn/ems/mapper/EmsStackAlarmDataMapper.java b/ems-system/src/main/java/com/xzzn/ems/mapper/EmsStackAlarmDataMapper.java new file mode 100644 index 0000000..0c398a5 --- /dev/null +++ b/ems-system/src/main/java/com/xzzn/ems/mapper/EmsStackAlarmDataMapper.java @@ -0,0 +1,61 @@ +package com.xzzn.ems.mapper; + +import java.util.List; +import com.xzzn.ems.domain.EmsStackAlarmData; + +/** + * bmsd告警数据Mapper接口 + * + * @author xzzn + * @date 2025-10-22 + */ +public interface EmsStackAlarmDataMapper +{ + /** + * 查询bmsd告警数据 + * + * @param id bmsd告警数据主键 + * @return bmsd告警数据 + */ + public EmsStackAlarmData selectEmsStackAlarmDataById(Long id); + + /** + * 查询bmsd告警数据列表 + * + * @param emsStackAlarmData bmsd告警数据 + * @return bmsd告警数据集合 + */ + public List selectEmsStackAlarmDataList(EmsStackAlarmData emsStackAlarmData); + + /** + * 新增bmsd告警数据 + * + * @param emsStackAlarmData bmsd告警数据 + * @return 结果 + */ + public int insertEmsStackAlarmData(EmsStackAlarmData emsStackAlarmData); + + /** + * 修改bmsd告警数据 + * + * @param emsStackAlarmData bmsd告警数据 + * @return 结果 + */ + public int updateEmsStackAlarmData(EmsStackAlarmData emsStackAlarmData); + + /** + * 删除bmsd告警数据 + * + * @param id bmsd告警数据主键 + * @return 结果 + */ + public int deleteEmsStackAlarmDataById(Long id); + + /** + * 批量删除bmsd告警数据 + * + * @param ids 需要删除的数据主键集合 + * @return 结果 + */ + public int deleteEmsStackAlarmDataByIds(Long[] ids); +} diff --git a/ems-system/src/main/java/com/xzzn/ems/service/IFXXAlarmDataProcessService.java b/ems-system/src/main/java/com/xzzn/ems/service/IFXXAlarmDataProcessService.java new file mode 100644 index 0000000..ad949e1 --- /dev/null +++ b/ems-system/src/main/java/com/xzzn/ems/service/IFXXAlarmDataProcessService.java @@ -0,0 +1,6 @@ +package com.xzzn.ems.service; + +public interface IFXXAlarmDataProcessService { + + public void handleFxAlarmData(String message); +} diff --git a/ems-system/src/main/java/com/xzzn/ems/service/IFXXDataProcessService.java b/ems-system/src/main/java/com/xzzn/ems/service/IFXXDataProcessService.java index bdf80fb..c9610c7 100644 --- a/ems-system/src/main/java/com/xzzn/ems/service/IFXXDataProcessService.java +++ b/ems-system/src/main/java/com/xzzn/ems/service/IFXXDataProcessService.java @@ -3,6 +3,4 @@ package com.xzzn.ems.service; public interface IFXXDataProcessService { public void handleFxData(String message); - - public void handleFxAlarmData(String message); } diff --git a/ems-system/src/main/java/com/xzzn/ems/service/impl/FXXAlarmDataProcessServiceImpl.java b/ems-system/src/main/java/com/xzzn/ems/service/impl/FXXAlarmDataProcessServiceImpl.java new file mode 100644 index 0000000..fc20b79 --- /dev/null +++ b/ems-system/src/main/java/com/xzzn/ems/service/impl/FXXAlarmDataProcessServiceImpl.java @@ -0,0 +1,634 @@ +package com.xzzn.ems.service.impl; + +import com.alibaba.fastjson2.JSON; +import com.alibaba.fastjson2.JSONArray; +import com.alibaba.fastjson2.JSONObject; +import com.alibaba.fastjson2.TypeReference; +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.xzzn.common.constant.RedisKeyConstants; +import com.xzzn.common.core.redis.RedisCache; +import com.xzzn.common.enums.*; +import com.xzzn.common.utils.DateUtils; +import com.xzzn.common.utils.MapUtils; +import com.xzzn.common.utils.StringUtils; +import com.xzzn.ems.domain.*; +import com.xzzn.ems.mapper.EmsClusterAlarmDataMapper; +import com.xzzn.ems.mapper.EmsCoolingAlarmDataMapper; +import com.xzzn.ems.mapper.EmsPcsAlarmDataMapper; +import com.xzzn.ems.mapper.EmsStackAlarmDataMapper; +import com.xzzn.ems.service.IEmsAlarmRecordsService; +import com.xzzn.ems.service.IFXXAlarmDataProcessService; +import com.xzzn.ems.utils.AbstractBatteryDataProcessor; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; + +import java.util.*; +import java.util.stream.Collectors; + +@Service +public class FXXAlarmDataProcessServiceImpl extends AbstractBatteryDataProcessor implements IFXXAlarmDataProcessService { + private static final Log log = LogFactory.getLog(FXXAlarmDataProcessServiceImpl.class); + private static final String SITE_ID = "021_FXX_01"; + + @Autowired + private RedisCache redisCache; + + @Autowired + private IEmsAlarmRecordsService iEmsAlarmRecordsService; + @Autowired + private EmsCoolingAlarmDataMapper emsCoolingAlarmDataMapper; + @Autowired + private EmsStackAlarmDataMapper emsStackAlarmDataMapper; + @Autowired + private EmsClusterAlarmDataMapper emsClusterAlarmDataMapper; + @Autowired + private EmsPcsAlarmDataMapper emsPcsAlarmDataMapper; + + // 构造方法（调用父类构造） + public FXXAlarmDataProcessServiceImpl(ObjectMapper objectMapper) { + super(objectMapper); + } + + @Override + public void handleFxAlarmData(String message) { + JSONArray arraylist = JSONArray.parseArray(message); + + // 获取redis缓存-告警信息 + Map alarmMatchInfo= redisCache.getCacheObject(RedisKeyConstants.ALARM_MATCH_INFO); + + for (int i = 0; i < arraylist.size(); i++) { + JSONObject obj = JSONObject.parseObject(arraylist.get(i).toString()); + + String deviceId = obj.get("Device").toString(); + String jsonData = obj.get("Data").toString(); + Long timestamp = Long.valueOf(obj.get("timestamp").toString()); + Date dataUpdateTime = DateUtils.convertUpdateTime(timestamp); + + log.info("deviceId:" + deviceId); + String deviceCategory = ""; + if (deviceId.contains("ZSLQ")) { + coolingDataProcess(deviceId, jsonData, dataUpdateTime); + } else if (deviceId.contains("BMSD")) { + deviceCategory = DeviceCategory.STACK.getCode(); + stackDataProcess(deviceId, jsonData, dataUpdateTime); + } else if (deviceId.contains("BMSC")) { + deviceCategory = DeviceCategory.CLUSTER.getCode(); + clusterDataProcess(deviceId, jsonData, dataUpdateTime); + } else if (deviceId.contains("PCS")) { + deviceCategory = DeviceCategory.PCS.getCode(); + pcsDataProcess(deviceId, jsonData, dataUpdateTime); + } + if (StringUtils.isEmpty(deviceCategory)) { + // 处理告警信息 + alarmDataProcess(deviceId, jsonData, alarmMatchInfo, deviceCategory); + } + } + } + + private void pcsDataProcess(String deviceId, String jsonData, Date dataUpdateTime) { + //中水冷却 + Map obj = JSON.parseObject(jsonData, new TypeReference>() { + }); + EmsPcsAlarmData pcsAlarmData = new EmsPcsAlarmData(); + // 更新时间 + pcsAlarmData.setDataTimestamp(dataUpdateTime); + + // 告警字段 + pcsAlarmData.setYljzyc(MapUtils.getInteger(obj, "YLJZYC")); + pcsAlarmData.setZlkgSmyc(MapUtils.getInteger(obj, "ZLKGSMYC")); + pcsAlarmData.setJlkgSmyc(MapUtils.getInteger(obj, "JLKGSMYC")); + pcsAlarmData.setZlfjsmyc(MapUtils.getInteger(obj, "ZLFJSMYC")); + pcsAlarmData.setJlfjsmyc(MapUtils.getInteger(obj, "JLFJSMYC")); + pcsAlarmData.setGjz2(MapUtils.getInteger(obj, "GJZ2")); + pcsAlarmData.setGzz2(MapUtils.getInteger(obj, "GZZ2")); + pcsAlarmData.setSrqgwgj(MapUtils.getInteger(obj, "SRQGWGJ")); + pcsAlarmData.setDgfjyc(MapUtils.getInteger(obj, "DGFJYC")); + pcsAlarmData.setBmsgj(MapUtils.getInteger(obj, "BMSGJ")); + pcsAlarmData.setBmsdj(MapUtils.getInteger(obj, "BMSDJ")); + pcsAlarmData.setBmsjf(MapUtils.getInteger(obj, "BMSJF")); + pcsAlarmData.setBmsjc(MapUtils.getInteger(obj, "BMSJC")); + pcsAlarmData.setBmsgjdyc(MapUtils.getInteger(obj, "BMSGJDYC")); + pcsAlarmData.setBmstxyc(MapUtils.getInteger(obj, "BMSTXYC")); + pcsAlarmData.setBmsxtgz(MapUtils.getInteger(obj, "BMSXTGZ")); + pcsAlarmData.setZldhmktxyc(MapUtils.getInteger(obj, "ZLDHMKTXYC")); + pcsAlarmData.setGzgJ(MapUtils.getInteger(obj, "GZGJ")); + pcsAlarmData.setDcdybfhcdtj(MapUtils.getInteger(obj, "DCDYBFHCDTJ")); + pcsAlarmData.setDcfj(MapUtils.getInteger(obj, "DCFJ")); + pcsAlarmData.setWbfjyc(MapUtils.getInteger(obj, "WBFJYC")); + pcsAlarmData.setDcdygj(MapUtils.getInteger(obj, "DCDYGJ")); + pcsAlarmData.setDczzqy(MapUtils.getInteger(obj, "DCZZQY")); + pcsAlarmData.setZlbxsyc(MapUtils.getInteger(obj, "ZLBXSYC")); + pcsAlarmData.setNbfjyc(MapUtils.getInteger(obj, "NBFJYC")); + pcsAlarmData.setDlbh(MapUtils.getInteger(obj, "DLBH")); + pcsAlarmData.setGzbh(MapUtils.getInteger(obj, "GZBH")); + pcsAlarmData.setScdybfhlwtj(MapUtils.getInteger(obj, "SCDYBFHLWTJ")); + pcsAlarmData.setScdyyc(MapUtils.getInteger(obj, "SCDYYC")); + pcsAlarmData.setZlgl(MapUtils.getInteger(obj, "ZLGL")); + pcsAlarmData.setDcqzqy(MapUtils.getInteger(obj, "DCQZQY")); + pcsAlarmData.setDcgy(MapUtils.getInteger(obj, "DCGY")); + pcsAlarmData.setGlmkgwgJ(MapUtils.getInteger(obj, "GLMKGWGJ")); + pcsAlarmData.setDwgqpdjgj(MapUtils.getInteger(obj, "DWGQPDJGJ")); + pcsAlarmData.setKkhrqyc(MapUtils.getInteger(obj, "KKHRQYC")); + pcsAlarmData.setBmsjt(MapUtils.getInteger(obj, "BMSJT")); + pcsAlarmData.setBwjdvc(MapUtils.getInteger(obj, "BWJDYC")); + pcsAlarmData.setJljdvc(MapUtils.getInteger(obj, "JLJDYC")); + pcsAlarmData.setFjjdvc(MapUtils.getInteger(obj, "FJJDYC")); + pcsAlarmData.setZjjdvc(MapUtils.getInteger(obj, "ZJJDYC")); + pcsAlarmData.setDgwdkgwc(MapUtils.getInteger(obj, "DGWDKGYC")); + pcsAlarmData.setFybyqwdkgwc(MapUtils.getInteger(obj, "FYBYQWDKGYC")); + pcsAlarmData.setWbwdkgwc(MapUtils.getInteger(obj, "WBWDKGYC")); + pcsAlarmData.setSrqwdkgwc(MapUtils.getInteger(obj, "SRQWDKGYC")); + pcsAlarmData.setZlfjyc(MapUtils.getInteger(obj, "ZLFJYC")); + pcsAlarmData.setGdycyyx(MapUtils.getInteger(obj, "GDYCYYX")); + pcsAlarmData.setDdycyyx(MapUtils.getInteger(obj, "DDYCYYX")); + pcsAlarmData.setDwdybphgj(MapUtils.getInteger(obj, "DWDYBPHGJ")); + pcsAlarmData.setXtcsbpp(MapUtils.getInteger(obj, "XTCSBPP")); + pcsAlarmData.setZlblmsszcw(MapUtils.getInteger(obj, "ZLBLMSSZCW")); + pcsAlarmData.setGjz(MapUtils.getInteger(obj, "GJZ")); + pcsAlarmData.setGzz(MapUtils.getInteger(obj, "GZZ")); + pcsAlarmData.setYctxyc(MapUtils.getInteger(obj, "YCTXYC")); + pcsAlarmData.setHmi485txyc(MapUtils.getInteger(obj, "HMI485TXYC")); + pcsAlarmData.setJxszcw(MapUtils.getInteger(obj, "JXSZCW")); + pcsAlarmData.setHmictxyc(MapUtils.getInteger(obj, "HMICTXYC")); + pcsAlarmData.setBjtxyc(MapUtils.getInteger(obj, "BJTXYC")); + pcsAlarmData.setYwgj(MapUtils.getInteger(obj, "YWGJ")); + pcsAlarmData.setZlzjcqyc(MapUtils.getInteger(obj, "ZLZJCQYC")); + pcsAlarmData.setLxgl(MapUtils.getInteger(obj, "LXGL")); + pcsAlarmData.setZldhyc(MapUtils.getInteger(obj, "ZLDHYC")); + pcsAlarmData.setTbctxvc(MapUtils.getInteger(obj, "TBCTXYC")); + pcsAlarmData.setBjtxxyc(MapUtils.getInteger(obj, "BJTXXYC")); + pcsAlarmData.setXxgxctxvc(MapUtils.getInteger(obj, "XXGXCTXYC")); + pcsAlarmData.setIdct(MapUtils.getInteger(obj, "IDCT")); + pcsAlarmData.setQdyc(MapUtils.getInteger(obj, "QDYC")); + pcsAlarmData.setNbyjgl(MapUtils.getInteger(obj, "NBYJGL")); + pcsAlarmData.setZndbtxyc(MapUtils.getInteger(obj, "ZNDBTXYC")); + pcsAlarmData.setZlflqyc(MapUtils.getInteger(obj, "ZLFLQYC")); + pcsAlarmData.setSxyc(MapUtils.getInteger(obj, "SXYC")); + pcsAlarmData.setMjgj(MapUtils.getInteger(obj, "MJGJ")); + pcsAlarmData.setLpjzyc(MapUtils.getInteger(obj, "LPJZYC")); + pcsAlarmData.setMxdlgl(MapUtils.getInteger(obj, "MXDLGL")); + pcsAlarmData.setMxdbyfhkjtj(MapUtils.getInteger(obj, "MXDYBFHKJTJ")); + pcsAlarmData.setWbjt(MapUtils.getInteger(obj, "WBJT")); + pcsAlarmData.setNbjt(MapUtils.getInteger(obj, "NBJT")); + pcsAlarmData.setJlflqyc(MapUtils.getInteger(obj, "JLFLQYC")); + pcsAlarmData.setRjhjyc(MapUtils.getInteger(obj, "RJHJYC")); + pcsAlarmData.setJlrqdyc(MapUtils.getInteger(obj, "JLRQDYC")); + pcsAlarmData.setJngw(MapUtils.getInteger(obj, "JNGW")); + pcsAlarmData.setNbyc(MapUtils.getInteger(obj, "NBYC")); + pcsAlarmData.setWdkgwc(MapUtils.getInteger(obj, "WDKGYC")); + pcsAlarmData.setJlkgwc(MapUtils.getInteger(obj, "JLKGYC")); + pcsAlarmData.setJlfjyc(MapUtils.getInteger(obj, "JLFJYC")); + pcsAlarmData.setZlkgwc(MapUtils.getInteger(obj, "ZLKGYC")); + pcsAlarmData.setZlrqdyc(MapUtils.getInteger(obj, "ZLRQDYC")); + pcsAlarmData.setNbrjgl(MapUtils.getInteger(obj, "NBRJGL")); + pcsAlarmData.setDwxxyc(MapUtils.getInteger(obj, "DWXXYC")); + pcsAlarmData.setGlmkgw(MapUtils.getInteger(obj, "GLMKGW")); + pcsAlarmData.setDwqpyc(MapUtils.getInteger(obj, "DWQPYC")); + pcsAlarmData.setDwgpyc(MapUtils.getInteger(obj, "DWGPYC")); + pcsAlarmData.setDwqyyc(MapUtils.getInteger(obj, "DWQYYC")); + pcsAlarmData.setDwgyyc(MapUtils.getInteger(obj, "DWGYYC")); + pcsAlarmData.setZlgv(MapUtils.getInteger(obj, "ZLGY")); + pcsAlarmData.setJlllyc(MapUtils.getInteger(obj, "JLLDLYC")); + pcsAlarmData.setJyzkyc(MapUtils.getInteger(obj, "JYZKYC")); + pcsAlarmData.setGzbz(MapUtils.getInteger(obj, "GZBZ")); + pcsAlarmData.setCreateBy("system"); + pcsAlarmData.setCreateTime(DateUtils.getNowDate()); + pcsAlarmData.setUpdateBy("system"); + pcsAlarmData.setUpdateTime(DateUtils.getNowDate()); + pcsAlarmData.setSiteId(SITE_ID); + pcsAlarmData.setDeviceId(deviceId); + emsPcsAlarmDataMapper.insertEmsPcsAlarmData(pcsAlarmData); + } + + private void stackDataProcess(String deviceId, String jsonData, Date dataUpdateTime) { + // bmsd + Map obj = JSON.parseObject(jsonData, new TypeReference>() { + }); + EmsStackAlarmData stackAlarmData = new EmsStackAlarmData(); + // 更新时间 + stackAlarmData.setDataTimestamp(dataUpdateTime); + + // 告警字段 + stackAlarmData.setKttxsl(MapUtils.getInteger(obj, "KTTXSL")); + stackAlarmData.setDidodi12(MapUtils.getInteger(obj, "DIDODI12")); + stackAlarmData.setDidodi11(MapUtils.getInteger(obj, "DIDODI11")); + stackAlarmData.setDidodi10(MapUtils.getInteger(obj, "DIDODI10")); + stackAlarmData.setDidodi9(MapUtils.getInteger(obj, "DIDODI9")); + stackAlarmData.setDidodi8(MapUtils.getInteger(obj, "DIDODI8")); + stackAlarmData.setDidodi7(MapUtils.getInteger(obj, "DIDODI7")); + stackAlarmData.setDidodi6(MapUtils.getInteger(obj, "DIDODI6")); + stackAlarmData.setDidodi5(MapUtils.getInteger(obj, "DIDODI5")); + stackAlarmData.setDidodi4(MapUtils.getInteger(obj, "DIDODI4")); + stackAlarmData.setDidodi3(MapUtils.getInteger(obj, "DIDODI3")); + stackAlarmData.setDidodi2(MapUtils.getInteger(obj, "DIDODI2")); + stackAlarmData.setDidodi1(MapUtils.getInteger(obj, "DIDODI1")); + stackAlarmData.setDidodi0(MapUtils.getInteger(obj, "DIDODI0")); + stackAlarmData.setWdcjsl(MapUtils.getInteger(obj, "WDCJSL")); + stackAlarmData.setDycjsl(MapUtils.getInteger(obj, "DYCJSL")); + stackAlarmData.setDnmkdyqyyzgjhz(MapUtils.getInteger(obj, "DNMKDYQYYZGJHZ")); + stackAlarmData.setDnmkdyqyzdgjhz(MapUtils.getInteger(obj, "DNMKDYQYZDGJHZ")); + stackAlarmData.setDnmkdyqyqwgjhz(MapUtils.getInteger(obj, "DNMKDYQYQWGJHZ")); + stackAlarmData.setDnmkdygyyzgjhz(MapUtils.getInteger(obj, "DNMKDYGYYZGJHZ")); + stackAlarmData.setDnmkdygyzdgjhz(MapUtils.getInteger(obj, "DNMKDYGYZDGJHZ")); + stackAlarmData.setDnmkdygyqwgjhz(MapUtils.getInteger(obj, "DNMKDYGYQWGJHZ")); + stackAlarmData.setDngdzgwzzdgjhz(MapUtils.getInteger(obj, "DNGDZGWZZDGJHZ")); + stackAlarmData.setDngdzgwzdgjhz(MapUtils.getInteger(obj, "DNGDZGWZDGJHZ")); + stackAlarmData.setDngdzgwqwgjhz(MapUtils.getInteger(obj, "DNGDZGWQWGJHZ")); + stackAlarmData.setYl8(MapUtils.getInteger(obj, "YL8")); + stackAlarmData.setYl7(MapUtils.getInteger(obj, "YL7")); + stackAlarmData.setYl6(MapUtils.getInteger(obj, "YL6")); + stackAlarmData.setYl5(MapUtils.getInteger(obj, "YL5")); + stackAlarmData.setYl4(MapUtils.getInteger(obj, "YL4")); + stackAlarmData.setYl3(MapUtils.getInteger(obj, "YL3")); + stackAlarmData.setYl2(MapUtils.getInteger(obj, "YL2")); + stackAlarmData.setYl1(MapUtils.getInteger(obj, "YL1")); + stackAlarmData.setSrin3(MapUtils.getInteger(obj, "SRIN3")); + stackAlarmData.setSrin2(MapUtils.getInteger(obj, "SRIN2")); + stackAlarmData.setSrin1(MapUtils.getInteger(obj, "SRIN1")); + stackAlarmData.setSrin0(MapUtils.getInteger(obj, "SRIN0")); + stackAlarmData.setBmsxtgzhz(MapUtils.getInteger(obj, "BMSXTGZHZ")); + stackAlarmData.setBmsxtgjhz(MapUtils.getInteger(obj, "BMSXTGJHZ")); + stackAlarmData.setFdjz(MapUtils.getInteger(obj, "FDJZ")); + stackAlarmData.setCdjz(MapUtils.getInteger(obj, "CDJZ")); + stackAlarmData.setDnjcqbhyc(MapUtils.getInteger(obj, "DNJCQBHYC")); + stackAlarmData.setDnjcqdkyc(MapUtils.getInteger(obj, "DNJCQDKYC")); + stackAlarmData.setDngzdyyc(MapUtils.getInteger(obj, "DNGZDYYC")); + stackAlarmData.setDngckslgjhz(MapUtils.getInteger(obj, "DNGCKSLGJHZ")); + stackAlarmData.setDngzkslhz(MapUtils.getInteger(obj, "DNGZKSLHZ")); + stackAlarmData.setDtsohgyzgjhz(MapUtils.getInteger(obj, "DTSOHGYZGJHZ")); + stackAlarmData.setDtsohgzdgjhz(MapUtils.getInteger(obj, "DTSOHGZDGJHZ")); + stackAlarmData.setDtsohgqwgjhz(MapUtils.getInteger(obj, "DTSOHGQWGJHZ")); + stackAlarmData.setDtsohdyzgjhz(MapUtils.getInteger(obj, "DTSOHDYZGJHZ")); + stackAlarmData.setDtsohdzdgjhz(MapUtils.getInteger(obj, "DTSOHDZDGJHZ")); + stackAlarmData.setDtsohdqwgjhz(MapUtils.getInteger(obj, "DTSOHDQWGJHZ")); + stackAlarmData.setDtsocgyzgjhz(MapUtils.getInteger(obj, "DTSOCGYZGJHZ")); + stackAlarmData.setDtsocgzdgjhz(MapUtils.getInteger(obj, "DTSOCGZDGJHZ")); + stackAlarmData.setDtsocgqwgjhz(MapUtils.getInteger(obj, "DTSOCGQWGJHZ")); + stackAlarmData.setDtsocdyzgjhz(MapUtils.getInteger(obj, "DTSOCDYZGJHZ")); + stackAlarmData.setDtsocdzdgjhz(MapUtils.getInteger(obj, "DTSOCDZDGJHZ")); + stackAlarmData.setDtsocdqwgjhz(MapUtils.getInteger(obj, "DTSOCDQWGJHZ")); + stackAlarmData.setDngdtwcyzgjhz(MapUtils.getInteger(obj, "DNGDTWCYZGJHZ")); + stackAlarmData.setDngdtwczdgjhz(MapUtils.getInteger(obj, "DNGDTWCZDGJHZ")); + stackAlarmData.setDngdtwcqwgjhz(MapUtils.getInteger(obj, "DNGDTWCQWGJHZ")); + stackAlarmData.setDngdtgwyzgjhz(MapUtils.getInteger(obj, "DNGDTGWYZGJHZ")); + stackAlarmData.setDngdtgwzdgjhz(MapUtils.getInteger(obj, "DNGDTGWZDGJHZ")); + stackAlarmData.setDngdtgwqwgjhz(MapUtils.getInteger(obj, "DNGDTGWQWGJHZ")); + stackAlarmData.setDngdtqwyzgjhz(MapUtils.getInteger(obj, "DNGDTQWYZGJHZ")); + stackAlarmData.setDngdtqwzdgjhz(MapUtils.getInteger(obj, "DNGDTQWZDGJHZ")); + stackAlarmData.setDngdtqwqwgjhz(MapUtils.getInteger(obj, "DNGDTQWQWGJHZ")); + stackAlarmData.setDngdtycyzgjhz(MapUtils.getInteger(obj, "DNGDTYCYZGJHZ")); + stackAlarmData.setDngdtyczdgjhz(MapUtils.getInteger(obj, "DNGDTYCZDGJHZ")); + stackAlarmData.setDngdtycqwgjhz(MapUtils.getInteger(obj, "DNGDTYCQWGJHZ")); + stackAlarmData.setDngdtqyyzgjhz(MapUtils.getInteger(obj, "DNGDTQYYZGJHZ")); + stackAlarmData.setDngdtqyzdgjhz(MapUtils.getInteger(obj, "DNGDTQYZDGJHZ")); + stackAlarmData.setDngdtqyqwgjhz(MapUtils.getInteger(obj, "DNGDTQYQWGJHZ")); + stackAlarmData.setDngdtgyyzgjhz(MapUtils.getInteger(obj, "DNGDTGYYZGJHZ")); + stackAlarmData.setDngdtgyzdgjhz(MapUtils.getInteger(obj, "DNGDTGYZDGJHZ")); + stackAlarmData.setDngdtgyqwgjhz(MapUtils.getInteger(obj, "DNGDTGYQWGJHZ")); + stackAlarmData.setDngzmkgwdzzdgjhz(MapUtils.getInteger(obj, "DNGZMKGWDZZDGJHZ")); + stackAlarmData.setDngzmkgwdzdgjhz(MapUtils.getInteger(obj, "DNGZMKGWDZDGJHZ")); + stackAlarmData.setDngzmkgwdqdgjhz(MapUtils.getInteger(obj, "DNGZMKGWDQDGJHZ")); + stackAlarmData.setDngzmkqwdzzdgjhz(MapUtils.getInteger(obj, "DNGZMKQWDZZDGJHZ")); + stackAlarmData.setDngzmkqwdzdgjhz(MapUtils.getInteger(obj, "DNGZMKQWDZDGJHZ")); + stackAlarmData.setDngzmkqwdqdgjhz(MapUtils.getInteger(obj, "DNGZMKQWDQDGJHZ")); + stackAlarmData.setDngzjydzdzzdgjhz(MapUtils.getInteger(obj, "DNGZJYDZDZZDGJHZ")); + stackAlarmData.setDngzjydzdzdgjhz(MapUtils.getInteger(obj, "DNGZJYDZDZDGJHZ")); + stackAlarmData.setDngzjydzdqdgjhz(MapUtils.getInteger(obj, "DNGZJYDZDQDGJHZ")); + stackAlarmData.setDngzdglzzdgjhz(MapUtils.getInteger(obj, "DNGZDGLZZDGJHZ")); + stackAlarmData.setDngzdglzdgjhz(MapUtils.getInteger(obj, "DNGZDGLZDGJHZ")); + stackAlarmData.setDngzdglqdgjhz(MapUtils.getInteger(obj, "DNGZDGLQDGJHZ")); + stackAlarmData.setDngzddygyzzdgjhz(MapUtils.getInteger(obj, "DNGZDDYGYZZDGJHZ")); + stackAlarmData.setDngzddygyzdgjhz(MapUtils.getInteger(obj, "DNGZDDYGYZDGJHZ")); + stackAlarmData.setDngzddygyqdgjhz(MapUtils.getInteger(obj, "DNGZDDYGYQDGJHZ")); + stackAlarmData.setDngzddyqyzzdgjhz(MapUtils.getInteger(obj, "DNGZDDYQYZZDGJHZ")); + stackAlarmData.setDngzddyqyzdgjhz(MapUtils.getInteger(obj, "DNGZDDYQYZDGJHZ")); + stackAlarmData.setDngzddyqyqdgjhz(MapUtils.getInteger(obj, "DNGZDDYQYQDGJHZ")); + stackAlarmData.setJfzt(MapUtils.getInteger(obj, "JFZT")); + stackAlarmData.setJczt(MapUtils.getInteger(obj, "JCZT")); + stackAlarmData.setBmsgzzt(MapUtils.getInteger(obj, "BMSGZZT")); + + stackAlarmData.setCreateBy("system"); + stackAlarmData.setCreateTime(DateUtils.getNowDate()); + stackAlarmData.setUpdateBy("system"); + stackAlarmData.setUpdateTime(DateUtils.getNowDate()); + stackAlarmData.setSiteId(SITE_ID); + stackAlarmData.setDeviceId(deviceId); + emsStackAlarmDataMapper.insertEmsStackAlarmData(stackAlarmData); + } + + private void clusterDataProcess(String deviceId, String jsonData, Date dataUpdateTime) { + // bmsc + Map obj = JSON.parseObject(jsonData, new TypeReference>() { + }); + EmsClusterAlarmData clusterAlarmData = new EmsClusterAlarmData(); + // 更新时间 + clusterAlarmData.setDataTimestamp(dataUpdateTime); + + // 告警字段 + clusterAlarmData.setC1wdcjgz(MapUtils.getInteger(obj, "C1WDCJGZ")); + clusterAlarmData.setC1dycjgz(MapUtils.getInteger(obj, "C1DYCJGZ")); + clusterAlarmData.setC1mkdygdzzdgj(MapUtils.getInteger(obj, "C1MKDYGDZZDGJ")); + clusterAlarmData.setC1mkdygdzdgj(MapUtils.getInteger(obj, "C1MKDYGDZDGJ")); + clusterAlarmData.setC1mkdygdqdgj(MapUtils.getInteger(obj, "C1MKDYGDQDGJ")); + clusterAlarmData.setC1mkdyggzzdgj(MapUtils.getInteger(obj, "C1MKDYGGZZDGJ")); + clusterAlarmData.setC1mkdyggzdgj(MapUtils.getInteger(obj, "C1MKDYGGZDGJ")); + clusterAlarmData.setC1mkdyggqdgj(MapUtils.getInteger(obj, "C1MKDYGGQDGJ")); + clusterAlarmData.setC1dzwdggzzdgj(MapUtils.getInteger(obj, "C1DZWDGGZZDGJ")); + clusterAlarmData.setC1dzwdggzdgj(MapUtils.getInteger(obj, "C1DZWDGGZDGJ")); + clusterAlarmData.setC1dzwdggqdgj(MapUtils.getInteger(obj, "C1DZWDGGQDGJ")); + clusterAlarmData.setC1ck40txsl(MapUtils.getInteger(obj, "C1CK40TXSL")); + clusterAlarmData.setC1ck39txsl(MapUtils.getInteger(obj, "C1CK39TXSL")); + clusterAlarmData.setC1ck38txsl(MapUtils.getInteger(obj, "C1CK38TXSL")); + clusterAlarmData.setC1ck37txsl(MapUtils.getInteger(obj, "C1CK37TXSL")); + clusterAlarmData.setC1ck36txsl(MapUtils.getInteger(obj, "C1CK36TXSL")); + clusterAlarmData.setC1ck35txsl(MapUtils.getInteger(obj, "C1CK35TXSL")); + clusterAlarmData.setC1ck34txsl(MapUtils.getInteger(obj, "C1CK34TXSL")); + clusterAlarmData.setC1ck33txsl(MapUtils.getInteger(obj, "C1CK33TXSL")); + clusterAlarmData.setC1ck32txsl(MapUtils.getInteger(obj, "C1CK32TXSL")); + clusterAlarmData.setC1ck31txsl(MapUtils.getInteger(obj, "C1CK31TXSL")); + clusterAlarmData.setC1ck30txsl(MapUtils.getInteger(obj, "C1CK30TXSL")); + clusterAlarmData.setC1ck29txsl(MapUtils.getInteger(obj, "C1CK29TXSL")); + clusterAlarmData.setC1ck28txsl(MapUtils.getInteger(obj, "C1CK28TXSL")); + clusterAlarmData.setC1ck27txsl(MapUtils.getInteger(obj, "C1CK27TXSL")); + clusterAlarmData.setC1ck26txsl(MapUtils.getInteger(obj, "C1CK26TXSL")); + clusterAlarmData.setC1ck25txsl(MapUtils.getInteger(obj, "C1CK25TXSL")); + clusterAlarmData.setC1ck24txsl(MapUtils.getInteger(obj, "C1CK24TXSL")); + clusterAlarmData.setC1ck23txsl(MapUtils.getInteger(obj, "C1CK23TXSL")); + clusterAlarmData.setC1ck22txsl(MapUtils.getInteger(obj, "C1CK22TXSL")); + clusterAlarmData.setC1ck21txsl(MapUtils.getInteger(obj, "C1CK21TXSL")); + clusterAlarmData.setC1ck20txsl(MapUtils.getInteger(obj, "C1CK20TXSL")); + clusterAlarmData.setC1ck19txsl(MapUtils.getInteger(obj, "C1CK19TXSL")); + clusterAlarmData.setC1ck18txsl(MapUtils.getInteger(obj, "C1CK18TXSL")); + clusterAlarmData.setC1ck17txsl(MapUtils.getInteger(obj, "C1CK17TXSL")); + clusterAlarmData.setC1ck16txsl(MapUtils.getInteger(obj, "C1CK16TXSL")); + clusterAlarmData.setC1ck15txsl(MapUtils.getInteger(obj, "C1CK15TXSL")); + clusterAlarmData.setC1ck14txsl(MapUtils.getInteger(obj, "C1CK14TXSL")); + clusterAlarmData.setC1ck13txsl(MapUtils.getInteger(obj, "C1CK13TXSL")); + clusterAlarmData.setC1ck12txsl(MapUtils.getInteger(obj, "C1CK12TXSL")); + clusterAlarmData.setC1ck11txsl(MapUtils.getInteger(obj, "C1CK11TXSL")); + clusterAlarmData.setC1ck10txsl(MapUtils.getInteger(obj, "C1CK10TXSL")); + clusterAlarmData.setC1ck9txsl(MapUtils.getInteger(obj, "C1CK9TXSL")); + clusterAlarmData.setC1ck8txsl(MapUtils.getInteger(obj, "C1CK8TXSL")); + clusterAlarmData.setC1ck7txsl(MapUtils.getInteger(obj, "C1CK7TXSL")); + clusterAlarmData.setC1ck6txsl(MapUtils.getInteger(obj, "C1CK6TXSL")); + clusterAlarmData.setC1ck5txsl(MapUtils.getInteger(obj, "C1CK5TXSL")); + clusterAlarmData.setC1ck4txsl(MapUtils.getInteger(obj, "C1CK4TXSL")); + clusterAlarmData.setC1ck3txsl(MapUtils.getInteger(obj, "C1CK3TXSL")); + clusterAlarmData.setC1ck2txsl(MapUtils.getInteger(obj, "C1CK2TXSL")); + clusterAlarmData.setC1ck1txsl(MapUtils.getInteger(obj, "C1CK1TXSL")); + clusterAlarmData.setC1dtwczzdgj(MapUtils.getInteger(obj, "C1DTWCZZDGJ")); + clusterAlarmData.setC1dtwczdgj(MapUtils.getInteger(obj, "C1DTWCZDGJ")); + clusterAlarmData.setC1dtwcqdgj(MapUtils.getInteger(obj, "C1DTWCQDGJ")); + clusterAlarmData.setC1dtyczzdgj(MapUtils.getInteger(obj, "C1DTYCZZDGJ")); + clusterAlarmData.setC1dtyczdgj(MapUtils.getInteger(obj, "C1DTYCZDGJ")); + clusterAlarmData.setC1dtycqdgj(MapUtils.getInteger(obj, "C1DTYCQDGJ")); + clusterAlarmData.setC1sohdzzdgj(MapUtils.getInteger(obj, "C1SOHDZZDGJ")); + clusterAlarmData.setC1sohdzdgj(MapUtils.getInteger(obj, "C1SOHDZDGJ")); + clusterAlarmData.setC1sohdqdgj(MapUtils.getInteger(obj, "C1SOHDQDGJ")); + clusterAlarmData.setC1socgzzdgj(MapUtils.getInteger(obj, "C1SOCGZZDGJ")); + clusterAlarmData.setC1socgzdgj(MapUtils.getInteger(obj, "C1SOCGZDGJ")); + clusterAlarmData.setC1socdzzdgj(MapUtils.getInteger(obj, "C1SOCDZZDGJ")); + clusterAlarmData.setC1socdzdgj(MapUtils.getInteger(obj, "C1SOCDZDGJ")); + clusterAlarmData.setC1socdqdgj(MapUtils.getInteger(obj, "C1SOCDQDGJ")); + clusterAlarmData.setC1dtgwzzdgj(MapUtils.getInteger(obj, "C1DTGWZZDGJ")); + clusterAlarmData.setC1dtgwzdgj(MapUtils.getInteger(obj, "C1DTGWZDGJ")); + clusterAlarmData.setC1dtgwqdgj(MapUtils.getInteger(obj, "C1DTGWQDGJ")); + clusterAlarmData.setC1dtqwzzdgj(MapUtils.getInteger(obj, "C1DTQWZZDGJ")); + clusterAlarmData.setC1dtqwzdgj(MapUtils.getInteger(obj, "C1DTQWZDGJ")); + clusterAlarmData.setC1dtqwqdgj(MapUtils.getInteger(obj, "C1DTQWQDGJ")); + clusterAlarmData.setC1dtgyzzdgj(MapUtils.getInteger(obj, "C1DTGYZZDGJ")); + clusterAlarmData.setC1dtgyzdgj(MapUtils.getInteger(obj, "C1DTGYZDGJ")); + clusterAlarmData.setC1dtgyqdgj(MapUtils.getInteger(obj, "C1DTGYQDGJ")); + clusterAlarmData.setC1dtqyzzdgj(MapUtils.getInteger(obj, "C1DTQYZZDGJ")); + clusterAlarmData.setC1dtqyzdgj(MapUtils.getInteger(obj, "C1DTQYZDGJ")); + clusterAlarmData.setC1dtqyqdgj(MapUtils.getInteger(obj, "C1DTQYQDGJ")); + clusterAlarmData.setC1ddlzzdgj(MapUtils.getInteger(obj, "C1DDLZZDGJ")); + clusterAlarmData.setC1ddlzdgj(MapUtils.getInteger(obj, "C1DDLZDGJ")); + clusterAlarmData.setC1ddlqdgj(MapUtils.getInteger(obj, "C1DDLQDGJ")); + clusterAlarmData.setC1ddygyzzdgj(MapUtils.getInteger(obj, "C1DDYGYZZDGJ")); + clusterAlarmData.setC1ddygyzdgj(MapUtils.getInteger(obj, "C1DDYGYZDGJ")); + clusterAlarmData.setC1ddygyqdgj(MapUtils.getInteger(obj, "C1DDYGYQDGJ")); + clusterAlarmData.setC1ddyqyzzdgj(MapUtils.getInteger(obj, "C1DDYQYZZDGJ")); + clusterAlarmData.setC1ddyqyzdgj(MapUtils.getInteger(obj, "C1DDYQYZDGJ")); + clusterAlarmData.setC1ddyqyqdgj(MapUtils.getInteger(obj, "C1DDYQYQDGJ")); + clusterAlarmData.setC1zktxsl(MapUtils.getInteger(obj, "C1ZKTXSL")); + clusterAlarmData.setC1socgqdgj(MapUtils.getInteger(obj, "C1SOCGQDGJ")); + + clusterAlarmData.setCreateBy("system"); + clusterAlarmData.setCreateTime(DateUtils.getNowDate()); + clusterAlarmData.setUpdateBy("system"); + clusterAlarmData.setUpdateTime(DateUtils.getNowDate()); + clusterAlarmData.setSiteId(SITE_ID); + clusterAlarmData.setDeviceId(deviceId); + emsClusterAlarmDataMapper.insertEmsClusterAlarmData(clusterAlarmData); + } + + private void coolingDataProcess(String deviceId, String jsonData, Date dataUpdateTime) { + //中水冷却 + Map obj = JSON.parseObject(jsonData, new TypeReference>() { + }); + + EmsCoolingAlarmData coolingAlarmData = new EmsCoolingAlarmData(); + // 更新时间 + coolingAlarmData.setDataTimestamp(dataUpdateTime); + + // 告警字段 + // 从Map中获取值并转为Integer，适配tinyint字段 + coolingAlarmData.setLsjyx(MapUtils.getInteger(obj, "LSJYX")); + coolingAlarmData.setPqdcfyx(MapUtils.getInteger(obj, "PQDCFYX")); + coolingAlarmData.setDjrq2yx(MapUtils.getInteger(obj, "DJRQ2YX")); + coolingAlarmData.setDjrq1yx(MapUtils.getInteger(obj, "DJRQ1YX")); + coolingAlarmData.setBqbyx(MapUtils.getInteger(obj, "BQBYX")); + coolingAlarmData.setBsbyx(MapUtils.getInteger(obj, "BSBYX")); + coolingAlarmData.setZxhbyx(MapUtils.getInteger(obj, "ZXHBYX")); // 此处不再报错 + coolingAlarmData.setSltzgz(MapUtils.getInteger(obj, "SLTZGZ")); + coolingAlarmData.setSlzhyj(MapUtils.getInteger(obj, "SLZHYJ")); + coolingAlarmData.setSlxtyctzxh(MapUtils.getInteger(obj, "SLXTYCTZXH")); + coolingAlarmData.setSlxtycqdxh(MapUtils.getInteger(obj, "SLXTYCQDXH")); + coolingAlarmData.setSlxtyckz(MapUtils.getInteger(obj, "SLXTYCKZ")); + coolingAlarmData.setSlxtbdkz(MapUtils.getInteger(obj, "SLXTBDKZ")); + coolingAlarmData.setSlxtzdms(MapUtils.getInteger(obj, "SLXTZDMS")); + coolingAlarmData.setSlxtsdms(MapUtils.getInteger(obj, "SLXTSDMS")); + coolingAlarmData.setHsylcdyj(MapUtils.getInteger(obj, "HSYLCDYJ")); + coolingAlarmData.setHsyldyj(MapUtils.getInteger(obj, "HSYLDYJ")); + coolingAlarmData.setGsylcgyj(MapUtils.getInteger(obj, "GSYLCGYJ")); + coolingAlarmData.setGsylgyj(MapUtils.getInteger(obj, "GSYLGYJ")); + coolingAlarmData.setGsylcdyj(MapUtils.getInteger(obj, "GSYLCDYJ")); + coolingAlarmData.setGsyldyj(MapUtils.getInteger(obj, "GSYLDYJ")); + coolingAlarmData.setHcgywg(MapUtils.getInteger(obj, "HCGYWG")); + coolingAlarmData.setHcgywcdtz(MapUtils.getInteger(obj, "HCGYWCDTZ")); + coolingAlarmData.setHcgywd(MapUtils.getInteger(obj, "HCGYWD")); + coolingAlarmData.setHcgylg(MapUtils.getInteger(obj, "HCGYLG")); + coolingAlarmData.setHcgyld(MapUtils.getInteger(obj, "HCGYLD")); + coolingAlarmData.setLysylgyj(MapUtils.getInteger(obj, "LYSYLGYJ")); + coolingAlarmData.setLysyldyj(MapUtils.getInteger(obj, "LYSYLDYJ")); + coolingAlarmData.setHswdcgyj(MapUtils.getInteger(obj, "HSWDCGYJ")); + coolingAlarmData.setHswdgyj(MapUtils.getInteger(obj, "HSWDGYJ")); + coolingAlarmData.setGswdcgtz(MapUtils.getInteger(obj, "GSWDCGTZ")); + coolingAlarmData.setGswdgyj(MapUtils.getInteger(obj, "GSWDGYJ")); + coolingAlarmData.setGswddyj(MapUtils.getInteger(obj, "GSWDDYJ")); + coolingAlarmData.setDdf2gz(MapUtils.getInteger(obj, "DDF2GZ")); + coolingAlarmData.setDdf1gz(MapUtils.getInteger(obj, "DDF1GZ")); + coolingAlarmData.setLyswdbsqyJ(MapUtils.getInteger(obj, "LYSWDBSQYJ")); + coolingAlarmData.setHsylbsqyJ(MapUtils.getInteger(obj, "HSYLBSQYJ")); + coolingAlarmData.setGsylbsqyJ(MapUtils.getInteger(obj, "GSYLBSQYJ")); + coolingAlarmData.setHswdbsqyJ(MapUtils.getInteger(obj, "HSWDBSQYJ")); + coolingAlarmData.setGswdbsqgztz(MapUtils.getInteger(obj, "GSWDBSQGZTZ")); + coolingAlarmData.setLsjgz(MapUtils.getInteger(obj, "LSJGZ")); + coolingAlarmData.setDjrq2gz(MapUtils.getInteger(obj, "DJRQ2GZ")); + coolingAlarmData.setDjrq1gz(MapUtils.getInteger(obj, "DJRQ1GZ")); + coolingAlarmData.setBqbgz(MapUtils.getInteger(obj, "BQBGZ")); + coolingAlarmData.setBsbgz(MapUtils.getInteger(obj, "BSBGZ")); + coolingAlarmData.setXhbgz(MapUtils.getInteger(obj, "XHBGZ")); + coolingAlarmData.setZdygz(MapUtils.getInteger(obj, "ZDYGZ")); + + coolingAlarmData.setCreateBy("system"); + coolingAlarmData.setCreateTime(DateUtils.getNowDate()); + coolingAlarmData.setUpdateBy("system"); + coolingAlarmData.setUpdateTime(DateUtils.getNowDate()); + coolingAlarmData.setSiteId(SITE_ID); + coolingAlarmData.setDeviceId(deviceId); + emsCoolingAlarmDataMapper.insertEmsCoolingAlarmData(coolingAlarmData); + } + + @Override + public void processBatch(List batchData) { + super.processBatch(batchData); + } + + private void alarmDataProcess(String deviceId, String jsonData, + Map alarmInfoData, String category) { + Map obj = JSON.parseObject(jsonData, new TypeReference>() { + }); + + String redisKey = RedisKeyConstants.LATEST_ALARM_RECORD + "_" + SITE_ID +"_" + deviceId; + // 获取redis里面的当前有效告警遍历添加到已存在告警key里面 + Map currentAlarm = redisCache.getCacheMap(redisKey); + final Set currentAlarmKeys = new HashSet<>(); + if (currentAlarm != null && !currentAlarm.isEmpty()) { + currentAlarm.keySet().stream() + .filter(Objects::nonNull) + .map(Object::toString) + .forEach(currentAlarmKeys::add); + } + + // 结合同步数据，筛选簇需要更新的告警信息 + List needUpdateKeys = obj.entrySet().stream() + .filter(entry -> { + Object valueObj = entry.getValue(); + if (valueObj == null) { + return false; + } + int value = Integer.parseInt(valueObj.toString()); + return value == 0 && currentAlarmKeys.contains(entry.getKey()); + }) + .map(Map.Entry::getKey) + .collect(Collectors.toList()); + + // 批量查询数据库-需要更新的数据 + Map needUpdateMap = new HashMap<>(); + if (!needUpdateKeys.isEmpty()) { + List records = iEmsAlarmRecordsService.getAllUnfinishedRecords(needUpdateKeys,SITE_ID, deviceId); + // 转为Map便于快速获取 + needUpdateMap = records.stream() + .collect(Collectors.toMap( + EmsAlarmRecords::getAlarmPoint, + record -> record + )); + } + + + List saveOrUpdateList = new ArrayList<>(); + List newAddRecordList = new ArrayList<>(); + List toRemoveFromRedis = new ArrayList<>(); + + // 遍历数据map + for (Map.Entry entry : obj.entrySet()) { + String key = entry.getKey(); + Integer value = (Integer) entry.getValue(); + Boolean isCurrentAlarm = currentAlarmKeys.contains(key); + + // 值为 1且不在当前告警里面 - 新增告警 + if (value == 1 && !isCurrentAlarm) { + String matchRedisKey = category + "_" + key; + Object cacheObj = alarmInfoData.get(matchRedisKey); + if (cacheObj == null) { + // 处理空数据逻辑 + return; + } + EmsAlarmMatchData matchInfo = JSON.toJavaObject(cacheObj, EmsAlarmMatchData.class); + EmsAlarmRecords emsAlarmRecord = convertAlarmRecord(deviceId,matchInfo); + saveOrUpdateList.add(emsAlarmRecord); + newAddRecordList.add(emsAlarmRecord); + } else if (value == 0 && isCurrentAlarm) {// 值为 0且在当前告警里面 - 更新告警已处理 + EmsAlarmRecords existingAlarm = needUpdateMap.get(key); + if (existingAlarm != null) { + existingAlarm.setStatus(AlarmStatus.DONE.getCode()); + existingAlarm.setUpdateTime(new Date()); + existingAlarm.setAlarmEndTime(new Date()); + saveOrUpdateList.add(existingAlarm); + toRemoveFromRedis.add(key); + } + } + } + + // 批量处理插入和更新操作 + if (saveOrUpdateList != null && saveOrUpdateList.size() > 0) { + iEmsAlarmRecordsService.batchProcessAlarmRecords(saveOrUpdateList); + } + // 已处理的从redis里面删除 + if (!toRemoveFromRedis.isEmpty()) { + redisCache.deleteAllCacheMapValue(RedisKeyConstants.LATEST_ALARM_RECORD + SITE_ID,toRemoveFromRedis.toArray()); + } + // 批量添加新增的告警到Redis + Map newAlarms = newAddRecordList.stream() + .filter(a -> !AlarmStatus.DONE.getCode().equals(a.getStatus())) + .collect(Collectors.toMap(EmsAlarmRecords::getAlarmPoint, a -> a)); + if (!newAlarms.isEmpty()) { + // 本次新增的放入redis + redisCache.setAllCacheMapValue(redisKey, newAlarms); + } + } + + private EmsAlarmRecords convertAlarmRecord(String deviceId, EmsAlarmMatchData matchInfo) { + EmsAlarmRecords emsAlarmRecords = new EmsAlarmRecords(); + emsAlarmRecords.setSiteId(SITE_ID); + emsAlarmRecords.setDeviceId(deviceId); + emsAlarmRecords.setDeviceType(DeviceType.TCP.toString()); + emsAlarmRecords.setAlarmLevel(AlarmLevelStatus.GENERAL.getCode()); + emsAlarmRecords.setStatus(AlarmStatus.WAITING.getCode()); + emsAlarmRecords.setAlarmStartTime(DateUtils.getNowDate()); + emsAlarmRecords.setCreateTime(DateUtils.getNowDate()); + emsAlarmRecords.setCreateBy("system"); + emsAlarmRecords.setUpdateTime(DateUtils.getNowDate()); + emsAlarmRecords.setUpdateBy("system"); + + if (matchInfo != null) { + emsAlarmRecords.setAlarmPoint(matchInfo.getPoint()); + emsAlarmRecords.setAlarmContent(matchInfo.getAlarmDescription()); + } + return emsAlarmRecords; + } + + // 空数据不处理 + private boolean checkJsonDataEmpty(String jsonData) { + boolean flag = false; + try { + if (StringUtils.isEmpty(jsonData)) { + flag = true; + } + JsonNode jsonNode = objectMapper.readTree(jsonData); + // 判断是否为空对象（{}） + if (jsonNode.isObject() && jsonNode.isEmpty()) { + flag = true ; + } + } catch (JsonProcessingException e) { + throw new RuntimeException(e); + } + return flag; + } +} diff --git a/ems-system/src/main/java/com/xzzn/ems/service/impl/FXXDataProcessServiceImpl.java b/ems-system/src/main/java/com/xzzn/ems/service/impl/FXXDataProcessServiceImpl.java index a808968..fb0665f 100644 --- a/ems-system/src/main/java/com/xzzn/ems/service/impl/FXXDataProcessServiceImpl.java +++ b/ems-system/src/main/java/com/xzzn/ems/service/impl/FXXDataProcessServiceImpl.java @@ -947,17 +947,6 @@ public class FXXDataProcessServiceImpl extends AbstractBatteryDataProcessor impl && dataTimeStr.compareTo(endTime) < 0; } - private String concateCurrentDayTime(String startTime) { - DateTimeFormatter timeFormatter = DateTimeFormatter.ofPattern("HH:mm"); - LocalTime time = LocalTime.parse(startTime, timeFormatter); - - LocalDate today = LocalDate.now(); - LocalDateTime targetDateTime = LocalDateTime.of(today, time); - - DateTimeFormatter resultFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss"); - return targetDateTime.format(resultFormatter); - } - private EmsDailyEnergyData initEnergyData() { // 先获取数据库当天数据,存在则更新时间，不存在则初始化 EmsDailyEnergyData energyData = emsDailyEnergyDataMapper.getDataByDate(SITE_ID,DateUtils.getDate()); @@ -1026,142 +1015,8 @@ public class FXXDataProcessServiceImpl extends AbstractBatteryDataProcessor impl } @Override - public void handleFxAlarmData(String message) { - JSONArray arraylist = JSONArray.parseArray(message); - - // 获取redis缓存-告警信息 - Map alarmMatchInfo= redisCache.getCacheObject(RedisKeyConstants.ALARM_MATCH_INFO); - - for (int i = 0; i < arraylist.size(); i++) { - JSONObject obj = JSONObject.parseObject(arraylist.get(i).toString()); - - String deviceId = obj.get("Device").toString(); - String jsonData = obj.get("Data").toString(); - - log.info("deviceId:" + deviceId); - - if (deviceId.contains("BMSD")) { - alarmDataProcess(deviceId, jsonData, alarmMatchInfo, DeviceCategory.STACK.getCode()); - } else if (deviceId.contains("BMSC")) { - alarmDataProcess(deviceId, jsonData, alarmMatchInfo, DeviceCategory.CLUSTER.getCode()); - } else if (deviceId.contains("PCS")) { - alarmDataProcess(deviceId, jsonData, alarmMatchInfo, DeviceCategory.PCS.getCode()); - } - } - } - - private void alarmDataProcess(String deviceId, String jsonData, - Map alarmInfoData, String category) { - Map obj = JSON.parseObject(jsonData, new TypeReference>() { - }); - - String redisKey = RedisKeyConstants.LATEST_ALARM_RECORD + "_" + SITE_ID +"_" + deviceId; - // 获取redis里面的当前有效告警遍历添加到已存在告警key里面 - Map currentAlarm = redisCache.getCacheMap(redisKey); - final Set currentAlarmKeys = new HashSet<>(); - if (currentAlarm != null && !currentAlarm.isEmpty()) { - currentAlarm.keySet().stream() - .filter(Objects::nonNull) - .map(Object::toString) - .forEach(currentAlarmKeys::add); - } - - // 结合同步数据，筛选簇需要更新的告警信息 - List needUpdateKeys = obj.entrySet().stream() - .filter(entry -> { - Object valueObj = entry.getValue(); - if (valueObj == null) { - return false; - } - int value = Integer.parseInt(valueObj.toString()); - return value == 0 && currentAlarmKeys.contains(entry.getKey()); - }) - .map(Map.Entry::getKey) - .collect(Collectors.toList()); - - // 批量查询数据库-需要更新的数据 - Map needUpdateMap = new HashMap<>(); - if (!needUpdateKeys.isEmpty()) { - List records = iEmsAlarmRecordsService.getAllUnfinishedRecords(needUpdateKeys,SITE_ID, deviceId); - // 转为Map便于快速获取 - needUpdateMap = records.stream() - .collect(Collectors.toMap( - EmsAlarmRecords::getAlarmPoint, - record -> record - )); - } - - - List saveOrUpdateList = new ArrayList<>(); - List newAddRecordList = new ArrayList<>(); - List toRemoveFromRedis = new ArrayList<>(); - - // 遍历数据map - for (Map.Entry entry : obj.entrySet()) { - String key = entry.getKey(); - Integer value = (Integer) entry.getValue(); - Boolean isCurrentAlarm = currentAlarmKeys.contains(key); - - // 值为 1且不在当前告警里面 - 新增告警 - if (value == 1 && !isCurrentAlarm) { - String matchRedisKey = category + "_" + key; - Object cacheObj = alarmInfoData.get(matchRedisKey); - if (cacheObj == null) { - // 处理空数据逻辑 - return; - } - EmsAlarmMatchData matchInfo = JSON.toJavaObject(cacheObj, EmsAlarmMatchData.class); - EmsAlarmRecords emsAlarmRecord = convertAlarmRecord(deviceId,matchInfo); - saveOrUpdateList.add(emsAlarmRecord); - newAddRecordList.add(emsAlarmRecord); - } else if (value == 0 && isCurrentAlarm) {// 值为 0且在当前告警里面 - 更新告警已处理 - EmsAlarmRecords existingAlarm = needUpdateMap.get(key); - if (existingAlarm != null) { - existingAlarm.setStatus(AlarmStatus.DONE.getCode()); - existingAlarm.setUpdateTime(new Date()); - existingAlarm.setAlarmEndTime(new Date()); - saveOrUpdateList.add(existingAlarm); - toRemoveFromRedis.add(key); - } - } - } - - // 批量处理插入和更新操作 - if (saveOrUpdateList != null && saveOrUpdateList.size() > 0) { - iEmsAlarmRecordsService.batchProcessAlarmRecords(saveOrUpdateList); - } - // 已处理的从redis里面删除 - if (!toRemoveFromRedis.isEmpty()) { - redisCache.deleteAllCacheMapValue(RedisKeyConstants.LATEST_ALARM_RECORD + SITE_ID,toRemoveFromRedis.toArray()); - } - // 批量添加新增的告警到Redis - Map newAlarms = newAddRecordList.stream() - .filter(a -> !AlarmStatus.DONE.getCode().equals(a.getStatus())) - .collect(Collectors.toMap(EmsAlarmRecords::getAlarmPoint, a -> a)); - if (!newAlarms.isEmpty()) { - // 本次新增的放入redis - redisCache.setAllCacheMapValue(redisKey, newAlarms); - } - } - - private EmsAlarmRecords convertAlarmRecord(String deviceId, EmsAlarmMatchData matchInfo) { - EmsAlarmRecords emsAlarmRecords = new EmsAlarmRecords(); - emsAlarmRecords.setSiteId(SITE_ID); - emsAlarmRecords.setDeviceId(deviceId); - emsAlarmRecords.setDeviceType(DeviceType.TCP.toString()); - emsAlarmRecords.setAlarmLevel(AlarmLevelStatus.GENERAL.getCode()); - emsAlarmRecords.setStatus(AlarmStatus.WAITING.getCode()); - emsAlarmRecords.setAlarmStartTime(DateUtils.getNowDate()); - emsAlarmRecords.setCreateTime(DateUtils.getNowDate()); - emsAlarmRecords.setCreateBy("system"); - emsAlarmRecords.setUpdateTime(DateUtils.getNowDate()); - emsAlarmRecords.setUpdateBy("system"); - - if (matchInfo != null) { - emsAlarmRecords.setAlarmPoint(matchInfo.getPoint()); - emsAlarmRecords.setAlarmContent(matchInfo.getAlarmDescription()); - } - return emsAlarmRecords; + public void processBatch(List batchData) { + super.processBatch(batchData); } // 空数据不处理 diff --git a/ems-system/src/main/resources/mapper/ems/EmsClusterAlarmDataMapper.xml b/ems-system/src/main/resources/mapper/ems/EmsClusterAlarmDataMapper.xml new file mode 100644 index 0000000..21dedba --- /dev/null +++ b/ems-system/src/main/resources/mapper/ems/EmsClusterAlarmDataMapper.xml @@ -0,0 +1,526 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + select id, data_timestamp, site_id, device_id, c1zktxsl, c1ddyqyqdgj, c1ddyqyzdgj, c1ddyqyzzdgj, c1ddygyqdgj, c1ddygyzdgj, c1ddygyzzdgj, c1ddlqdgj, c1ddlzdgj, c1ddlzzdgj, c1dtqyqdgj, c1dtqyzdgj, c1dtqyzzdgj, c1dtgyqdgj, c1dtgyzdgj, c1dtgyzzdgj, c1dtqwqdgj, c1dtqwzdgj, c1dtqwzzdgj, c1dtgwqdgj, c1dtgwzdgj, c1dtgwzzdgj, c1socdqdgj, c1socdzdgj, c1socdzzdgj, c1socgqdgj, c1socgzdgj, c1socgzzdgj, c1sohdqdgj, c1sohdzdgj, c1sohdzzdgj, c1dtycqdgj, c1dtyczdgj, c1dtyczzdgj, c1dtwcqdgj, c1dtwczdgj, c1dtwczzdgj, c1ck1txsl, c1ck2txsl, c1ck3txsl, c1ck4txsl, c1ck5txsl, c1ck6txsl, c1ck7txsl, c1ck8txsl, c1ck9txsl, c1ck10txsl, c1ck11txsl, c1ck12txsl, c1ck13txsl, c1ck14txsl, c1ck15txsl, c1ck16txsl, c1ck17txsl, c1ck18txsl, c1ck19txsl, c1ck20txsl, c1ck21txsl, c1ck22txsl, c1ck23txsl, c1ck24txsl, c1ck25txsl, c1ck26txsl, c1ck27txsl, c1ck28txsl, c1ck29txsl, c1ck30txsl, c1ck31txsl, c1ck32txsl, c1ck33txsl, c1ck34txsl, c1ck35txsl, c1ck36txsl, c1ck37txsl, c1ck38txsl, c1ck39txsl, c1ck40txsl, c1dzwdggqdgj, c1dzwdggzdgj, c1dzwdggzzdgj, c1mkdyggqdgj, c1mkdyggzdgj, c1mkdyggzzdgj, c1mkdygdqdgj, c1mkdygdzdgj, c1mkdygdzzdgj, c1dycjgz, c1wdcjgz, create_by, create_time, update_by, update_time, remark from ems_cluster_alarm_data + + + + + + + + insert into ems_cluster_alarm_data + + data_timestamp, + site_id, + device_id, + c1zktxsl, + c1ddyqyqdgj, + c1ddyqyzdgj, + c1ddyqyzzdgj, + c1ddygyqdgj, + c1ddygyzdgj, + c1ddygyzzdgj, + c1ddlqdgj, + c1ddlzdgj, + c1ddlzzdgj, + c1dtqyqdgj, + c1dtqyzdgj, + c1dtqyzzdgj, + c1dtgyqdgj, + c1dtgyzdgj, + c1dtgyzzdgj, + c1dtqwqdgj, + c1dtqwzdgj, + c1dtqwzzdgj, + c1dtgwqdgj, + c1dtgwzdgj, + c1dtgwzzdgj, + c1socdqdgj, + c1socdzdgj, + c1socdzzdgj, + c1socgqdgj, + c1socgzdgj, + c1socgzzdgj, + c1sohdqdgj, + c1sohdzdgj, + c1sohdzzdgj, + c1dtycqdgj, + c1dtyczdgj, + c1dtyczzdgj, + c1dtwcqdgj, + c1dtwczdgj, + c1dtwczzdgj, + c1ck1txsl, + c1ck2txsl, + c1ck3txsl, + c1ck4txsl, + c1ck5txsl, + c1ck6txsl, + c1ck7txsl, + c1ck8txsl, + c1ck9txsl, + c1ck10txsl, + c1ck11txsl, + c1ck12txsl, + c1ck13txsl, + c1ck14txsl, + c1ck15txsl, + c1ck16txsl, + c1ck17txsl, + c1ck18txsl, + c1ck19txsl, + c1ck20txsl, + c1ck21txsl, + c1ck22txsl, + c1ck23txsl, + c1ck24txsl, + c1ck25txsl, + c1ck26txsl, + c1ck27txsl, + c1ck28txsl, + c1ck29txsl, + c1ck30txsl, + c1ck31txsl, + c1ck32txsl, + c1ck33txsl, + c1ck34txsl, + c1ck35txsl, + c1ck36txsl, + c1ck37txsl, + c1ck38txsl, + c1ck39txsl, + c1ck40txsl, + c1dzwdggqdgj, + c1dzwdggzdgj, + c1dzwdggzzdgj, + c1mkdyggqdgj, + c1mkdyggzdgj, + c1mkdyggzzdgj, + c1mkdygdqdgj, + c1mkdygdzdgj, + c1mkdygdzzdgj, + c1dycjgz, + c1wdcjgz, + create_by, + create_time, + update_by, + update_time, + remark, + + + #{dataTimestamp}, + #{siteId}, + #{deviceId}, + #{c1zktxsl}, + #{c1ddyqyqdgj}, + #{c1ddyqyzdgj}, + #{c1ddyqyzzdgj}, + #{c1ddygyqdgj}, + #{c1ddygyzdgj}, + #{c1ddygyzzdgj}, + #{c1ddlqdgj}, + #{c1ddlzdgj}, + #{c1ddlzzdgj}, + #{c1dtqyqdgj}, + #{c1dtqyzdgj}, + #{c1dtqyzzdgj}, + #{c1dtgyqdgj}, + #{c1dtgyzdgj}, + #{c1dtgyzzdgj}, + #{c1dtqwqdgj}, + #{c1dtqwzdgj}, + #{c1dtqwzzdgj}, + #{c1dtgwqdgj}, + #{c1dtgwzdgj}, + #{c1dtgwzzdgj}, + #{c1socdqdgj}, + #{c1socdzdgj}, + #{c1socdzzdgj}, + #{c1socgqdgj}, + #{c1socgzdgj}, + #{c1socgzzdgj}, + #{c1sohdqdgj}, + #{c1sohdzdgj}, + #{c1sohdzzdgj}, + #{c1dtycqdgj}, + #{c1dtyczdgj}, + #{c1dtyczzdgj}, + #{c1dtwcqdgj}, + #{c1dtwczdgj}, + #{c1dtwczzdgj}, + #{c1ck1txsl}, + #{c1ck2txsl}, + #{c1ck3txsl}, + #{c1ck4txsl}, + #{c1ck5txsl}, + #{c1ck6txsl}, + #{c1ck7txsl}, + #{c1ck8txsl}, + #{c1ck9txsl}, + #{c1ck10txsl}, + #{c1ck11txsl}, + #{c1ck12txsl}, + #{c1ck13txsl}, + #{c1ck14txsl}, + #{c1ck15txsl}, + #{c1ck16txsl}, + #{c1ck17txsl}, + #{c1ck18txsl}, + #{c1ck19txsl}, + #{c1ck20txsl}, + #{c1ck21txsl}, + #{c1ck22txsl}, + #{c1ck23txsl}, + #{c1ck24txsl}, + #{c1ck25txsl}, + #{c1ck26txsl}, + #{c1ck27txsl}, + #{c1ck28txsl}, + #{c1ck29txsl}, + #{c1ck30txsl}, + #{c1ck31txsl}, + #{c1ck32txsl}, + #{c1ck33txsl}, + #{c1ck34txsl}, + #{c1ck35txsl}, + #{c1ck36txsl}, + #{c1ck37txsl}, + #{c1ck38txsl}, + #{c1ck39txsl}, + #{c1ck40txsl}, + #{c1dzwdggqdgj}, + #{c1dzwdggzdgj}, + #{c1dzwdggzzdgj}, + #{c1mkdyggqdgj}, + #{c1mkdyggzdgj}, + #{c1mkdyggzzdgj}, + #{c1mkdygdqdgj}, + #{c1mkdygdzdgj}, + #{c1mkdygdzzdgj}, + #{c1dycjgz}, + #{c1wdcjgz}, + #{createBy}, + #{createTime}, + #{updateBy}, + #{updateTime}, + #{remark}, + + + + + update ems_cluster_alarm_data + + data_timestamp = #{dataTimestamp}, + site_id = #{siteId}, + device_id = #{deviceId}, + c1zktxsl = #{c1zktxsl}, + c1ddyqyqdgj = #{c1ddyqyqdgj}, + c1ddyqyzdgj = #{c1ddyqyzdgj}, + c1ddyqyzzdgj = #{c1ddyqyzzdgj}, + c1ddygyqdgj = #{c1ddygyqdgj}, + c1ddygyzdgj = #{c1ddygyzdgj}, + c1ddygyzzdgj = #{c1ddygyzzdgj}, + c1ddlqdgj = #{c1ddlqdgj}, + c1ddlzdgj = #{c1ddlzdgj}, + c1ddlzzdgj = #{c1ddlzzdgj}, + c1dtqyqdgj = #{c1dtqyqdgj}, + c1dtqyzdgj = #{c1dtqyzdgj}, + c1dtqyzzdgj = #{c1dtqyzzdgj}, + c1dtgyqdgj = #{c1dtgyqdgj}, + c1dtgyzdgj = #{c1dtgyzdgj}, + c1dtgyzzdgj = #{c1dtgyzzdgj}, + c1dtqwqdgj = #{c1dtqwqdgj}, + c1dtqwzdgj = #{c1dtqwzdgj}, + c1dtqwzzdgj = #{c1dtqwzzdgj}, + c1dtgwqdgj = #{c1dtgwqdgj}, + c1dtgwzdgj = #{c1dtgwzdgj}, + c1dtgwzzdgj = #{c1dtgwzzdgj}, + c1socdqdgj = #{c1socdqdgj}, + c1socdzdgj = #{c1socdzdgj}, + c1socdzzdgj = #{c1socdzzdgj}, + c1socgqdgj = #{c1socgqdgj}, + c1socgzdgj = #{c1socgzdgj}, + c1socgzzdgj = #{c1socgzzdgj}, + c1sohdqdgj = #{c1sohdqdgj}, + c1sohdzdgj = #{c1sohdzdgj}, + c1sohdzzdgj = #{c1sohdzzdgj}, + c1dtycqdgj = #{c1dtycqdgj}, + c1dtyczdgj = #{c1dtyczdgj}, + c1dtyczzdgj = #{c1dtyczzdgj}, + c1dtwcqdgj = #{c1dtwcqdgj}, + c1dtwczdgj = #{c1dtwczdgj}, + c1dtwczzdgj = #{c1dtwczzdgj}, + c1ck1txsl = #{c1ck1txsl}, + c1ck2txsl = #{c1ck2txsl}, + c1ck3txsl = #{c1ck3txsl}, + c1ck4txsl = #{c1ck4txsl}, + c1ck5txsl = #{c1ck5txsl}, + c1ck6txsl = #{c1ck6txsl}, + c1ck7txsl = #{c1ck7txsl}, + c1ck8txsl = #{c1ck8txsl}, + c1ck9txsl = #{c1ck9txsl}, + c1ck10txsl = #{c1ck10txsl}, + c1ck11txsl = #{c1ck11txsl}, + c1ck12txsl = #{c1ck12txsl}, + c1ck13txsl = #{c1ck13txsl}, + c1ck14txsl = #{c1ck14txsl}, + c1ck15txsl = #{c1ck15txsl}, + c1ck16txsl = #{c1ck16txsl}, + c1ck17txsl = #{c1ck17txsl}, + c1ck18txsl = #{c1ck18txsl}, + c1ck19txsl = #{c1ck19txsl}, + c1ck20txsl = #{c1ck20txsl}, + c1ck21txsl = #{c1ck21txsl}, + c1ck22txsl = #{c1ck22txsl}, + c1ck23txsl = #{c1ck23txsl}, + c1ck24txsl = #{c1ck24txsl}, + c1ck25txsl = #{c1ck25txsl}, + c1ck26txsl = #{c1ck26txsl}, + c1ck27txsl = #{c1ck27txsl}, + c1ck28txsl = #{c1ck28txsl}, + c1ck29txsl = #{c1ck29txsl}, + c1ck30txsl = #{c1ck30txsl}, + c1ck31txsl = #{c1ck31txsl}, + c1ck32txsl = #{c1ck32txsl}, + c1ck33txsl = #{c1ck33txsl}, + c1ck34txsl = #{c1ck34txsl}, + c1ck35txsl = #{c1ck35txsl}, + c1ck36txsl = #{c1ck36txsl}, + c1ck37txsl = #{c1ck37txsl}, + c1ck38txsl = #{c1ck38txsl}, + c1ck39txsl = #{c1ck39txsl}, + c1ck40txsl = #{c1ck40txsl}, + c1dzwdggqdgj = #{c1dzwdggqdgj}, + c1dzwdggzdgj = #{c1dzwdggzdgj}, + c1dzwdggzzdgj = #{c1dzwdggzzdgj}, + c1mkdyggqdgj = #{c1mkdyggqdgj}, + c1mkdyggzdgj = #{c1mkdyggzdgj}, + c1mkdyggzzdgj = #{c1mkdyggzzdgj}, + c1mkdygdqdgj = #{c1mkdygdqdgj}, + c1mkdygdzdgj = #{c1mkdygdzdgj}, + c1mkdygdzzdgj = #{c1mkdygdzzdgj}, + c1dycjgz = #{c1dycjgz}, + c1wdcjgz = #{c1wdcjgz}, + create_by = #{createBy}, + create_time = #{createTime}, + update_by = #{updateBy}, + update_time = #{updateTime}, + remark = #{remark}, + + where id = #{id} + + + + delete from ems_cluster_alarm_data where id = #{id} + + + + delete from ems_cluster_alarm_data where id in + + #{id} + + + \ No newline at end of file diff --git a/ems-system/src/main/resources/mapper/ems/EmsCoolingAlarmDataMapper.xml b/ems-system/src/main/resources/mapper/ems/EmsCoolingAlarmDataMapper.xml new file mode 100644 index 0000000..a6db7b3 --- /dev/null +++ b/ems-system/src/main/resources/mapper/ems/EmsCoolingAlarmDataMapper.xml @@ -0,0 +1,321 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + select id, data_timestamp, site_id, device_id, lsjyx, pqdcfyx, djrq2yx, djrq1yx, bqbyx, bsbyx, zxhbyx, sltzgz, slzhyj, slxtyctzxh, slxtycqdxh, slxtyckz, slxtbdkz, slxtzdms, slxtsdms, hsylcdyj, hsyldyj, gsylcgyj, gsylgyj, gsylcdyj, gsyldyj, hcgywg, hcgywcdtz, hcgywd, hcgylg, hcgyld, lysylgyj, lysyldyj, hswdcgyj, hswdgyj, gswdcgtz, gswdgyj, gswddyj, ddf2gz, ddf1gz, lyswdbsqyJ, hsylbsqyJ, gsylbsqyJ, hswdbsqyJ, gswdbsqgztz, lsjgz, djrq2gz, djrq1gz, bqbgz, bsbgz, xhbgz, zdygz, create_by, create_time, update_by, update_time, remark from ems_cooling_alarm_data + + + + + + + + insert into ems_cooling_alarm_data + + data_timestamp, + site_id, + device_id, + lsjyx, + pqdcfyx, + djrq2yx, + djrq1yx, + bqbyx, + bsbyx, + zxhbyx, + sltzgz, + slzhyj, + slxtyctzxh, + slxtycqdxh, + slxtyckz, + slxtbdkz, + slxtzdms, + slxtsdms, + hsylcdyj, + hsyldyj, + gsylcgyj, + gsylgyj, + gsylcdyj, + gsyldyj, + hcgywg, + hcgywcdtz, + hcgywd, + hcgylg, + hcgyld, + lysylgyj, + lysyldyj, + hswdcgyj, + hswdgyj, + gswdcgtz, + gswdgyj, + gswddyj, + ddf2gz, + ddf1gz, + lyswdbsqyJ, + hsylbsqyJ, + gsylbsqyJ, + hswdbsqyJ, + gswdbsqgztz, + lsjgz, + djrq2gz, + djrq1gz, + bqbgz, + bsbgz, + xhbgz, + zdygz, + create_by, + create_time, + update_by, + update_time, + remark, + + + #{dataTimestamp}, + #{siteId}, + #{deviceId}, + #{lsjyx}, + #{pqdcfyx}, + #{djrq2yx}, + #{djrq1yx}, + #{bqbyx}, + #{bsbyx}, + #{zxhbyx}, + #{sltzgz}, + #{slzhyj}, + #{slxtyctzxh}, + #{slxtycqdxh}, + #{slxtyckz}, + #{slxtbdkz}, + #{slxtzdms}, + #{slxtsdms}, + #{hsylcdyj}, + #{hsyldyj}, + #{gsylcgyj}, + #{gsylgyj}, + #{gsylcdyj}, + #{gsyldyj}, + #{hcgywg}, + #{hcgywcdtz}, + #{hcgywd}, + #{hcgylg}, + #{hcgyld}, + #{lysylgyj}, + #{lysyldyj}, + #{hswdcgyj}, + #{hswdgyj}, + #{gswdcgtz}, + #{gswdgyj}, + #{gswddyj}, + #{ddf2gz}, + #{ddf1gz}, + #{lyswdbsqyJ}, + #{hsylbsqyJ}, + #{gsylbsqyJ}, + #{hswdbsqyJ}, + #{gswdbsqgztz}, + #{lsjgz}, + #{djrq2gz}, + #{djrq1gz}, + #{bqbgz}, + #{bsbgz}, + #{xhbgz}, + #{zdygz}, + #{createBy}, + #{createTime}, + #{updateBy}, + #{updateTime}, + #{remark}, + + + + + update ems_cooling_alarm_data + + data_timestamp = #{dataTimestamp}, + site_id = #{siteId}, + device_id = #{deviceId}, + lsjyx = #{lsjyx}, + pqdcfyx = #{pqdcfyx}, + djrq2yx = #{djrq2yx}, + djrq1yx = #{djrq1yx}, + bqbyx = #{bqbyx}, + bsbyx = #{bsbyx}, + zxhbyx = #{zxhbyx}, + sltzgz = #{sltzgz}, + slzhyj = #{slzhyj}, + slxtyctzxh = #{slxtyctzxh}, + slxtycqdxh = #{slxtycqdxh}, + slxtyckz = #{slxtyckz}, + slxtbdkz = #{slxtbdkz}, + slxtzdms = #{slxtzdms}, + slxtsdms = #{slxtsdms}, + hsylcdyj = #{hsylcdyj}, + hsyldyj = #{hsyldyj}, + gsylcgyj = #{gsylcgyj}, + gsylgyj = #{gsylgyj}, + gsylcdyj = #{gsylcdyj}, + gsyldyj = #{gsyldyj}, + hcgywg = #{hcgywg}, + hcgywcdtz = #{hcgywcdtz}, + hcgywd = #{hcgywd}, + hcgylg = #{hcgylg}, + hcgyld = #{hcgyld}, + lysylgyj = #{lysylgyj}, + lysyldyj = #{lysyldyj}, + hswdcgyj = #{hswdcgyj}, + hswdgyj = #{hswdgyj}, + gswdcgtz = #{gswdcgtz}, + gswdgyj = #{gswdgyj}, + gswddyj = #{gswddyj}, + ddf2gz = #{ddf2gz}, + ddf1gz = #{ddf1gz}, + lyswdbsqyJ = #{lyswdbsqyJ}, + hsylbsqyJ = #{hsylbsqyJ}, + gsylbsqyJ = #{gsylbsqyJ}, + hswdbsqyJ = #{hswdbsqyJ}, + gswdbsqgztz = #{gswdbsqgztz}, + lsjgz = #{lsjgz}, + djrq2gz = #{djrq2gz}, + djrq1gz = #{djrq1gz}, + bqbgz = #{bqbgz}, + bsbgz = #{bsbgz}, + xhbgz = #{xhbgz}, + zdygz = #{zdygz}, + create_by = #{createBy}, + create_time = #{createTime}, + update_by = #{updateBy}, + update_time = #{updateTime}, + remark = #{remark}, + + where id = #{id} + + + + delete from ems_cooling_alarm_data where id = #{id} + + + + delete from ems_cooling_alarm_data where id in + + #{id} + + + \ No newline at end of file diff --git a/ems-system/src/main/resources/mapper/ems/EmsPcsAlarmDataMapper.xml b/ems-system/src/main/resources/mapper/ems/EmsPcsAlarmDataMapper.xml new file mode 100644 index 0000000..de59108 --- /dev/null +++ b/ems-system/src/main/resources/mapper/ems/EmsPcsAlarmDataMapper.xml @@ -0,0 +1,571 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + select id, data_timestamp, site_id, device_id, gzbz, jyzkyc, jlllyc, zlgv, dwgyyc, dwqyyc, dwgpyc, dwqpyc, glmkgw, dwxxyc, nbrjgl, zlrqdyc, zlkgwc, jlfjyc, jlkgwc, wdkgwc, nbyc, jngw, jlrqdyc, rjhjyc, jlflqyc, nbjt, wbjt, mxdbyfhkjtj, mxdlgl, lpjzyc, mjgj, sxyc, zlflqyc, zndbtxyc, nbyjgl, qdyc, idct, xxgxctxvc, bjtxxyc, tbctxvc, zldhyc, lxgl, zlzjcqyc, ywgj, bjtxyc, hmictxyc, jxszcw, hmi485txyc, yctxyc, gzz, gjz, zlblmsszcw, xtcsbpp, dwdybphgj, ddycyyx, gdycyyx, zlfjyc, srqwdkgwc, wbwdkgwc, fybyqwdkgwc, dgwdkgwc, zjjdvc, fjjdvc, jljdvc, bwjdvc, bmsjt, kkhrqyc, dwgqpdjgj, glmkgwgJ, dcgy, dcqzqy, zlgl, scdyyc, scdybfhlwtj, gzbh, dlbh, nbfjyc, zlbxsyc, dczzqy, dcdygj, wbfjyc, dcfj, dcdybfhcdtj, gzgJ, zldhmktxyc, bmsxtgz, bmstxyc, bmsgjdyc, bmsjc, bmsjf, bmsdj, bmsgj, dgfjyc, srqgwgj, gzz2, gjz2, jlfjsmyc, zlfjsmyc, jlkgSmyc, zlkgSmyc, yljzyc, create_by, create_time, update_by, update_time, remark from ems_pcs_alarm_data + + + + + + + + insert into ems_pcs_alarm_data + + data_timestamp, + site_id, + device_id, + gzbz, + jyzkyc, + jlllyc, + zlgv, + dwgyyc, + dwqyyc, + dwgpyc, + dwqpyc, + glmkgw, + dwxxyc, + nbrjgl, + zlrqdyc, + zlkgwc, + jlfjyc, + jlkgwc, + wdkgwc, + nbyc, + jngw, + jlrqdyc, + rjhjyc, + jlflqyc, + nbjt, + wbjt, + mxdbyfhkjtj, + mxdlgl, + lpjzyc, + mjgj, + sxyc, + zlflqyc, + zndbtxyc, + nbyjgl, + qdyc, + idct, + xxgxctxvc, + bjtxxyc, + tbctxvc, + zldhyc, + lxgl, + zlzjcqyc, + ywgj, + bjtxyc, + hmictxyc, + jxszcw, + hmi485txyc, + yctxyc, + gzz, + gjz, + zlblmsszcw, + xtcsbpp, + dwdybphgj, + ddycyyx, + gdycyyx, + zlfjyc, + srqwdkgwc, + wbwdkgwc, + fybyqwdkgwc, + dgwdkgwc, + zjjdvc, + fjjdvc, + jljdvc, + bwjdvc, + bmsjt, + kkhrqyc, + dwgqpdjgj, + glmkgwgJ, + dcgy, + dcqzqy, + zlgl, + scdyyc, + scdybfhlwtj, + gzbh, + dlbh, + nbfjyc, + zlbxsyc, + dczzqy, + dcdygj, + wbfjyc, + dcfj, + dcdybfhcdtj, + gzgJ, + zldhmktxyc, + bmsxtgz, + bmstxyc, + bmsgjdyc, + bmsjc, + bmsjf, + bmsdj, + bmsgj, + dgfjyc, + srqgwgj, + gzz2, + gjz2, + jlfjsmyc, + zlfjsmyc, + jlkgSmyc, + zlkgSmyc, + yljzyc, + create_by, + create_time, + update_by, + update_time, + remark, + + + #{dataTimestamp}, + #{siteId}, + #{deviceId}, + #{gzbz}, + #{jyzkyc}, + #{jlllyc}, + #{zlgv}, + #{dwgyyc}, + #{dwqyyc}, + #{dwgpyc}, + #{dwqpyc}, + #{glmkgw}, + #{dwxxyc}, + #{nbrjgl}, + #{zlrqdyc}, + #{zlkgwc}, + #{jlfjyc}, + #{jlkgwc}, + #{wdkgwc}, + #{nbyc}, + #{jngw}, + #{jlrqdyc}, + #{rjhjyc}, + #{jlflqyc}, + #{nbjt}, + #{wbjt}, + #{mxdbyfhkjtj}, + #{mxdlgl}, + #{lpjzyc}, + #{mjgj}, + #{sxyc}, + #{zlflqyc}, + #{zndbtxyc}, + #{nbyjgl}, + #{qdyc}, + #{idct}, + #{xxgxctxvc}, + #{bjtxxyc}, + #{tbctxvc}, + #{zldhyc}, + #{lxgl}, + #{zlzjcqyc}, + #{ywgj}, + #{bjtxyc}, + #{hmictxyc}, + #{jxszcw}, + #{hmi485txyc}, + #{yctxyc}, + #{gzz}, + #{gjz}, + #{zlblmsszcw}, + #{xtcsbpp}, + #{dwdybphgj}, + #{ddycyyx}, + #{gdycyyx}, + #{zlfjyc}, + #{srqwdkgwc}, + #{wbwdkgwc}, + #{fybyqwdkgwc}, + #{dgwdkgwc}, + #{zjjdvc}, + #{fjjdvc}, + #{jljdvc}, + #{bwjdvc}, + #{bmsjt}, + #{kkhrqyc}, + #{dwgqpdjgj}, + #{glmkgwgJ}, + #{dcgy}, + #{dcqzqy}, + #{zlgl}, + #{scdyyc}, + #{scdybfhlwtj}, + #{gzbh}, + #{dlbh}, + #{nbfjyc}, + #{zlbxsyc}, + #{dczzqy}, + #{dcdygj}, + #{wbfjyc}, + #{dcfj}, + #{dcdybfhcdtj}, + #{gzgJ}, + #{zldhmktxyc}, + #{bmsxtgz}, + #{bmstxyc}, + #{bmsgjdyc}, + #{bmsjc}, + #{bmsjf}, + #{bmsdj}, + #{bmsgj}, + #{dgfjyc}, + #{srqgwgj}, + #{gzz2}, + #{gjz2}, + #{jlfjsmyc}, + #{zlfjsmyc}, + #{jlkgSmyc}, + #{zlkgSmyc}, + #{yljzyc}, + #{createBy}, + #{createTime}, + #{updateBy}, + #{updateTime}, + #{remark}, + + + + + update ems_pcs_alarm_data + + data_timestamp = #{dataTimestamp}, + site_id = #{siteId}, + device_id = #{deviceId}, + gzbz = #{gzbz}, + jyzkyc = #{jyzkyc}, + jlllyc = #{jlllyc}, + zlgv = #{zlgv}, + dwgyyc = #{dwgyyc}, + dwqyyc = #{dwqyyc}, + dwgpyc = #{dwgpyc}, + dwqpyc = #{dwqpyc}, + glmkgw = #{glmkgw}, + dwxxyc = #{dwxxyc}, + nbrjgl = #{nbrjgl}, + zlrqdyc = #{zlrqdyc}, + zlkgwc = #{zlkgwc}, + jlfjyc = #{jlfjyc}, + jlkgwc = #{jlkgwc}, + wdkgwc = #{wdkgwc}, + nbyc = #{nbyc}, + jngw = #{jngw}, + jlrqdyc = #{jlrqdyc}, + rjhjyc = #{rjhjyc}, + jlflqyc = #{jlflqyc}, + nbjt = #{nbjt}, + wbjt = #{wbjt}, + mxdbyfhkjtj = #{mxdbyfhkjtj}, + mxdlgl = #{mxdlgl}, + lpjzyc = #{lpjzyc}, + mjgj = #{mjgj}, + sxyc = #{sxyc}, + zlflqyc = #{zlflqyc}, + zndbtxyc = #{zndbtxyc}, + nbyjgl = #{nbyjgl}, + qdyc = #{qdyc}, + idct = #{idct}, + xxgxctxvc = #{xxgxctxvc}, + bjtxxyc = #{bjtxxyc}, + tbctxvc = #{tbctxvc}, + zldhyc = #{zldhyc}, + lxgl = #{lxgl}, + zlzjcqyc = #{zlzjcqyc}, + ywgj = #{ywgj}, + bjtxyc = #{bjtxyc}, + hmictxyc = #{hmictxyc}, + jxszcw = #{jxszcw}, + hmi485txyc = #{hmi485txyc}, + yctxyc = #{yctxyc}, + gzz = #{gzz}, + gjz = #{gjz}, + zlblmsszcw = #{zlblmsszcw}, + xtcsbpp = #{xtcsbpp}, + dwdybphgj = #{dwdybphgj}, + ddycyyx = #{ddycyyx}, + gdycyyx = #{gdycyyx}, + zlfjyc = #{zlfjyc}, + srqwdkgwc = #{srqwdkgwc}, + wbwdkgwc = #{wbwdkgwc}, + fybyqwdkgwc = #{fybyqwdkgwc}, + dgwdkgwc = #{dgwdkgwc}, + zjjdvc = #{zjjdvc}, + fjjdvc = #{fjjdvc}, + jljdvc = #{jljdvc}, + bwjdvc = #{bwjdvc}, + bmsjt = #{bmsjt}, + kkhrqyc = #{kkhrqyc}, + dwgqpdjgj = #{dwgqpdjgj}, + glmkgwgJ = #{glmkgwgJ}, + dcgy = #{dcgy}, + dcqzqy = #{dcqzqy}, + zlgl = #{zlgl}, + scdyyc = #{scdyyc}, + scdybfhlwtj = #{scdybfhlwtj}, + gzbh = #{gzbh}, + dlbh = #{dlbh}, + nbfjyc = #{nbfjyc}, + zlbxsyc = #{zlbxsyc}, + dczzqy = #{dczzqy}, + dcdygj = #{dcdygj}, + wbfjyc = #{wbfjyc}, + dcfj = #{dcfj}, + dcdybfhcdtj = #{dcdybfhcdtj}, + gzgJ = #{gzgJ}, + zldhmktxyc = #{zldhmktxyc}, + bmsxtgz = #{bmsxtgz}, + bmstxyc = #{bmstxyc}, + bmsgjdyc = #{bmsgjdyc}, + bmsjc = #{bmsjc}, + bmsjf = #{bmsjf}, + bmsdj = #{bmsdj}, + bmsgj = #{bmsgj}, + dgfjyc = #{dgfjyc}, + srqgwgj = #{srqgwgj}, + gzz2 = #{gzz2}, + gjz2 = #{gjz2}, + jlfjsmyc = #{jlfjsmyc}, + zlfjsmyc = #{zlfjsmyc}, + jlkgSmyc = #{jlkgSmyc}, + zlkgSmyc = #{zlkgSmyc}, + yljzyc = #{yljzyc}, + create_by = #{createBy}, + create_time = #{createTime}, + update_by = #{updateBy}, + update_time = #{updateTime}, + remark = #{remark}, + + where id = #{id} + + + + delete from ems_pcs_alarm_data where id = #{id} + + + + delete from ems_pcs_alarm_data where id in + + #{id} + + + \ No newline at end of file diff --git a/ems-system/src/main/resources/mapper/ems/EmsStackAlarmDataMapper.xml b/ems-system/src/main/resources/mapper/ems/EmsStackAlarmDataMapper.xml new file mode 100644 index 0000000..7fa6235 --- /dev/null +++ b/ems-system/src/main/resources/mapper/ems/EmsStackAlarmDataMapper.xml @@ -0,0 +1,571 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + select id, data_timestamp, site_id, device_id, bmsgzzt, jczt, jfzt, dngzddyqyqdgjhz, dngzddyqyzdgjhz, dngzddyqyzzdgjhz, dngzddygyqdgjhz, dngzddygyzdgjhz, dngzddygyzzdgjhz, dngzdglqdgjhz, dngzdglzdgjhz, dngzdglzzdgjhz, dngzjydzdqdgjhz, dngzjydzdzdgjhz, dngzjydzdzzdgjhz, dngzmkqwdqdgjhz, dngzmkqwdzdgjhz, dngzmkqwdzzdgjhz, dngzmkgwdqdgjhz, dngzmkgwdzdgjhz, dngzmkgwdzzdgjhz, dngdtgyqwgjhz, dngdtgyzdgjhz, dngdtgyyzgjhz, dngdtqyqwgjhz, dngdtqyzdgjhz, dngdtqyyzgjhz, dngdtycqwgjhz, dngdtyczdgjhz, dngdtycyzgjhz, dngdtqwqwgjhz, dngdtqwzdgjhz, dngdtqwyzgjhz, dngdtgwqwgjhz, dngdtgwzdgjhz, dngdtgwyzgjhz, dngdtwcqwgjhz, dngdtwczdgjhz, dngdtwcyzgjhz, dtsocdqwgjhz, dtsocdzdgjhz, dtsocdyzgjhz, dtsocgqwgjhz, dtsocgzdgjhz, dtsocgyzgjhz, dtsohdqwgjhz, dtsohdzdgjhz, dtsohdyzgjhz, dtsohgqwgjhz, dtsohgzdgjhz, dtsohgyzgjhz, dngzkslhz, dngckslgjhz, dngzdyyc, dnjcqdkyc, dnjcqbhyc, cdjz, fdjz, bmsxtgjhz, bmsxtgzhz, srin0, srin1, srin2, srin3, yl1, yl2, yl3, yl4, yl5, yl6, yl7, yl8, dngdzgwqwgjhz, dngdzgwzdgjhz, dngdzgwzzdgjhz, dnmkdygyqwgjhz, dnmkdygyzdgjhz, dnmkdygyyzgjhz, dnmkdyqyqwgjhz, dnmkdyqyzdgjhz, dnmkdyqyyzgjhz, dycjsl, wdcjsl, didodi0, didodi1, didodi2, didodi3, didodi4, didodi5, didodi6, didodi7, didodi8, didodi9, didodi10, didodi11, didodi12, kttxsl, create_by, create_time, update_by, update_time, remark from ems_stack_alarm_data + + + + + + + + insert into ems_stack_alarm_data + + data_timestamp, + site_id, + device_id, + bmsgzzt, + jczt, + jfzt, + dngzddyqyqdgjhz, + dngzddyqyzdgjhz, + dngzddyqyzzdgjhz, + dngzddygyqdgjhz, + dngzddygyzdgjhz, + dngzddygyzzdgjhz, + dngzdglqdgjhz, + dngzdglzdgjhz, + dngzdglzzdgjhz, + dngzjydzdqdgjhz, + dngzjydzdzdgjhz, + dngzjydzdzzdgjhz, + dngzmkqwdqdgjhz, + dngzmkqwdzdgjhz, + dngzmkqwdzzdgjhz, + dngzmkgwdqdgjhz, + dngzmkgwdzdgjhz, + dngzmkgwdzzdgjhz, + dngdtgyqwgjhz, + dngdtgyzdgjhz, + dngdtgyyzgjhz, + dngdtqyqwgjhz, + dngdtqyzdgjhz, + dngdtqyyzgjhz, + dngdtycqwgjhz, + dngdtyczdgjhz, + dngdtycyzgjhz, + dngdtqwqwgjhz, + dngdtqwzdgjhz, + dngdtqwyzgjhz, + dngdtgwqwgjhz, + dngdtgwzdgjhz, + dngdtgwyzgjhz, + dngdtwcqwgjhz, + dngdtwczdgjhz, + dngdtwcyzgjhz, + dtsocdqwgjhz, + dtsocdzdgjhz, + dtsocdyzgjhz, + dtsocgqwgjhz, + dtsocgzdgjhz, + dtsocgyzgjhz, + dtsohdqwgjhz, + dtsohdzdgjhz, + dtsohdyzgjhz, + dtsohgqwgjhz, + dtsohgzdgjhz, + dtsohgyzgjhz, + dngzkslhz, + dngckslgjhz, + dngzdyyc, + dnjcqdkyc, + dnjcqbhyc, + cdjz, + fdjz, + bmsxtgjhz, + bmsxtgzhz, + srin0, + srin1, + srin2, + srin3, + yl1, + yl2, + yl3, + yl4, + yl5, + yl6, + yl7, + yl8, + dngdzgwqwgjhz, + dngdzgwzdgjhz, + dngdzgwzzdgjhz, + dnmkdygyqwgjhz, + dnmkdygyzdgjhz, + dnmkdygyyzgjhz, + dnmkdyqyqwgjhz, + dnmkdyqyzdgjhz, + dnmkdyqyyzgjhz, + dycjsl, + wdcjsl, + didodi0, + didodi1, + didodi2, + didodi3, + didodi4, + didodi5, + didodi6, + didodi7, + didodi8, + didodi9, + didodi10, + didodi11, + didodi12, + kttxsl, + create_by, + create_time, + update_by, + update_time, + remark, + + + #{dataTimestamp}, + #{siteId}, + #{deviceId}, + #{bmsgzzt}, + #{jczt}, + #{jfzt}, + #{dngzddyqyqdgjhz}, + #{dngzddyqyzdgjhz}, + #{dngzddyqyzzdgjhz}, + #{dngzddygyqdgjhz}, + #{dngzddygyzdgjhz}, + #{dngzddygyzzdgjhz}, + #{dngzdglqdgjhz}, + #{dngzdglzdgjhz}, + #{dngzdglzzdgjhz}, + #{dngzjydzdqdgjhz}, + #{dngzjydzdzdgjhz}, + #{dngzjydzdzzdgjhz}, + #{dngzmkqwdqdgjhz}, + #{dngzmkqwdzdgjhz}, + #{dngzmkqwdzzdgjhz}, + #{dngzmkgwdqdgjhz}, + #{dngzmkgwdzdgjhz}, + #{dngzmkgwdzzdgjhz}, + #{dngdtgyqwgjhz}, + #{dngdtgyzdgjhz}, + #{dngdtgyyzgjhz}, + #{dngdtqyqwgjhz}, + #{dngdtqyzdgjhz}, + #{dngdtqyyzgjhz}, + #{dngdtycqwgjhz}, + #{dngdtyczdgjhz}, + #{dngdtycyzgjhz}, + #{dngdtqwqwgjhz}, + #{dngdtqwzdgjhz}, + #{dngdtqwyzgjhz}, + #{dngdtgwqwgjhz}, + #{dngdtgwzdgjhz}, + #{dngdtgwyzgjhz}, + #{dngdtwcqwgjhz}, + #{dngdtwczdgjhz}, + #{dngdtwcyzgjhz}, + #{dtsocdqwgjhz}, + #{dtsocdzdgjhz}, + #{dtsocdyzgjhz}, + #{dtsocgqwgjhz}, + #{dtsocgzdgjhz}, + #{dtsocgyzgjhz}, + #{dtsohdqwgjhz}, + #{dtsohdzdgjhz}, + #{dtsohdyzgjhz}, + #{dtsohgqwgjhz}, + #{dtsohgzdgjhz}, + #{dtsohgyzgjhz}, + #{dngzkslhz}, + #{dngckslgjhz}, + #{dngzdyyc}, + #{dnjcqdkyc}, + #{dnjcqbhyc}, + #{cdjz}, + #{fdjz}, + #{bmsxtgjhz}, + #{bmsxtgzhz}, + #{srin0}, + #{srin1}, + #{srin2}, + #{srin3}, + #{yl1}, + #{yl2}, + #{yl3}, + #{yl4}, + #{yl5}, + #{yl6}, + #{yl7}, + #{yl8}, + #{dngdzgwqwgjhz}, + #{dngdzgwzdgjhz}, + #{dngdzgwzzdgjhz}, + #{dnmkdygyqwgjhz}, + #{dnmkdygyzdgjhz}, + #{dnmkdygyyzgjhz}, + #{dnmkdyqyqwgjhz}, + #{dnmkdyqyzdgjhz}, + #{dnmkdyqyyzgjhz}, + #{dycjsl}, + #{wdcjsl}, + #{didodi0}, + #{didodi1}, + #{didodi2}, + #{didodi3}, + #{didodi4}, + #{didodi5}, + #{didodi6}, + #{didodi7}, + #{didodi8}, + #{didodi9}, + #{didodi10}, + #{didodi11}, + #{didodi12}, + #{kttxsl}, + #{createBy}, + #{createTime}, + #{updateBy}, + #{updateTime}, + #{remark}, + + + + + update ems_stack_alarm_data + + data_timestamp = #{dataTimestamp}, + site_id = #{siteId}, + device_id = #{deviceId}, + bmsgzzt = #{bmsgzzt}, + jczt = #{jczt}, + jfzt = #{jfzt}, + dngzddyqyqdgjhz = #{dngzddyqyqdgjhz}, + dngzddyqyzdgjhz = #{dngzddyqyzdgjhz}, + dngzddyqyzzdgjhz = #{dngzddyqyzzdgjhz}, + dngzddygyqdgjhz = #{dngzddygyqdgjhz}, + dngzddygyzdgjhz = #{dngzddygyzdgjhz}, + dngzddygyzzdgjhz = #{dngzddygyzzdgjhz}, + dngzdglqdgjhz = #{dngzdglqdgjhz}, + dngzdglzdgjhz = #{dngzdglzdgjhz}, + dngzdglzzdgjhz = #{dngzdglzzdgjhz}, + dngzjydzdqdgjhz = #{dngzjydzdqdgjhz}, + dngzjydzdzdgjhz = #{dngzjydzdzdgjhz}, + dngzjydzdzzdgjhz = #{dngzjydzdzzdgjhz}, + dngzmkqwdqdgjhz = #{dngzmkqwdqdgjhz}, + dngzmkqwdzdgjhz = #{dngzmkqwdzdgjhz}, + dngzmkqwdzzdgjhz = #{dngzmkqwdzzdgjhz}, + dngzmkgwdqdgjhz = #{dngzmkgwdqdgjhz}, + dngzmkgwdzdgjhz = #{dngzmkgwdzdgjhz}, + dngzmkgwdzzdgjhz = #{dngzmkgwdzzdgjhz}, + dngdtgyqwgjhz = #{dngdtgyqwgjhz}, + dngdtgyzdgjhz = #{dngdtgyzdgjhz}, + dngdtgyyzgjhz = #{dngdtgyyzgjhz}, + dngdtqyqwgjhz = #{dngdtqyqwgjhz}, + dngdtqyzdgjhz = #{dngdtqyzdgjhz}, + dngdtqyyzgjhz = #{dngdtqyyzgjhz}, + dngdtycqwgjhz = #{dngdtycqwgjhz}, + dngdtyczdgjhz = #{dngdtyczdgjhz}, + dngdtycyzgjhz = #{dngdtycyzgjhz}, + dngdtqwqwgjhz = #{dngdtqwqwgjhz}, + dngdtqwzdgjhz = #{dngdtqwzdgjhz}, + dngdtqwyzgjhz = #{dngdtqwyzgjhz}, + dngdtgwqwgjhz = #{dngdtgwqwgjhz}, + dngdtgwzdgjhz = #{dngdtgwzdgjhz}, + dngdtgwyzgjhz = #{dngdtgwyzgjhz}, + dngdtwcqwgjhz = #{dngdtwcqwgjhz}, + dngdtwczdgjhz = #{dngdtwczdgjhz}, + dngdtwcyzgjhz = #{dngdtwcyzgjhz}, + dtsocdqwgjhz = #{dtsocdqwgjhz}, + dtsocdzdgjhz = #{dtsocdzdgjhz}, + dtsocdyzgjhz = #{dtsocdyzgjhz}, + dtsocgqwgjhz = #{dtsocgqwgjhz}, + dtsocgzdgjhz = #{dtsocgzdgjhz}, + dtsocgyzgjhz = #{dtsocgyzgjhz}, + dtsohdqwgjhz = #{dtsohdqwgjhz}, + dtsohdzdgjhz = #{dtsohdzdgjhz}, + dtsohdyzgjhz = #{dtsohdyzgjhz}, + dtsohgqwgjhz = #{dtsohgqwgjhz}, + dtsohgzdgjhz = #{dtsohgzdgjhz}, + dtsohgyzgjhz = #{dtsohgyzgjhz}, + dngzkslhz = #{dngzkslhz}, + dngckslgjhz = #{dngckslgjhz}, + dngzdyyc = #{dngzdyyc}, + dnjcqdkyc = #{dnjcqdkyc}, + dnjcqbhyc = #{dnjcqbhyc}, + cdjz = #{cdjz}, + fdjz = #{fdjz}, + bmsxtgjhz = #{bmsxtgjhz}, + bmsxtgzhz = #{bmsxtgzhz}, + srin0 = #{srin0}, + srin1 = #{srin1}, + srin2 = #{srin2}, + srin3 = #{srin3}, + yl1 = #{yl1}, + yl2 = #{yl2}, + yl3 = #{yl3}, + yl4 = #{yl4}, + yl5 = #{yl5}, + yl6 = #{yl6}, + yl7 = #{yl7}, + yl8 = #{yl8}, + dngdzgwqwgjhz = #{dngdzgwqwgjhz}, + dngdzgwzdgjhz = #{dngdzgwzdgjhz}, + dngdzgwzzdgjhz = #{dngdzgwzzdgjhz}, + dnmkdygyqwgjhz = #{dnmkdygyqwgjhz}, + dnmkdygyzdgjhz = #{dnmkdygyzdgjhz}, + dnmkdygyyzgjhz = #{dnmkdygyyzgjhz}, + dnmkdyqyqwgjhz = #{dnmkdyqyqwgjhz}, + dnmkdyqyzdgjhz = #{dnmkdyqyzdgjhz}, + dnmkdyqyyzgjhz = #{dnmkdyqyyzgjhz}, + dycjsl = #{dycjsl}, + wdcjsl = #{wdcjsl}, + didodi0 = #{didodi0}, + didodi1 = #{didodi1}, + didodi2 = #{didodi2}, + didodi3 = #{didodi3}, + didodi4 = #{didodi4}, + didodi5 = #{didodi5}, + didodi6 = #{didodi6}, + didodi7 = #{didodi7}, + didodi8 = #{didodi8}, + didodi9 = #{didodi9}, + didodi10 = #{didodi10}, + didodi11 = #{didodi11}, + didodi12 = #{didodi12}, + kttxsl = #{kttxsl}, + create_by = #{createBy}, + create_time = #{createTime}, + update_by = #{updateBy}, + update_time = #{updateTime}, + remark = #{remark}, + + where id = #{id} + + + + delete from ems_stack_alarm_data where id = #{id} + + + + delete from ems_stack_alarm_data where id in + + #{id} + + + \ No newline at end of file