Skip to content

S
sample-form-platform
Commit c6ba21e2 authored by 赵啸非's avatar 赵啸非
Browse files
Options

添加设备相关信息

parent fa7b842e
Hide whitespace changes
Inline Side-by-side
Showing with 2980 additions and 1976 deletions
common-lib/src/main/java/com/mortals/xhx/common/pdu/device/DeviceReq.java
View file @ c6ba21e2
package com.mortals.xhx.common.pdu.device;
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
import lombok.Data;
import java.io.Serializable;
......
sample-form-manager/db/add.sql 0 → 100644
View file @ c6ba21e2
-- ----------------------------
2023-06-21
-- ----------------------------
ALTER TABLE mortals_xhx_device
ADD COLUMN `deviceFirmId` bigint(20) DEFAULT NULL COMMENT '设备生产厂商ID' AFTER siteName;
ALTER TABLE mortals_xhx_device
ADD COLUMN `deviceFirmname` varchar(200) DEFAULT NULL COMMENT '设备生产厂商名称' AFTER deviceFirmId;
ALTER TABLE mortals_xhx_device
ADD COLUMN `ip` varchar(64) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL COMMENT '设备访问ip' AFTER deviceFirmname;
ALTER TABLE mortals_xhx_device
ADD COLUMN `port` varchar(64) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL COMMENT '端口' AFTER ip;
ALTER TABLE mortals_xhx_device
ADD COLUMN `enabled` tinyint(2) DEFAULT NULL COMMENT '启用状态 (0.停止，1.启用)' AFTER port;
ALTER TABLE mortals_xhx_device
ADD COLUMN `deviceRemark` varchar(256) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL COMMENT '备注' AFTER enabled;
ALTER TABLE mortals_xhx_device
ADD COLUMN `onlineTime` datetime DEFAULT NULL COMMENT '最近上线时间' AFTER deviceRemark;
ALTER TABLE mortals_xhx_device
ADD COLUMN `offlineTime` datetime DEFAULT NULL COMMENT '最近离线时间' AFTER onlineTime;
\ No newline at end of file
sample-form-manager/src/main/java/com/mortals/xhx/base/framework/aspect/OperlogAspect.java
View file @ c6ba21e2
......@@ -4,8 +4,10 @@ import java.util.Date;
import javax.servlet.http.HttpServletRequest;
import cn.hutool.core.util.StrUtil;
import com.mortals.framework.model.OperateLogPdu;
import com.mortals.framework.service.IMessageProduceService;
import com.mortals.xhx.common.code.OperTypeEnum;
import com.mortals.xhx.system.MessageProducer;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
......@@ -28,7 +30,7 @@ import com.mortals.xhx.base.system.oper.service.OperLogService;
* 操作日志记录
*/
@Component
public class OperlogAspect extends FileLogServiceImpl implements ILogService {
public class OperlogAspect extends FileLogServiceImpl implements ILogService {
private final static Logger logger = LoggerFactory.getLogger(OperlogAspect.class);
......@@ -39,11 +41,19 @@ public class OperlogAspect extends FileLogServiceImpl implements ILogService {
@Override
public void doHandlerLog(String platformMark, Long userId, String userName, String loginName, String requestUrl,
String content, String ip, Date logDate) {
String content, String ip, Date logDate) {
super.doHandlerLog(platformMark, userId, userName, loginName, requestUrl, content, ip, logDate);
if(ObjectUtils.isEmpty(userId)) return;
operLogService.insertOperLog(ip, requestUrl, userId, userName, loginName, content);
int operType = OperTypeEnum.OTHER.getValue();
//判断内容包含
if (StrUtil.contains(content, "查询") || StrUtil.contains(content, "查看")) {
operType = OperTypeEnum.SEARCH.getValue();
} else if (StrUtil.contains(content, "保存") || StrUtil.contains(content, "新增") || StrUtil.contains(content, "修改")) {
operType = OperTypeEnum.SAVE.getValue();
} else if (StrUtil.contains(content, "删除")) {
operType = OperTypeEnum.DELETE.getValue();
}
OperateLogPdu operateLogPdu = new OperateLogPdu();
operateLogPdu.initAttrValue();
operateLogPdu.setIp(ip);
......@@ -54,17 +64,13 @@ public class OperlogAspect extends FileLogServiceImpl implements ILogService {
operateLogPdu.setPlatformMark(platformMark);
operateLogPdu.setLogDate(logDate);
operateLogPdu.setContent(content);
operateLogPdu.setOperType(1);
operateLogPdu.setOperType(operType);
messageProducer.syncOperSend(operateLogPdu);
}
@Override
public void doHandlerLog(String platformMark, String loginName, String requestUrl, String content, String ip) {
// operLogService.insertOperLog(ip, requestUrl, null, "", loginName,
// content);
this.doHandlerLog(platformMark, null, "", loginName, requestUrl, content, ip, new Date());
}
@Pointcut("execution(public * com.mortals.xhx..*Controller.*(..))")
......@@ -79,7 +85,6 @@ public class OperlogAspect extends FileLogServiceImpl implements ILogService {
// url
logger.info("ip[{}]url[{}]", request.getRemoteAddr(), request.getRequestURL());
// 参数第1和第2个参数为HttpServletRequest request, HttpServletResponse
// response
if (joinPoint.getArgs().length > 2) {
logger.info("args={}", joinPoint.getArgs()[2]);
} else {
......
sample-form-manager/src/main/java/com/mortals/xhx/common/code/DeviceMethodEnum.java 0 → 100644
View file @ c6ba21e2
package com.mortals.xhx.common.code;
import java.util.LinkedHashMap;
import java.util.Map;
/**
* 设备请求方式，1：新增，2：修改，3：删除，4：激活，5：启用，6：停用
*
* @author zxfei
*/
public enum DeviceMethodEnum {
ADD(1, "新增"),
UPDATE(2, "修改"),
DEL(3, "删除"),
ACTIVE(4, "激活"),
ENABLED(5, "启用"),
STOP(6, "停用"),
ONLINE(7, "上线"),
OFFLINE(8, "下线")
;
private Integer value;
private String desc;
DeviceMethodEnum(Integer value, String desc) {
this.value = value;
this.desc = desc;
}
public Integer getValue() {
return this.value;
}
public String getDesc() {
return this.desc;
}
public static DeviceMethodEnum getByValue(Integer value) {
for (DeviceMethodEnum deviceTypeEnum : DeviceMethodEnum.values()) {
if (deviceTypeEnum.getValue() == value) {
return deviceTypeEnum;
}
}
return null;
}
/**
* 获取Map集合
*
* @param eItem 不包含项
* @return
*/
public static Map<String, String> getEnumMap(Integer... eItem) {
Map<String, String> resultMap = new LinkedHashMap<>();
for (DeviceMethodEnum item : DeviceMethodEnum.values()) {
try {
boolean hasE = false;
for (Integer e : eItem) {
if (item.getValue() == e) {
hasE = true;
break;
}
}
if (!hasE) {
resultMap.put(item.getValue() + "", item.getDesc());
}
} catch (Exception ex) {
}
}
return resultMap;
}
}
\ No newline at end of file
sample-form-manager/src/main/java/com/mortals/xhx/common/code/EnabledEnum.java 0 → 100644
View file @ c6ba21e2
package com.mortals.xhx.common.code;
import java.util.LinkedHashMap;
import java.util.Map;
/**
* 启用状态 (0.停止，1.启用)枚举类
*
* @author zxfei
*/
public enum EnabledEnum {
停止(0, "停止"),
启用(1, "启用");
private Integer value;
private String desc;
EnabledEnum(Integer value, String desc) {
this.value = value;
this.desc = desc;
}
public Integer getValue() {
return this.value;
}
public String getDesc() {
return this.desc;
}
public static EnabledEnum getByValue(Integer value) {
for (EnabledEnum enabledEnum : EnabledEnum.values()) {
if (enabledEnum.getValue() == value) {
return enabledEnum;
}
}
return null;
}
/**
* 获取Map集合
*
* @param eItem 不包含项
* @return
*/
public static Map<String, String> getEnumMap(Integer... eItem) {
Map<String, String> resultMap = new LinkedHashMap<>();
for (EnabledEnum item : EnabledEnum.values()) {
try {
boolean hasE = false;
for (Integer e : eItem) {
if (item.getValue() == e) {
hasE = true;
break;
}
}
if (!hasE) {
resultMap.put(item.getValue() + "", item.getDesc());
}
} catch (Exception ex) {
}
}
return resultMap;
}
}
\ No newline at end of file
sample-form-manager/src/main/java/com/mortals/xhx/common/code/OperTypeEnum.java
View file @ c6ba21e2
......@@ -3,20 +3,19 @@ package com.mortals.xhx.common.code;
import java.util.HashMap;
import java.util.Map;
/**
* Created by chendilin on 2018/3/7.
*/
public enum OperTypeEnum {
SAVE(0,"添加"),
UPDATE(1,"更新"),
DELETE(2,"删除"),
OTHER(-1,"其它");
SAVE(0, "添加"),
UPDATE(1, "更新"),
DELETE(2, "删除"),
SEARCH(3, "查询"),
OTHER(-1, "其它");
private int value;
private String msg;
private OperTypeEnum(int value,String msg) {
private OperTypeEnum(int value, String msg) {
this.value = value;
this.msg = msg;
}
......@@ -25,11 +24,11 @@ public enum OperTypeEnum {
return this.value;
}
public static Map<String,String> getEnumMap(){
Map<String,String> resultMap = new HashMap<>();
OperTypeEnum[] operTypeEnum = OperTypeEnum.values();
public static Map<String, String> getEnumMap() {
Map<String, String> resultMap = new HashMap<>();
OperTypeEnum[] operTypeEnum = OperTypeEnum.values();
for (OperTypeEnum typeEnum : operTypeEnum) {
resultMap.put(String.valueOf(typeEnum.value),typeEnum.msg);
resultMap.put(String.valueOf(typeEnum.value), typeEnum.msg);
}
return resultMap;
}
......
sample-form-manager/src/main/java/com/mortals/xhx/module/device/model/DeviceEntity.java
View file @ c6ba21e2
package com.mortals.xhx.module.device.model;
import java.util.Date;
import java.util.List;
import java.util.ArrayList;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.mortals.framework.annotation.Excel;
import com.mortals.framework.model.BaseEntityLong;
import com.mortals.xhx.module.device.model.vo.DeviceVo;
import lombok.Data;
/**
* 设备实体对象
*
* @author zxfei
* @date 2023-02-25
*/
* 设备实体对象
*
* @author zxfei
* @date 2023-06-21
*/
@Data
public class DeviceEntity extends DeviceVo {
private static final long serialVersionUID = 1L;
/**
* 设备id
*/
* 设备id
*/
private Long deviceId;
/**
* 设备名称
*/
* 设备名称
*/
private String deviceName;
/**
* 设备编码
*/
* 设备编码
*/
private String deviceCode;
/**
* 设备的MAC地址
*/
* 设备的MAC地址
*/
private String deviceMac;
/**
* 站点Id
*/
* 站点Id
*/
private Long siteId;
/**
* 站点编号，来源基础服务平台
*/
* 站点编号，来源基础服务平台
*/
private String siteCode;
/**
* 站点名称
*/
* 站点名称
*/
private String siteName;
/**
* 产品编码
*/
* 产品编码
*/
private String productCode;
/**
* 产品名称
*/
* 产品名称
*/
private String productName;
/**
* 设备来源(0.子设备，1.网关设备，2.直连设备)
*/
* 设备来源(0.子设备，1.网关设备，2.直连设备)
*/
private Integer deviceSrc;
/**
* 经度
*/
* 经度
*/
private String lon;
/**
* 纬度
*/
* 纬度
*/
private String lati;
/**
* 负责人
*/
* 负责人
*/
private String leadingOfficial;
/**
* 联系电话
*/
* 联系电话
*/
private String leadingOfficialTelephone;
/**
* 设备状态 (0.未激活，1.离线,2.在线)
*/
* 设备状态 (0.未激活，1.离线,2.在线)
*/
private Integer deviceStatus;
/**
* 备注
*/
* 备注
*/
private String deviceRemark;
/**
* 设备来源(0.旧设备，1.新设备)
*/
* 设备来源(0.旧设备，1.新设备)
*/
private Integer source;
public DeviceEntity(){}
/**
* 获取 设备id
* @return Long
*/
public Long getDeviceId(){
return deviceId;
}
/**
* 设置 设备id
* @param deviceId
*/
public void setDeviceId(Long deviceId){
this.deviceId = deviceId;
}
/**
* 获取 设备名称
* @return String
*/
public String getDeviceName(){
return deviceName;
}
/**
* 设置 设备名称
* @param deviceName
*/
public void setDeviceName(String deviceName){
this.deviceName = deviceName;
}
/**
* 获取 设备编码
* @return String
*/
public String getDeviceCode(){
return deviceCode;
}
/**
* 设置 设备编码
* @param deviceCode
*/
public void setDeviceCode(String deviceCode){
this.deviceCode = deviceCode;
}
/**
* 获取 设备的MAC地址
* @return String
*/
public String getDeviceMac(){
return deviceMac;
}
/**
* 设置 设备的MAC地址
* @param deviceMac
*/
public void setDeviceMac(String deviceMac){
this.deviceMac = deviceMac;
}
/**
* 获取 站点Id
* @return Long
*/
public Long getSiteId(){
return siteId;
}
/**
* 设置 站点Id
* @param siteId
*/
public void setSiteId(Long siteId){
this.siteId = siteId;
}
/**
* 获取 站点编号，来源基础服务平台
* @return String
*/
public String getSiteCode(){
return siteCode;
}
/**
* 设置 站点编号，来源基础服务平台
* @param siteCode
*/
public void setSiteCode(String siteCode){
this.siteCode = siteCode;
}
/**
* 获取 站点名称
* @return String
*/
public String getSiteName(){
return siteName;
}
/**
* 设置 站点名称
* @param siteName
*/
public void setSiteName(String siteName){
this.siteName = siteName;
}
* 设备生产厂商ID
*/
private Long deviceFirmId;
/**
* 获取 产品编码
* @return String
*/
public String getProductCode(){
return productCode;
}
/**
* 设置 产品编码
* @param productCode
*/
public void setProductCode(String productCode){
this.productCode = productCode;
}
* 设备生产厂商名称
*/
private String deviceFirmname;
/**
* 获取 产品名称
* @return String
*/
public String getProductName(){
return productName;
}
* 设备访问ip
*/
private String ip;
/**
* 设置 产品名称
* @param productName
*/
public void setProductName(String productName){
this.productName = productName;
}
* 端口
*/
private String port;
/**
* 获取 设备来源(0.子设备，1.网关设备，2.直连设备)
* @return Integer
*/
public Integer getDeviceSrc(){
return deviceSrc;
}
* 启用状态 (0.停止，1.启用)
*/
private Integer enabled;
/**
* 设置 设备来源(0.子设备，1.网关设备，2.直连设备)
* @param deviceSrc
*/
public void setDeviceSrc(Integer deviceSrc){
this.deviceSrc = deviceSrc;
}
* 最近上线时间
*/
private Date onlineTime;
/**
* 获取 经度
* @return String
*/
public String getLon(){
return lon;
}
/**
* 设置 经度
* @param lon
*/
public void setLon(String lon){
this.lon = lon;
}
/**
* 获取 纬度
* @return String
*/
public String getLati(){
return lati;
}
/**
* 设置 纬度
* @param lati
*/
public void setLati(String lati){
this.lati = lati;
}
/**
* 获取 负责人
* @return String
*/
public String getLeadingOfficial(){
return leadingOfficial;
}
/**
* 设置 负责人
* @param leadingOfficial
*/
public void setLeadingOfficial(String leadingOfficial){
this.leadingOfficial = leadingOfficial;
}
/**
* 获取 联系电话
* @return String
*/
public String getLeadingOfficialTelephone(){
return leadingOfficialTelephone;
}
/**
* 设置 联系电话
* @param leadingOfficialTelephone
*/
public void setLeadingOfficialTelephone(String leadingOfficialTelephone){
this.leadingOfficialTelephone = leadingOfficialTelephone;
}
/**
* 获取 设备状态 (0.未激活，1.离线,2.在线)
* @return Integer
*/
public Integer getDeviceStatus(){
return deviceStatus;
}
/**
* 设置 设备状态 (0.未激活，1.离线,2.在线)
* @param deviceStatus
*/
public void setDeviceStatus(Integer deviceStatus){
this.deviceStatus = deviceStatus;
}
/**
* 获取 备注
* @return String
*/
public String getDeviceRemark(){
return deviceRemark;
}
/**
* 设置 备注
* @param deviceRemark
*/
public void setDeviceRemark(String deviceRemark){
this.deviceRemark = deviceRemark;
}
/**
* 获取 设备来源(0.旧设备，1.新设备)
* @return Integer
*/
public Integer getSource(){
return source;
}
/**
* 设置 设备来源(0.旧设备，1.新设备)
* @param source
*/
public void setSource(Integer source){
this.source = source;
}
* 最近离线时间
*/
private Date offlineTime;
@Override
public int hashCode() {
return this.getId().hashCode();
return this.getId().hashCode();
}
@Override
public boolean equals(Object obj) {
......@@ -340,68 +123,60 @@ public class DeviceEntity extends DeviceVo {
if (obj instanceof DeviceEntity) {
DeviceEntity tmp = (DeviceEntity) obj;
if (this.getId() == tmp.getId()) {
return true;
return true;
}
}
return false;
}
public String toString(){
StringBuilder sb = new StringBuilder("");
sb.append(",deviceId:").append(getDeviceId());
sb.append(",deviceName:").append(getDeviceName());
sb.append(",deviceCode:").append(getDeviceCode());
sb.append(",deviceMac:").append(getDeviceMac());
sb.append(",siteId:").append(getSiteId());
sb.append(",siteCode:").append(getSiteCode());
sb.append(",siteName:").append(getSiteName());
sb.append(",productCode:").append(getProductCode());
sb.append(",productName:").append(getProductName());
sb.append(",deviceSrc:").append(getDeviceSrc());
sb.append(",lon:").append(getLon());
sb.append(",lati:").append(getLati());
sb.append(",leadingOfficial:").append(getLeadingOfficial());
sb.append(",leadingOfficialTelephone:").append(getLeadingOfficialTelephone());
sb.append(",deviceStatus:").append(getDeviceStatus());
sb.append(",deviceRemark:").append(getDeviceRemark());
sb.append(",source:").append(getSource());
return sb.toString();
}
public void initAttrValue(){
this.deviceId = null;
this.deviceId = -1L;
this.deviceName = "";
this.deviceCode = "";
this.deviceMac = "";
this.siteId = -1L;
this.siteCode = "";
this.siteName = "";
this.productCode = "";
this.deviceName = null;
this.productName = "";
this.deviceCode = null;
this.deviceSrc = 2;
this.deviceMac = null;
this.lon = "";
this.siteId = null;
this.lati = "";
this.siteCode = null;
this.leadingOfficial = "";
this.siteName = null;
this.leadingOfficialTelephone = "";
this.productCode = null;
this.deviceStatus = 0;
this.productName = null;
this.deviceRemark = "";
this.deviceSrc = 2;
this.source = 1;
this.lon = null;
this.deviceFirmId = -1L;
this.lati = null;
this.deviceFirmname = "";
this.leadingOfficial = null;
this.ip = "";
this.leadingOfficialTelephone = null;
this.port = "";
this.deviceStatus = null;
this.enabled = 0;
this.deviceRemark = null;
this.onlineTime = null;
this.source = 1;
this.offlineTime = null;
}
}
\ No newline at end of file
sample-form-manager/src/main/java/com/mortals/xhx/module/device/model/DeviceQuery.java
View file @ c6ba21e2
package com.mortals.xhx.module.device.model;
import java.util.Date;
import java.util.List;
import com.mortals.xhx.module.device.model.DeviceEntity;
/**
* 设备查询对象
*
* @author zxfei
* @date 2023-02-25
*/
* 设备查询对象
*
* @author zxfei
* @date 2023-06-21
*/
public class DeviceQuery extends DeviceEntity {
/** 开始 主键ID，主键，自增长 */
private Long idStart;
......@@ -201,6 +202,63 @@ public class DeviceQuery extends DeviceEntity {
/** 结束 更新时间 */
private String updateTimeEnd;
/** 开始 设备生产厂商ID */
private Long deviceFirmIdStart;
/** 结束 设备生产厂商ID */
private Long deviceFirmIdEnd;
/** 增加 设备生产厂商ID */
private Long deviceFirmIdIncrement;
/** 设备生产厂商ID列表 */
private List <Long> deviceFirmIdList;
/** 设备生产厂商ID排除列表 */
private List <Long> deviceFirmIdNotList;
/** 设备生产厂商名称 */
private List<String> deviceFirmnameList;
/** 设备生产厂商名称排除列表 */
private List <String> deviceFirmnameNotList;
/** 设备访问ip */
private List<String> ipList;
/** 设备访问ip排除列表 */
private List <String> ipNotList;
/** 端口 */
private List<String> portList;
/** 端口排除列表 */
private List <String> portNotList;
/** 开始 启用状态 (0.停止，1.启用) */
private Integer enabledStart;
/** 结束 启用状态 (0.停止，1.启用) */
private Integer enabledEnd;
/** 增加 启用状态 (0.停止，1.启用) */
private Integer enabledIncrement;
/** 启用状态 (0.停止，1.启用)列表 */
private List <Integer> enabledList;
/** 启用状态 (0.停止，1.启用)排除列表 */
private List <Integer> enabledNotList;
/** 开始 最近上线时间 */
private String onlineTimeStart;
/** 结束 最近上线时间 */
private String onlineTimeEnd;
/** 开始 最近离线时间 */
private String offlineTimeStart;
/** 结束 最近离线时间 */
private String offlineTimeEnd;
/** OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4) */
private List<DeviceQuery> orConditionList;
......@@ -210,1791 +268,2280 @@ public class DeviceQuery extends DeviceEntity {
public DeviceQuery(){}
/**
* 获取 开始 主键ID，主键，自增长
* @return idStart
*/
* 获取 开始 主键ID，主键，自增长
* @return idStart
*/
public Long getIdStart(){
return this.idStart;
}
/**
* 设置 开始 主键ID，主键，自增长
* @param idStart
*/
* 设置 开始 主键ID，主键，自增长
* @param idStart
*/
public void setIdStart(Long idStart){
this.idStart = idStart;
}
/**
* 获取 结束 主键ID，主键，自增长
* @return $idEnd
*/
* 获取 结束 主键ID，主键，自增长
* @return $idEnd
*/
public Long getIdEnd(){
return this.idEnd;
}
/**
* 设置 结束 主键ID，主键，自增长
* @param idEnd
*/
* 设置 结束 主键ID，主键，自增长
* @param idEnd
*/
public void setIdEnd(Long idEnd){
this.idEnd = idEnd;
}
/**
* 获取 增加 主键ID，主键，自增长
* @return idIncrement
*/
* 获取 增加 主键ID，主键，自增长
* @return idIncrement
*/
public Long getIdIncrement(){
return this.idIncrement;
}
/**
* 设置 增加 主键ID，主键，自增长
* @param idIncrement
*/
* 设置 增加 主键ID，主键，自增长
* @param idIncrement
*/
public void setIdIncrement(Long idIncrement){
this.idIncrement = idIncrement;
}
/**
* 获取 主键ID，主键，自增长
* @return idList
*/
* 获取 主键ID，主键，自增长
* @return idList
*/
public List<Long> getIdList(){
return this.idList;
}
/**
* 设置 主键ID，主键，自增长
* @param idList
*/
* 设置 主键ID，主键，自增长
* @param idList
*/
public void setIdList(List<Long> idList){
this.idList = idList;
}
/**
* 获取 主键ID，主键，自增长
* @return idNotList
*/
* 获取 主键ID，主键，自增长
* @return idNotList
*/
public List<Long> getIdNotList(){
return this.idNotList;
}
/**
* 设置 主键ID，主键，自增长
* @param idNotList
*/
* 设置 主键ID，主键，自增长
* @param idNotList
*/
public void setIdNotList(List<Long> idNotList){
this.idNotList = idNotList;
}
/**
* 获取 开始 设备id
* @return deviceIdStart
*/
* 获取 开始 设备id
* @return deviceIdStart
*/
public Long getDeviceIdStart(){
return this.deviceIdStart;
}
/**
* 设置 开始 设备id
* @param deviceIdStart
*/
* 设置 开始 设备id
* @param deviceIdStart
*/
public void setDeviceIdStart(Long deviceIdStart){
this.deviceIdStart = deviceIdStart;
}
/**
* 获取 结束 设备id
* @return $deviceIdEnd
*/
* 获取 结束 设备id
* @return $deviceIdEnd
*/
public Long getDeviceIdEnd(){
return this.deviceIdEnd;
}
/**
* 设置 结束 设备id
* @param deviceIdEnd
*/
* 设置 结束 设备id
* @param deviceIdEnd
*/
public void setDeviceIdEnd(Long deviceIdEnd){
this.deviceIdEnd = deviceIdEnd;
}
/**
* 获取 增加 设备id
* @return deviceIdIncrement
*/
* 获取 增加 设备id
* @return deviceIdIncrement
*/
public Long getDeviceIdIncrement(){
return this.deviceIdIncrement;
}
/**
* 设置 增加 设备id
* @param deviceIdIncrement
*/
* 设置 增加 设备id
* @param deviceIdIncrement
*/
public void setDeviceIdIncrement(Long deviceIdIncrement){
this.deviceIdIncrement = deviceIdIncrement;
}
/**
* 获取 设备id
* @return deviceIdList
*/
* 获取 设备id
* @return deviceIdList
*/
public List<Long> getDeviceIdList(){
return this.deviceIdList;
}
/**
* 设置 设备id
* @param deviceIdList
*/
* 设置 设备id
* @param deviceIdList
*/
public void setDeviceIdList(List<Long> deviceIdList){
this.deviceIdList = deviceIdList;
}
/**
* 获取 设备id
* @return deviceIdNotList
*/
* 获取 设备id
* @return deviceIdNotList
*/
public List<Long> getDeviceIdNotList(){
return this.deviceIdNotList;
}
/**
* 设置 设备id
* @param deviceIdNotList
*/
* 设置 设备id
* @param deviceIdNotList
*/
public void setDeviceIdNotList(List<Long> deviceIdNotList){
this.deviceIdNotList = deviceIdNotList;
}
/**
* 获取 设备名称
* @return deviceNameList
*/
* 获取 设备名称
* @return deviceNameList
*/
public List<String> getDeviceNameList(){
return this.deviceNameList;
}
/**
* 设置 设备名称
* @param deviceNameList
*/
* 设置 设备名称
* @param deviceNameList
*/
public void setDeviceNameList(List<String> deviceNameList){
this.deviceNameList = deviceNameList;
}
/**
* 获取 设备名称
* @return deviceNameNotList
*/
* 获取 设备名称
* @return deviceNameNotList
*/
public List<String> getDeviceNameNotList(){
return this.deviceNameNotList;
}
/**
* 设置 设备名称
* @param deviceNameNotList
*/
* 设置 设备名称
* @param deviceNameNotList
*/
public void setDeviceNameNotList(List<String> deviceNameNotList){
this.deviceNameNotList = deviceNameNotList;
}
/**
* 获取 设备编码
* @return deviceCodeList
*/
* 获取 设备编码
* @return deviceCodeList
*/
public List<String> getDeviceCodeList(){
return this.deviceCodeList;
}
/**
* 设置 设备编码
* @param deviceCodeList
*/
* 设置 设备编码
* @param deviceCodeList
*/
public void setDeviceCodeList(List<String> deviceCodeList){
this.deviceCodeList = deviceCodeList;
}
/**
* 获取 设备编码
* @return deviceCodeNotList
*/
* 获取 设备编码
* @return deviceCodeNotList
*/
public List<String> getDeviceCodeNotList(){
return this.deviceCodeNotList;
}
/**
* 设置 设备编码
* @param deviceCodeNotList
*/
* 设置 设备编码
* @param deviceCodeNotList
*/
public void setDeviceCodeNotList(List<String> deviceCodeNotList){
this.deviceCodeNotList = deviceCodeNotList;
}
/**
* 获取 设备的MAC地址
* @return deviceMacList
*/
* 获取 设备的MAC地址
* @return deviceMacList
*/
public List<String> getDeviceMacList(){
return this.deviceMacList;
}
/**
* 设置 设备的MAC地址
* @param deviceMacList
*/
* 设置 设备的MAC地址
* @param deviceMacList
*/
public void setDeviceMacList(List<String> deviceMacList){
this.deviceMacList = deviceMacList;
}
/**
* 获取 设备的MAC地址
* @return deviceMacNotList
*/
* 获取 设备的MAC地址
* @return deviceMacNotList
*/
public List<String> getDeviceMacNotList(){
return this.deviceMacNotList;
}
/**
* 设置 设备的MAC地址
* @param deviceMacNotList
*/
* 设置 设备的MAC地址
* @param deviceMacNotList
*/
public void setDeviceMacNotList(List<String> deviceMacNotList){
this.deviceMacNotList = deviceMacNotList;
}
/**
* 获取 开始 站点Id
* @return siteIdStart
*/
* 获取 开始 站点Id
* @return siteIdStart
*/
public Long getSiteIdStart(){
return this.siteIdStart;
}
/**
* 设置 开始 站点Id
* @param siteIdStart
*/
* 设置 开始 站点Id
* @param siteIdStart
*/
public void setSiteIdStart(Long siteIdStart){
this.siteIdStart = siteIdStart;
}
/**
* 获取 结束 站点Id
* @return $siteIdEnd
*/
* 获取 结束 站点Id
* @return $siteIdEnd
*/
public Long getSiteIdEnd(){
return this.siteIdEnd;
}
/**
* 设置 结束 站点Id
* @param siteIdEnd
*/
* 设置 结束 站点Id
* @param siteIdEnd
*/
public void setSiteIdEnd(Long siteIdEnd){
this.siteIdEnd = siteIdEnd;
}
/**
* 获取 增加 站点Id
* @return siteIdIncrement
*/
* 获取 增加 站点Id
* @return siteIdIncrement
*/
public Long getSiteIdIncrement(){
return this.siteIdIncrement;
}
/**
* 设置 增加 站点Id
* @param siteIdIncrement
*/
* 设置 增加 站点Id
* @param siteIdIncrement
*/
public void setSiteIdIncrement(Long siteIdIncrement){
this.siteIdIncrement = siteIdIncrement;
}
/**
* 获取 站点Id
* @return siteIdList
*/
* 获取 站点Id
* @return siteIdList
*/
public List<Long> getSiteIdList(){
return this.siteIdList;
}
/**
* 设置 站点Id
* @param siteIdList
*/
* 设置 站点Id
* @param siteIdList
*/
public void setSiteIdList(List<Long> siteIdList){
this.siteIdList = siteIdList;
}
/**
* 获取 站点Id
* @return siteIdNotList
*/
* 获取 站点Id
* @return siteIdNotList
*/
public List<Long> getSiteIdNotList(){
return this.siteIdNotList;
}
/**
* 设置 站点Id
* @param siteIdNotList
*/
* 设置 站点Id
* @param siteIdNotList
*/
public void setSiteIdNotList(List<Long> siteIdNotList){
this.siteIdNotList = siteIdNotList;
}
/**
* 获取 站点编号，来源基础服务平台
* @return siteCodeList
*/
* 获取 站点编号，来源基础服务平台
* @return siteCodeList
*/
public List<String> getSiteCodeList(){
return this.siteCodeList;
}
/**
* 设置 站点编号，来源基础服务平台
* @param siteCodeList
*/
* 设置 站点编号，来源基础服务平台
* @param siteCodeList
*/
public void setSiteCodeList(List<String> siteCodeList){
this.siteCodeList = siteCodeList;
}
/**
* 获取 站点编号，来源基础服务平台
* @return siteCodeNotList
*/
* 获取 站点编号，来源基础服务平台
* @return siteCodeNotList
*/
public List<String> getSiteCodeNotList(){
return this.siteCodeNotList;
}
/**
* 设置 站点编号，来源基础服务平台
* @param siteCodeNotList
*/
* 设置 站点编号，来源基础服务平台
* @param siteCodeNotList
*/
public void setSiteCodeNotList(List<String> siteCodeNotList){
this.siteCodeNotList = siteCodeNotList;
}
/**
* 获取 站点名称
* @return siteNameList
*/
* 获取 站点名称
* @return siteNameList
*/
public List<String> getSiteNameList(){
return this.siteNameList;
}
/**
* 设置 站点名称
* @param siteNameList
*/
* 设置 站点名称
* @param siteNameList
*/
public void setSiteNameList(List<String> siteNameList){
this.siteNameList = siteNameList;
}
/**
* 获取 站点名称
* @return siteNameNotList
*/
* 获取 站点名称
* @return siteNameNotList
*/
public List<String> getSiteNameNotList(){
return this.siteNameNotList;
}
/**
* 设置 站点名称
* @param siteNameNotList
*/
* 设置 站点名称
* @param siteNameNotList
*/
public void setSiteNameNotList(List<String> siteNameNotList){
this.siteNameNotList = siteNameNotList;
}
/**
* 获取 产品编码
* @return productCodeList
*/
* 获取 产品编码
* @return productCodeList
*/
public List<String> getProductCodeList(){
return this.productCodeList;
}
/**
* 设置 产品编码
* @param productCodeList
*/
* 设置 产品编码
* @param productCodeList
*/
public void setProductCodeList(List<String> productCodeList){
this.productCodeList = productCodeList;
}
/**
* 获取 产品编码
* @return productCodeNotList
*/
* 获取 产品编码
* @return productCodeNotList
*/
public List<String> getProductCodeNotList(){
return this.productCodeNotList;
}
/**
* 设置 产品编码
* @param productCodeNotList
*/
* 设置 产品编码
* @param productCodeNotList
*/
public void setProductCodeNotList(List<String> productCodeNotList){
this.productCodeNotList = productCodeNotList;
}
/**
* 获取 产品名称
* @return productNameList
*/
* 获取 产品名称
* @return productNameList
*/
public List<String> getProductNameList(){
return this.productNameList;
}
/**
* 设置 产品名称
* @param productNameList
*/
* 设置 产品名称
* @param productNameList
*/
public void setProductNameList(List<String> productNameList){
this.productNameList = productNameList;
}
/**
* 获取 产品名称
* @return productNameNotList
*/
* 获取 产品名称
* @return productNameNotList
*/
public List<String> getProductNameNotList(){
return this.productNameNotList;
}
/**
* 设置 产品名称
* @param productNameNotList
*/
* 设置 产品名称
* @param productNameNotList
*/
public void setProductNameNotList(List<String> productNameNotList){
this.productNameNotList = productNameNotList;
}
/**
* 获取 开始 设备来源(0.子设备，1.网关设备，2.直连设备)
* @return deviceSrcStart
*/
* 获取 开始 设备来源(0.子设备，1.网关设备，2.直连设备)
* @return deviceSrcStart
*/
public Integer getDeviceSrcStart(){
return this.deviceSrcStart;
}
/**
* 设置 开始 设备来源(0.子设备，1.网关设备，2.直连设备)
* @param deviceSrcStart
*/
* 设置 开始 设备来源(0.子设备，1.网关设备，2.直连设备)
* @param deviceSrcStart
*/
public void setDeviceSrcStart(Integer deviceSrcStart){
this.deviceSrcStart = deviceSrcStart;
}
/**
* 获取 结束 设备来源(0.子设备，1.网关设备，2.直连设备)
* @return $deviceSrcEnd
*/
* 获取 结束 设备来源(0.子设备，1.网关设备，2.直连设备)
* @return $deviceSrcEnd
*/
public Integer getDeviceSrcEnd(){
return this.deviceSrcEnd;
}
/**
* 设置 结束 设备来源(0.子设备，1.网关设备，2.直连设备)
* @param deviceSrcEnd
*/
* 设置 结束 设备来源(0.子设备，1.网关设备，2.直连设备)
* @param deviceSrcEnd
*/
public void setDeviceSrcEnd(Integer deviceSrcEnd){
this.deviceSrcEnd = deviceSrcEnd;
}
/**
* 获取 增加 设备来源(0.子设备，1.网关设备，2.直连设备)
* @return deviceSrcIncrement
*/
* 获取 增加 设备来源(0.子设备，1.网关设备，2.直连设备)
* @return deviceSrcIncrement
*/
public Integer getDeviceSrcIncrement(){
return this.deviceSrcIncrement;
}
/**
* 设置 增加 设备来源(0.子设备，1.网关设备，2.直连设备)
* @param deviceSrcIncrement
*/
* 设置 增加 设备来源(0.子设备，1.网关设备，2.直连设备)
* @param deviceSrcIncrement
*/
public void setDeviceSrcIncrement(Integer deviceSrcIncrement){
this.deviceSrcIncrement = deviceSrcIncrement;
}
/**
* 获取 设备来源(0.子设备，1.网关设备，2.直连设备)
* @return deviceSrcList
*/
* 获取 设备来源(0.子设备，1.网关设备，2.直连设备)
* @return deviceSrcList
*/
public List<Integer> getDeviceSrcList(){
return this.deviceSrcList;
}
/**
* 设置 设备来源(0.子设备，1.网关设备，2.直连设备)
* @param deviceSrcList
*/
* 设置 设备来源(0.子设备，1.网关设备，2.直连设备)
* @param deviceSrcList
*/
public void setDeviceSrcList(List<Integer> deviceSrcList){
this.deviceSrcList = deviceSrcList;
}
/**
* 获取 设备来源(0.子设备，1.网关设备，2.直连设备)
* @return deviceSrcNotList
*/
* 获取 设备来源(0.子设备，1.网关设备，2.直连设备)
* @return deviceSrcNotList
*/
public List<Integer> getDeviceSrcNotList(){
return this.deviceSrcNotList;
}
/**
* 设置 设备来源(0.子设备，1.网关设备，2.直连设备)
* @param deviceSrcNotList
*/
* 设置 设备来源(0.子设备，1.网关设备，2.直连设备)
* @param deviceSrcNotList
*/
public void setDeviceSrcNotList(List<Integer> deviceSrcNotList){
this.deviceSrcNotList = deviceSrcNotList;
}
/**
* 获取 经度
* @return lonList
*/
* 获取 经度
* @return lonList
*/
public List<String> getLonList(){
return this.lonList;
}
/**
* 设置 经度
* @param lonList
*/
* 设置 经度
* @param lonList
*/
public void setLonList(List<String> lonList){
this.lonList = lonList;
}
/**
* 获取 经度
* @return lonNotList
*/
* 获取 经度
* @return lonNotList
*/
public List<String> getLonNotList(){
return this.lonNotList;
}
/**
* 设置 经度
* @param lonNotList
*/
* 设置 经度
* @param lonNotList
*/
public void setLonNotList(List<String> lonNotList){
this.lonNotList = lonNotList;
}
/**
* 获取 纬度
* @return latiList
*/
* 获取 纬度
* @return latiList
*/
public List<String> getLatiList(){
return this.latiList;
}
/**
* 设置 纬度
* @param latiList
*/
* 设置 纬度
* @param latiList
*/
public void setLatiList(List<String> latiList){
this.latiList = latiList;
}
/**
* 获取 纬度
* @return latiNotList
*/
* 获取 纬度
* @return latiNotList
*/
public List<String> getLatiNotList(){
return this.latiNotList;
}
/**
* 设置 纬度
* @param latiNotList
*/
* 设置 纬度
* @param latiNotList
*/
public void setLatiNotList(List<String> latiNotList){
this.latiNotList = latiNotList;
}
/**
* 获取 负责人
* @return leadingOfficialList
*/
* 获取 负责人
* @return leadingOfficialList
*/
public List<String> getLeadingOfficialList(){
return this.leadingOfficialList;
}
/**
* 设置 负责人
* @param leadingOfficialList
*/
* 设置 负责人
* @param leadingOfficialList
*/
public void setLeadingOfficialList(List<String> leadingOfficialList){
this.leadingOfficialList = leadingOfficialList;
}
/**
* 获取 负责人
* @return leadingOfficialNotList
*/
* 获取 负责人
* @return leadingOfficialNotList
*/
public List<String> getLeadingOfficialNotList(){
return this.leadingOfficialNotList;
}
/**
* 设置 负责人
* @param leadingOfficialNotList
*/
* 设置 负责人
* @param leadingOfficialNotList
*/
public void setLeadingOfficialNotList(List<String> leadingOfficialNotList){
this.leadingOfficialNotList = leadingOfficialNotList;
}
/**
* 获取 联系电话
* @return leadingOfficialTelephoneList
*/
* 获取 联系电话
* @return leadingOfficialTelephoneList
*/
public List<String> getLeadingOfficialTelephoneList(){
return this.leadingOfficialTelephoneList;
}
/**
* 设置 联系电话
* @param leadingOfficialTelephoneList
*/
* 设置 联系电话
* @param leadingOfficialTelephoneList
*/
public void setLeadingOfficialTelephoneList(List<String> leadingOfficialTelephoneList){
this.leadingOfficialTelephoneList = leadingOfficialTelephoneList;
}
/**
* 获取 联系电话
* @return leadingOfficialTelephoneNotList
*/
* 获取 联系电话
* @return leadingOfficialTelephoneNotList
*/
public List<String> getLeadingOfficialTelephoneNotList(){
return this.leadingOfficialTelephoneNotList;
}
/**
* 设置 联系电话
* @param leadingOfficialTelephoneNotList
*/
* 设置 联系电话
* @param leadingOfficialTelephoneNotList
*/
public void setLeadingOfficialTelephoneNotList(List<String> leadingOfficialTelephoneNotList){
this.leadingOfficialTelephoneNotList = leadingOfficialTelephoneNotList;
}
/**
* 获取 开始 设备状态 (0.未激活，1.离线,2.在线)
* @return deviceStatusStart
*/
* 获取 开始 设备状态 (0.未激活，1.离线,2.在线)
* @return deviceStatusStart
*/
public Integer getDeviceStatusStart(){
return this.deviceStatusStart;
}
/**
* 设置 开始 设备状态 (0.未激活，1.离线,2.在线)
* @param deviceStatusStart
*/
* 设置 开始 设备状态 (0.未激活，1.离线,2.在线)
* @param deviceStatusStart
*/
public void setDeviceStatusStart(Integer deviceStatusStart){
this.deviceStatusStart = deviceStatusStart;
}
/**
* 获取 结束 设备状态 (0.未激活，1.离线,2.在线)
* @return $deviceStatusEnd
*/
* 获取 结束 设备状态 (0.未激活，1.离线,2.在线)
* @return $deviceStatusEnd
*/
public Integer getDeviceStatusEnd(){
return this.deviceStatusEnd;
}
/**
* 设置 结束 设备状态 (0.未激活，1.离线,2.在线)
* @param deviceStatusEnd
*/
* 设置 结束 设备状态 (0.未激活，1.离线,2.在线)
* @param deviceStatusEnd
*/
public void setDeviceStatusEnd(Integer deviceStatusEnd){
this.deviceStatusEnd = deviceStatusEnd;
}
/**
* 获取 增加 设备状态 (0.未激活，1.离线,2.在线)
* @return deviceStatusIncrement
*/
* 获取 增加 设备状态 (0.未激活，1.离线,2.在线)
* @return deviceStatusIncrement
*/
public Integer getDeviceStatusIncrement(){
return this.deviceStatusIncrement;
}
/**
* 设置 增加 设备状态 (0.未激活，1.离线,2.在线)
* @param deviceStatusIncrement
*/
* 设置 增加 设备状态 (0.未激活，1.离线,2.在线)
* @param deviceStatusIncrement
*/
public void setDeviceStatusIncrement(Integer deviceStatusIncrement){
this.deviceStatusIncrement = deviceStatusIncrement;
}
/**
* 获取 设备状态 (0.未激活，1.离线,2.在线)
* @return deviceStatusList
*/
* 获取 设备状态 (0.未激活，1.离线,2.在线)
* @return deviceStatusList
*/
public List<Integer> getDeviceStatusList(){
return this.deviceStatusList;
}
/**
* 设置 设备状态 (0.未激活，1.离线,2.在线)
* @param deviceStatusList
*/
* 设置 设备状态 (0.未激活，1.离线,2.在线)
* @param deviceStatusList
*/
public void setDeviceStatusList(List<Integer> deviceStatusList){
this.deviceStatusList = deviceStatusList;
}
/**
* 获取 设备状态 (0.未激活，1.离线,2.在线)
* @return deviceStatusNotList
*/
* 获取 设备状态 (0.未激活，1.离线,2.在线)
* @return deviceStatusNotList
*/
public List<Integer> getDeviceStatusNotList(){
return this.deviceStatusNotList;
}
/**
* 设置 设备状态 (0.未激活，1.离线,2.在线)
* @param deviceStatusNotList
*/
* 设置 设备状态 (0.未激活，1.离线,2.在线)
* @param deviceStatusNotList
*/
public void setDeviceStatusNotList(List<Integer> deviceStatusNotList){
this.deviceStatusNotList = deviceStatusNotList;
}
/**
* 获取 备注
* @return deviceRemarkList
*/
* 获取 备注
* @return deviceRemarkList
*/
public List<String> getDeviceRemarkList(){
return this.deviceRemarkList;
}
/**
* 设置 备注
* @param deviceRemarkList
*/
* 设置 备注
* @param deviceRemarkList
*/
public void setDeviceRemarkList(List<String> deviceRemarkList){
this.deviceRemarkList = deviceRemarkList;
}
/**
* 获取 备注
* @return deviceRemarkNotList
*/
* 获取 备注
* @return deviceRemarkNotList
*/
public List<String> getDeviceRemarkNotList(){
return this.deviceRemarkNotList;
}
/**
* 设置 备注
* @param deviceRemarkNotList
*/
* 设置 备注
* @param deviceRemarkNotList
*/
public void setDeviceRemarkNotList(List<String> deviceRemarkNotList){
this.deviceRemarkNotList = deviceRemarkNotList;
}
/**
* 获取 开始 设备来源(0.旧设备，1.新设备)
* @return sourceStart
*/
* 获取 开始 设备来源(0.旧设备，1.新设备)
* @return sourceStart
*/
public Integer getSourceStart(){
return this.sourceStart;
}
/**
* 设置 开始 设备来源(0.旧设备，1.新设备)
* @param sourceStart
*/
* 设置 开始 设备来源(0.旧设备，1.新设备)
* @param sourceStart
*/
public void setSourceStart(Integer sourceStart){
this.sourceStart = sourceStart;
}
/**
* 获取 结束 设备来源(0.旧设备，1.新设备)
* @return $sourceEnd
*/
* 获取 结束 设备来源(0.旧设备，1.新设备)
* @return $sourceEnd
*/
public Integer getSourceEnd(){
return this.sourceEnd;
}
/**
* 设置 结束 设备来源(0.旧设备，1.新设备)
* @param sourceEnd
*/
* 设置 结束 设备来源(0.旧设备，1.新设备)
* @param sourceEnd
*/
public void setSourceEnd(Integer sourceEnd){
this.sourceEnd = sourceEnd;
}
/**
* 获取 增加 设备来源(0.旧设备，1.新设备)
* @return sourceIncrement
*/
* 获取 增加 设备来源(0.旧设备，1.新设备)
* @return sourceIncrement
*/
public Integer getSourceIncrement(){
return this.sourceIncrement;
}
/**
* 设置 增加 设备来源(0.旧设备，1.新设备)
* @param sourceIncrement
*/
* 设置 增加 设备来源(0.旧设备，1.新设备)
* @param sourceIncrement
*/
public void setSourceIncrement(Integer sourceIncrement){
this.sourceIncrement = sourceIncrement;
}
/**
* 获取 设备来源(0.旧设备，1.新设备)
* @return sourceList
*/
* 获取 设备来源(0.旧设备，1.新设备)
* @return sourceList
*/
public List<Integer> getSourceList(){
return this.sourceList;
}
/**
* 设置 设备来源(0.旧设备，1.新设备)
* @param sourceList
*/
* 设置 设备来源(0.旧设备，1.新设备)
* @param sourceList
*/
public void setSourceList(List<Integer> sourceList){
this.sourceList = sourceList;
}
/**
* 获取 设备来源(0.旧设备，1.新设备)
* @return sourceNotList
*/
* 获取 设备来源(0.旧设备，1.新设备)
* @return sourceNotList
*/
public List<Integer> getSourceNotList(){
return this.sourceNotList;
}
/**
* 设置 设备来源(0.旧设备，1.新设备)
* @param sourceNotList
*/
* 设置 设备来源(0.旧设备，1.新设备)
* @param sourceNotList
*/
public void setSourceNotList(List<Integer> sourceNotList){
this.sourceNotList = sourceNotList;
}
/**
* 获取 开始 创建用户
* @return createUserIdStart
*/
* 获取 开始 创建用户
* @return createUserIdStart
*/
public Long getCreateUserIdStart(){
return this.createUserIdStart;
}
/**
* 设置 开始 创建用户
* @param createUserIdStart
*/
* 设置 开始 创建用户
* @param createUserIdStart
*/
public void setCreateUserIdStart(Long createUserIdStart){
this.createUserIdStart = createUserIdStart;
}
/**
* 获取 结束 创建用户
* @return $createUserIdEnd
*/
* 获取 结束 创建用户
* @return $createUserIdEnd
*/
public Long getCreateUserIdEnd(){
return this.createUserIdEnd;
}
/**
* 设置 结束 创建用户
* @param createUserIdEnd
*/
* 设置 结束 创建用户
* @param createUserIdEnd
*/
public void setCreateUserIdEnd(Long createUserIdEnd){
this.createUserIdEnd = createUserIdEnd;
}
/**
* 获取 增加 创建用户
* @return createUserIdIncrement
*/
* 获取 增加 创建用户
* @return createUserIdIncrement
*/
public Long getCreateUserIdIncrement(){
return this.createUserIdIncrement;
}
/**
* 设置 增加 创建用户
* @param createUserIdIncrement
*/
* 设置 增加 创建用户
* @param createUserIdIncrement
*/
public void setCreateUserIdIncrement(Long createUserIdIncrement){
this.createUserIdIncrement = createUserIdIncrement;
}
/**
* 获取 创建用户
* @return createUserIdList
*/
* 获取 创建用户
* @return createUserIdList
*/
public List<Long> getCreateUserIdList(){
return this.createUserIdList;
}
/**
* 设置 创建用户
* @param createUserIdList
*/
* 设置 创建用户
* @param createUserIdList
*/
public void setCreateUserIdList(List<Long> createUserIdList){
this.createUserIdList = createUserIdList;
}
/**
* 获取 创建用户
* @return createUserIdNotList
*/
* 获取 创建用户
* @return createUserIdNotList
*/
public List<Long> getCreateUserIdNotList(){
return this.createUserIdNotList;
}
/**
* 设置 创建用户
* @param createUserIdNotList
*/
* 设置 创建用户
* @param createUserIdNotList
*/
public void setCreateUserIdNotList(List<Long> createUserIdNotList){
this.createUserIdNotList = createUserIdNotList;
}
/**
* 获取 开始 创建时间
* @return createTimeStart
*/
* 获取 开始 创建时间
* @return createTimeStart
*/
public String getCreateTimeStart(){
return this.createTimeStart;
}
/**
* 设置 开始 创建时间
* @param createTimeStart
*/
* 设置 开始 创建时间
* @param createTimeStart
*/
public void setCreateTimeStart(String createTimeStart){
this.createTimeStart = createTimeStart;
}
/**
* 获取 结束 创建时间
* @return createTimeEnd
*/
* 获取 结束 创建时间
* @return createTimeEnd
*/
public String getCreateTimeEnd(){
return this.createTimeEnd;
}
/**
* 设置 结束 创建时间
* @param createTimeEnd
*/
* 设置 结束 创建时间
* @param createTimeEnd
*/
public void setCreateTimeEnd(String createTimeEnd){
this.createTimeEnd = createTimeEnd;
}
/**
* 获取 开始 更新用户
* @return updateUserIdStart
*/
* 获取 开始 更新用户
* @return updateUserIdStart
*/
public Long getUpdateUserIdStart(){
return this.updateUserIdStart;
}
/**
* 设置 开始 更新用户
* @param updateUserIdStart
*/
* 设置 开始 更新用户
* @param updateUserIdStart
*/
public void setUpdateUserIdStart(Long updateUserIdStart){
this.updateUserIdStart = updateUserIdStart;
}
/**
* 获取 结束 更新用户
* @return $updateUserIdEnd
*/
* 获取 结束 更新用户
* @return $updateUserIdEnd
*/
public Long getUpdateUserIdEnd(){
return this.updateUserIdEnd;
}
/**
* 设置 结束 更新用户
* @param updateUserIdEnd
*/
* 设置 结束 更新用户
* @param updateUserIdEnd
*/
public void setUpdateUserIdEnd(Long updateUserIdEnd){
this.updateUserIdEnd = updateUserIdEnd;
}
/**
* 获取 增加 更新用户
* @return updateUserIdIncrement
*/
* 获取 增加 更新用户
* @return updateUserIdIncrement
*/
public Long getUpdateUserIdIncrement(){
return this.updateUserIdIncrement;
}
/**
* 设置 增加 更新用户
* @param updateUserIdIncrement
*/
* 设置 增加 更新用户
* @param updateUserIdIncrement
*/
public void setUpdateUserIdIncrement(Long updateUserIdIncrement){
this.updateUserIdIncrement = updateUserIdIncrement;
}
/**
* 获取 更新用户
* @return updateUserIdList
*/
* 获取 更新用户
* @return updateUserIdList
*/
public List<Long> getUpdateUserIdList(){
return this.updateUserIdList;
}
/**
* 设置 更新用户
* @param updateUserIdList
*/
* 设置 更新用户
* @param updateUserIdList
*/
public void setUpdateUserIdList(List<Long> updateUserIdList){
this.updateUserIdList = updateUserIdList;
}
/**
* 获取 更新用户
* @return updateUserIdNotList
*/
* 获取 更新用户
* @return updateUserIdNotList
*/
public List<Long> getUpdateUserIdNotList(){
return this.updateUserIdNotList;
}
/**
* 设置 更新用户
* @param updateUserIdNotList
*/
* 设置 更新用户
* @param updateUserIdNotList
*/
public void setUpdateUserIdNotList(List<Long> updateUserIdNotList){
this.updateUserIdNotList = updateUserIdNotList;
}
/**
* 获取 开始 更新时间
* @return updateTimeStart
*/
* 获取 开始 更新时间
* @return updateTimeStart
*/
public String getUpdateTimeStart(){
return this.updateTimeStart;
}
/**
* 设置 开始 更新时间
* @param updateTimeStart
*/
* 设置 开始 更新时间
* @param updateTimeStart
*/
public void setUpdateTimeStart(String updateTimeStart){
this.updateTimeStart = updateTimeStart;
}
/**
* 获取 结束 更新时间
* @return updateTimeEnd
*/
* 获取 结束 更新时间
* @return updateTimeEnd
*/
public String getUpdateTimeEnd(){
return this.updateTimeEnd;
}
/**
* 设置 结束 更新时间
* @param updateTimeEnd
*/
* 设置 结束 更新时间
* @param updateTimeEnd
*/
public void setUpdateTimeEnd(String updateTimeEnd){
this.updateTimeEnd = updateTimeEnd;
}
/**
* 设置 主键ID，主键，自增长
* @param id
*/
* 获取 开始 设备生产厂商ID
* @return deviceFirmIdStart
*/
public Long getDeviceFirmIdStart(){
return this.deviceFirmIdStart;
}
/**
* 设置 开始 设备生产厂商ID
* @param deviceFirmIdStart
*/
public void setDeviceFirmIdStart(Long deviceFirmIdStart){
this.deviceFirmIdStart = deviceFirmIdStart;
}
/**
* 获取 结束 设备生产厂商ID
* @return $deviceFirmIdEnd
*/
public Long getDeviceFirmIdEnd(){
return this.deviceFirmIdEnd;
}
/**
* 设置 结束 设备生产厂商ID
* @param deviceFirmIdEnd
*/
public void setDeviceFirmIdEnd(Long deviceFirmIdEnd){
this.deviceFirmIdEnd = deviceFirmIdEnd;
}
/**
* 获取 增加 设备生产厂商ID
* @return deviceFirmIdIncrement
*/
public Long getDeviceFirmIdIncrement(){
return this.deviceFirmIdIncrement;
}
/**
* 设置 增加 设备生产厂商ID
* @param deviceFirmIdIncrement
*/
public void setDeviceFirmIdIncrement(Long deviceFirmIdIncrement){
this.deviceFirmIdIncrement = deviceFirmIdIncrement;
}
/**
* 获取 设备生产厂商ID
* @return deviceFirmIdList
*/
public List<Long> getDeviceFirmIdList(){
return this.deviceFirmIdList;
}
/**
* 设置 设备生产厂商ID
* @param deviceFirmIdList
*/
public void setDeviceFirmIdList(List<Long> deviceFirmIdList){
this.deviceFirmIdList = deviceFirmIdList;
}
/**
* 获取 设备生产厂商ID
* @return deviceFirmIdNotList
*/
public List<Long> getDeviceFirmIdNotList(){
return this.deviceFirmIdNotList;
}
/**
* 设置 设备生产厂商ID
* @param deviceFirmIdNotList
*/
public void setDeviceFirmIdNotList(List<Long> deviceFirmIdNotList){
this.deviceFirmIdNotList = deviceFirmIdNotList;
}
/**
* 获取 设备生产厂商名称
* @return deviceFirmnameList
*/
public List<String> getDeviceFirmnameList(){
return this.deviceFirmnameList;
}
/**
* 设置 设备生产厂商名称
* @param deviceFirmnameList
*/
public void setDeviceFirmnameList(List<String> deviceFirmnameList){
this.deviceFirmnameList = deviceFirmnameList;
}
/**
* 获取 设备生产厂商名称
* @return deviceFirmnameNotList
*/
public List<String> getDeviceFirmnameNotList(){
return this.deviceFirmnameNotList;
}
/**
* 设置 设备生产厂商名称
* @param deviceFirmnameNotList
*/
public void setDeviceFirmnameNotList(List<String> deviceFirmnameNotList){
this.deviceFirmnameNotList = deviceFirmnameNotList;
}
/**
* 获取 设备访问ip
* @return ipList
*/
public List<String> getIpList(){
return this.ipList;
}
/**
* 设置 设备访问ip
* @param ipList
*/
public void setIpList(List<String> ipList){
this.ipList = ipList;
}
/**
* 获取 设备访问ip
* @return ipNotList
*/
public List<String> getIpNotList(){
return this.ipNotList;
}
/**
* 设置 设备访问ip
* @param ipNotList
*/
public void setIpNotList(List<String> ipNotList){
this.ipNotList = ipNotList;
}
/**
* 获取 端口
* @return portList
*/
public List<String> getPortList(){
return this.portList;
}
/**
* 设置 端口
* @param portList
*/
public void setPortList(List<String> portList){
this.portList = portList;
}
/**
* 获取 端口
* @return portNotList
*/
public List<String> getPortNotList(){
return this.portNotList;
}
/**
* 设置 端口
* @param portNotList
*/
public void setPortNotList(List<String> portNotList){
this.portNotList = portNotList;
}
/**
* 获取 开始 启用状态 (0.停止，1.启用)
* @return enabledStart
*/
public Integer getEnabledStart(){
return this.enabledStart;
}
/**
* 设置 开始 启用状态 (0.停止，1.启用)
* @param enabledStart
*/
public void setEnabledStart(Integer enabledStart){
this.enabledStart = enabledStart;
}
/**
* 获取 结束 启用状态 (0.停止，1.启用)
* @return $enabledEnd
*/
public Integer getEnabledEnd(){
return this.enabledEnd;
}
/**
* 设置 结束 启用状态 (0.停止，1.启用)
* @param enabledEnd
*/
public void setEnabledEnd(Integer enabledEnd){
this.enabledEnd = enabledEnd;
}
/**
* 获取 增加 启用状态 (0.停止，1.启用)
* @return enabledIncrement
*/
public Integer getEnabledIncrement(){
return this.enabledIncrement;
}
/**
* 设置 增加 启用状态 (0.停止，1.启用)
* @param enabledIncrement
*/
public void setEnabledIncrement(Integer enabledIncrement){
this.enabledIncrement = enabledIncrement;
}
/**
* 获取 启用状态 (0.停止，1.启用)
* @return enabledList
*/
public List<Integer> getEnabledList(){
return this.enabledList;
}
/**
* 设置 启用状态 (0.停止，1.启用)
* @param enabledList
*/
public void setEnabledList(List<Integer> enabledList){
this.enabledList = enabledList;
}
/**
* 获取 启用状态 (0.停止，1.启用)
* @return enabledNotList
*/
public List<Integer> getEnabledNotList(){
return this.enabledNotList;
}
/**
* 设置 启用状态 (0.停止，1.启用)
* @param enabledNotList
*/
public void setEnabledNotList(List<Integer> enabledNotList){
this.enabledNotList = enabledNotList;
}
/**
* 获取 开始 最近上线时间
* @return onlineTimeStart
*/
public String getOnlineTimeStart(){
return this.onlineTimeStart;
}
/**
* 设置 开始 最近上线时间
* @param onlineTimeStart
*/
public void setOnlineTimeStart(String onlineTimeStart){
this.onlineTimeStart = onlineTimeStart;
}
/**
* 获取 结束 最近上线时间
* @return onlineTimeEnd
*/
public String getOnlineTimeEnd(){
return this.onlineTimeEnd;
}
/**
* 设置 结束 最近上线时间
* @param onlineTimeEnd
*/
public void setOnlineTimeEnd(String onlineTimeEnd){
this.onlineTimeEnd = onlineTimeEnd;
}
/**
* 获取 开始 最近离线时间
* @return offlineTimeStart
*/
public String getOfflineTimeStart(){
return this.offlineTimeStart;
}
/**
* 设置 开始 最近离线时间
* @param offlineTimeStart
*/
public void setOfflineTimeStart(String offlineTimeStart){
this.offlineTimeStart = offlineTimeStart;
}
/**
* 获取 结束 最近离线时间
* @return offlineTimeEnd
*/
public String getOfflineTimeEnd(){
return this.offlineTimeEnd;
}
/**
* 设置 结束 最近离线时间
* @param offlineTimeEnd
*/
public void setOfflineTimeEnd(String offlineTimeEnd){
this.offlineTimeEnd = offlineTimeEnd;
}
/**
* 设置 主键ID，主键，自增长
* @param id
*/
public DeviceQuery id(Long id){
setId(id);
return this;
}
/**
* 设置 开始 主键ID，主键，自增长
* @param idStart
*/
setId(id);
return this;
}
/**
* 设置 开始 主键ID，主键，自增长
* @param idStart
*/
public DeviceQuery idStart(Long idStart){
this.idStart = idStart;
return this;
this.idStart = idStart;
return this;
}
/**
* 设置 结束 主键ID，主键，自增长
* @param idEnd
*/
* 设置 结束 主键ID，主键，自增长
* @param idEnd
*/
public DeviceQuery idEnd(Long idEnd){
this.idEnd = idEnd;
return this;
this.idEnd = idEnd;
return this;
}
/**
* 设置 增加 主键ID，主键，自增长
* @param idIncrement
*/
* 设置 增加 主键ID，主键，自增长
* @param idIncrement
*/
public DeviceQuery idIncrement(Long idIncrement){
this.idIncrement = idIncrement;
return this;
this.idIncrement = idIncrement;
return this;
}
/**
* 设置 主键ID，主键，自增长
* @param idList
*/
* 设置 主键ID，主键，自增长
* @param idList
*/
public DeviceQuery idList(List<Long> idList){
this.idList = idList;
return this;
}
/**
* 设置 主键ID，主键，自增长
* @param idNotList
*/
public DeviceQuery idNotList(List<Long> idNotList){
return this;
}
/**
* 设置 主键ID，主键，自增长
* @param idNotList
*/
public DeviceQuery idNotList(List<Long> idNotList){
this.idNotList = idNotList;
return this;
}
}
/**
* 设置 设备id
* @param deviceId
*/
* 设置 设备id
* @param deviceId
*/
public DeviceQuery deviceId(Long deviceId){
setDeviceId(deviceId);
return this;
}
/**
* 设置 开始 设备id
* @param deviceIdStart
*/
setDeviceId(deviceId);
return this;
}
/**
* 设置 开始 设备id
* @param deviceIdStart
*/
public DeviceQuery deviceIdStart(Long deviceIdStart){
this.deviceIdStart = deviceIdStart;
return this;
this.deviceIdStart = deviceIdStart;
return this;
}
/**
* 设置 结束 设备id
* @param deviceIdEnd
*/
* 设置 结束 设备id
* @param deviceIdEnd
*/
public DeviceQuery deviceIdEnd(Long deviceIdEnd){
this.deviceIdEnd = deviceIdEnd;
return this;
this.deviceIdEnd = deviceIdEnd;
return this;
}
/**
* 设置 增加 设备id
* @param deviceIdIncrement
*/
* 设置 增加 设备id
* @param deviceIdIncrement
*/
public DeviceQuery deviceIdIncrement(Long deviceIdIncrement){
this.deviceIdIncrement = deviceIdIncrement;
return this;
this.deviceIdIncrement = deviceIdIncrement;
return this;
}
/**
* 设置 设备id
* @param deviceIdList
*/
* 设置 设备id
* @param deviceIdList
*/
public DeviceQuery deviceIdList(List<Long> deviceIdList){
this.deviceIdList = deviceIdList;
return this;
}
/**
* 设置 设备id
* @param deviceIdNotList
*/
public DeviceQuery deviceIdNotList(List<Long> deviceIdNotList){
return this;
}
/**
* 设置 设备id
* @param deviceIdNotList
*/
public DeviceQuery deviceIdNotList(List<Long> deviceIdNotList){
this.deviceIdNotList = deviceIdNotList;
return this;
}
}
/**
* 设置 设备名称
* @param deviceName
*/
/**
* 设置 设备名称
* @param deviceName
*/
public DeviceQuery deviceName(String deviceName){
setDeviceName(deviceName);
return this;
return this;
}
/**
* 设置 设备名称
* @param deviceNameList
*/
* 设置 设备名称
* @param deviceNameList
*/
public DeviceQuery deviceNameList(List<String> deviceNameList){
this.deviceNameList = deviceNameList;
return this;
return this;
}
/**
* 设置 设备编码
* @param deviceCode
*/
/**
* 设置 设备编码
* @param deviceCode
*/
public DeviceQuery deviceCode(String deviceCode){
setDeviceCode(deviceCode);
return this;
return this;
}
/**
* 设置 设备编码
* @param deviceCodeList
*/
* 设置 设备编码
* @param deviceCodeList
*/
public DeviceQuery deviceCodeList(List<String> deviceCodeList){
this.deviceCodeList = deviceCodeList;
return this;
return this;
}
/**
* 设置 设备的MAC地址
* @param deviceMac
*/
/**
* 设置 设备的MAC地址
* @param deviceMac
*/
public DeviceQuery deviceMac(String deviceMac){
setDeviceMac(deviceMac);
return this;
return this;
}
/**
* 设置 设备的MAC地址
* @param deviceMacList
*/
* 设置 设备的MAC地址
* @param deviceMacList
*/
public DeviceQuery deviceMacList(List<String> deviceMacList){
this.deviceMacList = deviceMacList;
return this;
return this;
}
/**
* 设置 站点Id
* @param siteId
*/
* 设置 站点Id
* @param siteId
*/
public DeviceQuery siteId(Long siteId){
setSiteId(siteId);
return this;
}
/**
* 设置 开始 站点Id
* @param siteIdStart
*/
setSiteId(siteId);
return this;
}
/**
* 设置 开始 站点Id
* @param siteIdStart
*/
public DeviceQuery siteIdStart(Long siteIdStart){
this.siteIdStart = siteIdStart;
return this;
this.siteIdStart = siteIdStart;
return this;
}
/**
* 设置 结束 站点Id
* @param siteIdEnd
*/
* 设置 结束 站点Id
* @param siteIdEnd
*/
public DeviceQuery siteIdEnd(Long siteIdEnd){
this.siteIdEnd = siteIdEnd;
return this;
this.siteIdEnd = siteIdEnd;
return this;
}
/**
* 设置 增加 站点Id
* @param siteIdIncrement
*/
* 设置 增加 站点Id
* @param siteIdIncrement
*/
public DeviceQuery siteIdIncrement(Long siteIdIncrement){
this.siteIdIncrement = siteIdIncrement;
return this;
this.siteIdIncrement = siteIdIncrement;
return this;
}
/**
* 设置 站点Id
* @param siteIdList
*/
* 设置 站点Id
* @param siteIdList
*/
public DeviceQuery siteIdList(List<Long> siteIdList){
this.siteIdList = siteIdList;
return this;
}
/**
* 设置 站点Id
* @param siteIdNotList
*/
public DeviceQuery siteIdNotList(List<Long> siteIdNotList){
return this;
}
/**
* 设置 站点Id
* @param siteIdNotList
*/
public DeviceQuery siteIdNotList(List<Long> siteIdNotList){
this.siteIdNotList = siteIdNotList;
return this;
}
}
/**
* 设置 站点编号，来源基础服务平台
* @param siteCode
*/
/**
* 设置 站点编号，来源基础服务平台
* @param siteCode
*/
public DeviceQuery siteCode(String siteCode){
setSiteCode(siteCode);
return this;
return this;
}
/**
* 设置 站点编号，来源基础服务平台
* @param siteCodeList
*/
* 设置 站点编号，来源基础服务平台
* @param siteCodeList
*/
public DeviceQuery siteCodeList(List<String> siteCodeList){
this.siteCodeList = siteCodeList;
return this;
return this;
}
/**
* 设置 站点名称
* @param siteName
*/
/**
* 设置 站点名称
* @param siteName
*/
public DeviceQuery siteName(String siteName){
setSiteName(siteName);
return this;
return this;
}
/**
* 设置 站点名称
* @param siteNameList
*/
* 设置 站点名称
* @param siteNameList
*/
public DeviceQuery siteNameList(List<String> siteNameList){
this.siteNameList = siteNameList;
return this;
return this;
}
/**
* 设置 产品编码
* @param productCode
*/
/**
* 设置 产品编码
* @param productCode
*/
public DeviceQuery productCode(String productCode){
setProductCode(productCode);
return this;
return this;
}
/**
* 设置 产品编码
* @param productCodeList
*/
* 设置 产品编码
* @param productCodeList
*/
public DeviceQuery productCodeList(List<String> productCodeList){
this.productCodeList = productCodeList;
return this;
return this;
}
/**
* 设置 产品名称
* @param productName
*/
/**
* 设置 产品名称
* @param productName
*/
public DeviceQuery productName(String productName){
setProductName(productName);
return this;
return this;
}
/**
* 设置 产品名称
* @param productNameList
*/
* 设置 产品名称
* @param productNameList
*/
public DeviceQuery productNameList(List<String> productNameList){
this.productNameList = productNameList;
return this;
return this;
}
/**
* 设置 设备来源(0.子设备，1.网关设备，2.直连设备)
* @param deviceSrc
*/
* 设置 设备来源(0.子设备，1.网关设备，2.直连设备)
* @param deviceSrc
*/
public DeviceQuery deviceSrc(Integer deviceSrc){
setDeviceSrc(deviceSrc);
return this;
}
/**
* 设置 开始 设备来源(0.子设备，1.网关设备，2.直连设备)
* @param deviceSrcStart
*/
setDeviceSrc(deviceSrc);
return this;
}
/**
* 设置 开始 设备来源(0.子设备，1.网关设备，2.直连设备)
* @param deviceSrcStart
*/
public DeviceQuery deviceSrcStart(Integer deviceSrcStart){
this.deviceSrcStart = deviceSrcStart;
return this;
this.deviceSrcStart = deviceSrcStart;
return this;
}
/**
* 设置 结束 设备来源(0.子设备，1.网关设备，2.直连设备)
* @param deviceSrcEnd
*/
* 设置 结束 设备来源(0.子设备，1.网关设备，2.直连设备)
* @param deviceSrcEnd
*/
public DeviceQuery deviceSrcEnd(Integer deviceSrcEnd){
this.deviceSrcEnd = deviceSrcEnd;
return this;
this.deviceSrcEnd = deviceSrcEnd;
return this;
}
/**
* 设置 增加 设备来源(0.子设备，1.网关设备，2.直连设备)
* @param deviceSrcIncrement
*/
* 设置 增加 设备来源(0.子设备，1.网关设备，2.直连设备)
* @param deviceSrcIncrement
*/
public DeviceQuery deviceSrcIncrement(Integer deviceSrcIncrement){
this.deviceSrcIncrement = deviceSrcIncrement;
return this;
this.deviceSrcIncrement = deviceSrcIncrement;
return this;
}
/**
* 设置 设备来源(0.子设备，1.网关设备，2.直连设备)
* @param deviceSrcList
*/
* 设置 设备来源(0.子设备，1.网关设备，2.直连设备)
* @param deviceSrcList
*/
public DeviceQuery deviceSrcList(List<Integer> deviceSrcList){
this.deviceSrcList = deviceSrcList;
return this;
}
/**
* 设置 设备来源(0.子设备，1.网关设备，2.直连设备)
* @param deviceSrcNotList
*/
public DeviceQuery deviceSrcNotList(List<Integer> deviceSrcNotList){
return this;
}
/**
* 设置 设备来源(0.子设备，1.网关设备，2.直连设备)
* @param deviceSrcNotList
*/
public DeviceQuery deviceSrcNotList(List<Integer> deviceSrcNotList){
this.deviceSrcNotList = deviceSrcNotList;
return this;
}
}
/**
* 设置 经度
* @param lon
*/
/**
* 设置 经度
* @param lon
*/
public DeviceQuery lon(String lon){
setLon(lon);
return this;
return this;
}
/**
* 设置 经度
* @param lonList
*/
* 设置 经度
* @param lonList
*/
public DeviceQuery lonList(List<String> lonList){
this.lonList = lonList;
return this;
return this;
}
/**
* 设置 纬度
* @param lati
*/
/**
* 设置 纬度
* @param lati
*/
public DeviceQuery lati(String lati){
setLati(lati);
return this;
return this;
}
/**
* 设置 纬度
* @param latiList
*/
* 设置 纬度
* @param latiList
*/
public DeviceQuery latiList(List<String> latiList){
this.latiList = latiList;
return this;
return this;
}
/**
* 设置 负责人
* @param leadingOfficial
*/
/**
* 设置 负责人
* @param leadingOfficial
*/
public DeviceQuery leadingOfficial(String leadingOfficial){
setLeadingOfficial(leadingOfficial);
return this;
return this;
}
/**
* 设置 负责人
* @param leadingOfficialList
*/
* 设置 负责人
* @param leadingOfficialList
*/
public DeviceQuery leadingOfficialList(List<String> leadingOfficialList){
this.leadingOfficialList = leadingOfficialList;
return this;
return this;
}
/**
* 设置 联系电话
* @param leadingOfficialTelephone
*/
/**
* 设置 联系电话
* @param leadingOfficialTelephone
*/
public DeviceQuery leadingOfficialTelephone(String leadingOfficialTelephone){
setLeadingOfficialTelephone(leadingOfficialTelephone);
return this;
return this;
}
/**
* 设置 联系电话
* @param leadingOfficialTelephoneList
*/
* 设置 联系电话
* @param leadingOfficialTelephoneList
*/
public DeviceQuery leadingOfficialTelephoneList(List<String> leadingOfficialTelephoneList){
this.leadingOfficialTelephoneList = leadingOfficialTelephoneList;
return this;
return this;
}
/**
* 设置 设备状态 (0.未激活，1.离线,2.在线)
* @param deviceStatus
*/
* 设置 设备状态 (0.未激活，1.离线,2.在线)
* @param deviceStatus
*/
public DeviceQuery deviceStatus(Integer deviceStatus){
setDeviceStatus(deviceStatus);
return this;
}
/**
* 设置 开始 设备状态 (0.未激活，1.离线,2.在线)
* @param deviceStatusStart
*/
setDeviceStatus(deviceStatus);
return this;
}
/**
* 设置 开始 设备状态 (0.未激活，1.离线,2.在线)
* @param deviceStatusStart
*/
public DeviceQuery deviceStatusStart(Integer deviceStatusStart){
this.deviceStatusStart = deviceStatusStart;
return this;
this.deviceStatusStart = deviceStatusStart;
return this;
}
/**
* 设置 结束 设备状态 (0.未激活，1.离线,2.在线)
* @param deviceStatusEnd
*/
* 设置 结束 设备状态 (0.未激活，1.离线,2.在线)
* @param deviceStatusEnd
*/
public DeviceQuery deviceStatusEnd(Integer deviceStatusEnd){
this.deviceStatusEnd = deviceStatusEnd;
return this;
this.deviceStatusEnd = deviceStatusEnd;
return this;
}
/**
* 设置 增加 设备状态 (0.未激活，1.离线,2.在线)
* @param deviceStatusIncrement
*/
* 设置 增加 设备状态 (0.未激活，1.离线,2.在线)
* @param deviceStatusIncrement
*/
public DeviceQuery deviceStatusIncrement(Integer deviceStatusIncrement){
this.deviceStatusIncrement = deviceStatusIncrement;
return this;
this.deviceStatusIncrement = deviceStatusIncrement;
return this;
}
/**
* 设置 设备状态 (0.未激活，1.离线,2.在线)
* @param deviceStatusList
*/
* 设置 设备状态 (0.未激活，1.离线,2.在线)
* @param deviceStatusList
*/
public DeviceQuery deviceStatusList(List<Integer> deviceStatusList){
this.deviceStatusList = deviceStatusList;
return this;
}
/**
* 设置 设备状态 (0.未激活，1.离线,2.在线)
* @param deviceStatusNotList
*/
public DeviceQuery deviceStatusNotList(List<Integer> deviceStatusNotList){
return this;
}
/**
* 设置 设备状态 (0.未激活，1.离线,2.在线)
* @param deviceStatusNotList
*/
public DeviceQuery deviceStatusNotList(List<Integer> deviceStatusNotList){
this.deviceStatusNotList = deviceStatusNotList;
return this;
}
}
/**
* 设置 备注
* @param deviceRemark
*/
/**
* 设置 备注
* @param deviceRemark
*/
public DeviceQuery deviceRemark(String deviceRemark){
setDeviceRemark(deviceRemark);
return this;
return this;
}
/**
* 设置 备注
* @param deviceRemarkList
*/
* 设置 备注
* @param deviceRemarkList
*/
public DeviceQuery deviceRemarkList(List<String> deviceRemarkList){
this.deviceRemarkList = deviceRemarkList;
return this;
return this;
}
/**
* 设置 设备来源(0.旧设备，1.新设备)
* @param source
*/
* 设置 设备来源(0.旧设备，1.新设备)
* @param source
*/
public DeviceQuery source(Integer source){
setSource(source);
return this;
}
/**
* 设置 开始 设备来源(0.旧设备，1.新设备)
* @param sourceStart
*/
setSource(source);
return this;
}
/**
* 设置 开始 设备来源(0.旧设备，1.新设备)
* @param sourceStart
*/
public DeviceQuery sourceStart(Integer sourceStart){
this.sourceStart = sourceStart;
return this;
this.sourceStart = sourceStart;
return this;
}
/**
* 设置 结束 设备来源(0.旧设备，1.新设备)
* @param sourceEnd
*/
* 设置 结束 设备来源(0.旧设备，1.新设备)
* @param sourceEnd
*/
public DeviceQuery sourceEnd(Integer sourceEnd){
this.sourceEnd = sourceEnd;
return this;
this.sourceEnd = sourceEnd;
return this;
}
/**
* 设置 增加 设备来源(0.旧设备，1.新设备)
* @param sourceIncrement
*/
* 设置 增加 设备来源(0.旧设备，1.新设备)
* @param sourceIncrement
*/
public DeviceQuery sourceIncrement(Integer sourceIncrement){
this.sourceIncrement = sourceIncrement;
return this;
this.sourceIncrement = sourceIncrement;
return this;
}
/**
* 设置 设备来源(0.旧设备，1.新设备)
* @param sourceList
*/
* 设置 设备来源(0.旧设备，1.新设备)
* @param sourceList
*/
public DeviceQuery sourceList(List<Integer> sourceList){
this.sourceList = sourceList;
return this;
}
/**
* 设置 设备来源(0.旧设备，1.新设备)
* @param sourceNotList
*/
public DeviceQuery sourceNotList(List<Integer> sourceNotList){
return this;
}
/**
* 设置 设备来源(0.旧设备，1.新设备)
* @param sourceNotList
*/
public DeviceQuery sourceNotList(List<Integer> sourceNotList){
this.sourceNotList = sourceNotList;
return this;
}
}
/**
* 设置 创建用户
* @param createUserId
*/
* 设置 创建用户
* @param createUserId
*/
public DeviceQuery createUserId(Long createUserId){
setCreateUserId(createUserId);
return this;
}
/**
* 设置 开始 创建用户
* @param createUserIdStart
*/
setCreateUserId(createUserId);
return this;
}
/**
* 设置 开始 创建用户
* @param createUserIdStart
*/
public DeviceQuery createUserIdStart(Long createUserIdStart){
this.createUserIdStart = createUserIdStart;
return this;
this.createUserIdStart = createUserIdStart;
return this;
}
/**
* 设置 结束 创建用户
* @param createUserIdEnd
*/
* 设置 结束 创建用户
* @param createUserIdEnd
*/
public DeviceQuery createUserIdEnd(Long createUserIdEnd){
this.createUserIdEnd = createUserIdEnd;
return this;
this.createUserIdEnd = createUserIdEnd;
return this;
}
/**
* 设置 增加 创建用户
* @param createUserIdIncrement
*/
* 设置 增加 创建用户
* @param createUserIdIncrement
*/
public DeviceQuery createUserIdIncrement(Long createUserIdIncrement){
this.createUserIdIncrement = createUserIdIncrement;
return this;
this.createUserIdIncrement = createUserIdIncrement;
return this;
}
/**
* 设置 创建用户
* @param createUserIdList
*/
* 设置 创建用户
* @param createUserIdList
*/
public DeviceQuery createUserIdList(List<Long> createUserIdList){
this.createUserIdList = createUserIdList;
return this;
}
/**
* 设置 创建用户
* @param createUserIdNotList
*/
public DeviceQuery createUserIdNotList(List<Long> createUserIdNotList){
return this;
}
/**
* 设置 创建用户
* @param createUserIdNotList
*/
public DeviceQuery createUserIdNotList(List<Long> createUserIdNotList){
this.createUserIdNotList = createUserIdNotList;
return this;
}
}
/**
* 设置 更新用户
* @param updateUserId
*/
* 设置 更新用户
* @param updateUserId
*/
public DeviceQuery updateUserId(Long updateUserId){
setUpdateUserId(updateUserId);
return this;
}
/**
* 设置 开始 更新用户
* @param updateUserIdStart
*/
setUpdateUserId(updateUserId);
return this;
}
/**
* 设置 开始 更新用户
* @param updateUserIdStart
*/
public DeviceQuery updateUserIdStart(Long updateUserIdStart){
this.updateUserIdStart = updateUserIdStart;
return this;
this.updateUserIdStart = updateUserIdStart;
return this;
}
/**
* 设置 结束 更新用户
* @param updateUserIdEnd
*/
* 设置 结束 更新用户
* @param updateUserIdEnd
*/
public DeviceQuery updateUserIdEnd(Long updateUserIdEnd){
this.updateUserIdEnd = updateUserIdEnd;
return this;
this.updateUserIdEnd = updateUserIdEnd;
return this;
}
/**
* 设置 增加 更新用户
* @param updateUserIdIncrement
*/
* 设置 增加 更新用户
* @param updateUserIdIncrement
*/
public DeviceQuery updateUserIdIncrement(Long updateUserIdIncrement){
this.updateUserIdIncrement = updateUserIdIncrement;
return this;
this.updateUserIdIncrement = updateUserIdIncrement;
return this;
}
/**
* 设置 更新用户
* @param updateUserIdList
*/
* 设置 更新用户
* @param updateUserIdList
*/
public DeviceQuery updateUserIdList(List<Long> updateUserIdList){
this.updateUserIdList = updateUserIdList;
return this;
}
/**
* 设置 更新用户
* @param updateUserIdNotList
*/
public DeviceQuery updateUserIdNotList(List<Long> updateUserIdNotList){
return this;
}
/**
* 设置 更新用户
* @param updateUserIdNotList
*/
public DeviceQuery updateUserIdNotList(List<Long> updateUserIdNotList){
this.updateUserIdNotList = updateUserIdNotList;
return this;
}
}
/**
* 设置 设备生产厂商ID
* @param deviceFirmId
*/
public DeviceQuery deviceFirmId(Long deviceFirmId){
setDeviceFirmId(deviceFirmId);
return this;
}
/**
* 设置 开始 设备生产厂商ID
* @param deviceFirmIdStart
*/
public DeviceQuery deviceFirmIdStart(Long deviceFirmIdStart){
this.deviceFirmIdStart = deviceFirmIdStart;
return this;
}
/**
* 设置 结束 设备生产厂商ID
* @param deviceFirmIdEnd
*/
public DeviceQuery deviceFirmIdEnd(Long deviceFirmIdEnd){
this.deviceFirmIdEnd = deviceFirmIdEnd;
return this;
}
/**
* 设置 增加 设备生产厂商ID
* @param deviceFirmIdIncrement
*/
public DeviceQuery deviceFirmIdIncrement(Long deviceFirmIdIncrement){
this.deviceFirmIdIncrement = deviceFirmIdIncrement;
return this;
}
/**
* 设置 设备生产厂商ID
* @param deviceFirmIdList
*/
public DeviceQuery deviceFirmIdList(List<Long> deviceFirmIdList){
this.deviceFirmIdList = deviceFirmIdList;
return this;
}
/**
* 设置 设备生产厂商ID
* @param deviceFirmIdNotList
*/
public DeviceQuery deviceFirmIdNotList(List<Long> deviceFirmIdNotList){
this.deviceFirmIdNotList = deviceFirmIdNotList;
return this;
}
/**
* 设置 设备生产厂商名称
* @param deviceFirmname
*/
public DeviceQuery deviceFirmname(String deviceFirmname){
setDeviceFirmname(deviceFirmname);
return this;
}
/**
* 设置 设备生产厂商名称
* @param deviceFirmnameList
*/
public DeviceQuery deviceFirmnameList(List<String> deviceFirmnameList){
this.deviceFirmnameList = deviceFirmnameList;
return this;
}
/**
* 设置 设备访问ip
* @param ip
*/
public DeviceQuery ip(String ip){
setIp(ip);
return this;
}
/**
* 设置 设备访问ip
* @param ipList
*/
public DeviceQuery ipList(List<String> ipList){
this.ipList = ipList;
return this;
}
/**
* 设置 端口
* @param port
*/
public DeviceQuery port(String port){
setPort(port);
return this;
}
/**
* 设置 端口
* @param portList
*/
public DeviceQuery portList(List<String> portList){
this.portList = portList;
return this;
}
/**
* 设置 启用状态 (0.停止，1.启用)
* @param enabled
*/
public DeviceQuery enabled(Integer enabled){
setEnabled(enabled);
return this;
}
/**
* 设置 开始 启用状态 (0.停止，1.启用)
* @param enabledStart
*/
public DeviceQuery enabledStart(Integer enabledStart){
this.enabledStart = enabledStart;
return this;
}
/**
* 设置 结束 启用状态 (0.停止，1.启用)
* @param enabledEnd
*/
public DeviceQuery enabledEnd(Integer enabledEnd){
this.enabledEnd = enabledEnd;
return this;
}
/**
* 设置 增加 启用状态 (0.停止，1.启用)
* @param enabledIncrement
*/
public DeviceQuery enabledIncrement(Integer enabledIncrement){
this.enabledIncrement = enabledIncrement;
return this;
}
/**
* 设置 启用状态 (0.停止，1.启用)
* @param enabledList
*/
public DeviceQuery enabledList(List<Integer> enabledList){
this.enabledList = enabledList;
return this;
}
/**
* 设置 启用状态 (0.停止，1.启用)
* @param enabledNotList
*/
public DeviceQuery enabledNotList(List<Integer> enabledNotList){
this.enabledNotList = enabledNotList;
return this;
}
/**
* 获取 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
* @return orConditionList
*/
* 获取 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
* @return orConditionList
*/
public List<DeviceQuery> getOrConditionList(){
return this.orConditionList;
return this.orConditionList;
}
/**
* 设置 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
* @param orConditionList
*/
* 设置 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
* @param orConditionList
*/
public void setOrConditionList(List<DeviceQuery> orConditionList){
this.orConditionList = orConditionList;
}
/**
* 获取 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
* @return andConditionList
*/
* 获取 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
* @return andConditionList
*/
public List<DeviceQuery> getAndConditionList(){
return this.andConditionList;
}
/**
* 设置 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
* @param andConditionList
*/
* 设置 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
* @param andConditionList
*/
public void setAndConditionList(List<DeviceQuery> andConditionList){
this.andConditionList = andConditionList;
}
......
sample-form-manager/src/main/java/com/mortals/xhx/module/device/service/DeviceService.java
View file @ c6ba21e2
package com.mortals.xhx.module.device.service;
import com.mortals.framework.model.Context;
import com.mortals.framework.service.ICRUDService;
import com.mortals.xhx.module.device.dao.DeviceDao;
import com.mortals.xhx.module.device.model.DeviceEntity;
/**
* DeviceService
......@@ -11,4 +13,20 @@ import com.mortals.xhx.module.device.model.DeviceEntity;
*/
public interface DeviceService extends ICRUDService<DeviceEntity,Long>{
DeviceDao getDao();
/**
* 设备激活
* @param deviceCode
* @param context
*/
void active(String deviceCode, Context context);
/**
* 设备启用停用
* @param id
* @param context
*/
void deviceEnabled(Long id, Integer status, Context context);
}
\ No newline at end of file
sample-form-manager/src/main/java/com/mortals/xhx/module/device/service/impl/DeviceServiceImpl.java
View file @ c6ba21e2
package com.mortals.xhx.module.device.service.impl;
import com.alibaba.fastjson.JSON;
import com.mortals.framework.common.Rest;
import com.mortals.framework.exception.AppException;
import com.mortals.framework.model.Context;
import com.mortals.framework.service.impl.AbstractCRUDServiceImpl;
import com.mortals.xhx.common.code.DeviceMethodEnum;
import com.mortals.xhx.common.code.DeviceStatusEnum;
import com.mortals.xhx.common.code.EnabledEnum;
import com.mortals.xhx.common.pdu.LoginForm;
import com.mortals.xhx.common.pdu.device.DeviceReq;
import com.mortals.xhx.feign.device.IDeviceFeign;
import com.mortals.xhx.module.device.dao.DeviceDao;
import com.mortals.xhx.module.device.model.DeviceEntity;
import com.mortals.xhx.module.device.model.DeviceQuery;
import com.mortals.xhx.module.device.service.DeviceService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.util.ObjectUtils;
import java.util.Date;
/**
* DeviceService
* 设备 service实现
......@@ -13,6 +31,58 @@ import org.springframework.stereotype.Service;
* @date 2023-02-25
*/
@Service("deviceService")
@Slf4j
public class DeviceServiceImpl extends AbstractCRUDServiceImpl<DeviceDao, DeviceEntity, Long> implements DeviceService {
@Autowired
private IDeviceFeign deviceFeign;
@Value("${token.loginName:'admin'}")
private String loginName;
@Value("${token.password:'admin'}")
private String password;
@Override
public void active(String deviceCode, Context context) {
DeviceEntity deviceEntity = this.selectOne(new DeviceQuery().deviceCode(deviceCode));
if (ObjectUtils.isEmpty(deviceEntity)) throw new AppException("当前设备不存在！");
if (deviceEntity.getDeviceStatus() > DeviceStatusEnum.未激活.getValue())
throw new AppException("当前设备已激活！");
deviceEntity.setDeviceStatus(DeviceStatusEnum.离线.getValue());
deviceEntity.setEnabled(EnabledEnum.启用.getValue());
this.getDao().update(deviceEntity);
String token = getToken();
DeviceReq deviceReq = new DeviceReq();
deviceReq.setReceiveMethod(DeviceMethodEnum.ACTIVE.getValue());
deviceReq.setDeviceCode(deviceCode);
Rest<String> rest = deviceFeign.deviceCall(deviceReq, token);
log.info("激活结果：{}", JSON.toJSONString(rest));
}
@Override
public void deviceEnabled(Long id, Integer enabled, Context context) {
DeviceEntity deviceEntity = this.get(id, context);
if (ObjectUtils.isEmpty(deviceEntity)) throw new AppException("当前设备不存在！");
deviceEntity.setEnabled(enabled);
deviceEntity.setUpdateTime(new Date());
deviceEntity.setUpdateUserId(getContextUserId(context));
this.getDao().update(deviceEntity);
String token = getToken();
DeviceReq deviceReq = new DeviceReq();
deviceReq.setReceiveMethod(DeviceMethodEnum.ENABLED.getValue());
deviceReq.setDeviceCode(deviceEntity.getDeviceCode());
Rest<String> rest = deviceFeign.deviceCall(deviceReq, token);
log.info("启用结果：{}", JSON.toJSONString(rest));
}
private String getToken() {
LoginForm loginForm = new LoginForm();
loginForm.setLoginName(loginName);
loginForm.setPassword(password);
Rest<String> rest = deviceFeign.getToken(loginForm);
String token = rest.getData();
return token;
}
}
\ No newline at end of file
sample-form-manager/src/main/java/com/mortals/xhx/module/device/web/DeviceController.java
View file @ c6ba21e2
package com.mortals.xhx.module.device.web;
import com.alibaba.fastjson.JSON;
import com.mortals.framework.common.Rest;
import com.mortals.framework.exception.AppException;
import com.mortals.framework.web.BaseCRUDJsonBodyMappingController;
import com.mortals.xhx.base.system.param.service.ParamService;
import com.mortals.xhx.common.code.DeviceMethodEnum;
import com.mortals.xhx.common.code.EnabledEnum;
import com.mortals.xhx.common.pdu.LoginForm;
import com.mortals.xhx.common.pdu.device.DeviceReq;
import com.mortals.xhx.feign.device.IDeviceFeign;
import com.mortals.xhx.module.device.model.DeviceQuery;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.ObjectUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.*;
import com.mortals.framework.model.Context;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.mortals.framework.web.BaseCRUDJsonBodyMappingController;
import com.mortals.xhx.module.device.model.DeviceEntity;
import com.mortals.xhx.module.device.service.DeviceService;
import org.apache.commons.lang3.ArrayUtils;
import com.mortals.framework.util.StringUtils;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import com.alibaba.fastjson.JSONObject;
import java.util.Arrays;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import static com.mortals.framework.ap.SysConstains.*;
/**
*
* 设备
*
* @author zxfei
* @date 2023-02-25
*/
* 设备
*
* @author zxfei
* @date 2023-02-25
*/
@RestController
@RequestMapping("device")
public class DeviceController extends BaseCRUDJsonBodyMappingController<DeviceService,DeviceEntity,Long> {
@Slf4j
public class DeviceController extends BaseCRUDJsonBodyMappingController<DeviceService, DeviceEntity, Long> {
@Autowired
private ParamService paramService;
public DeviceController(){
super.setModuleDesc( "设备");
@Autowired
private IDeviceFeign deviceFeign;
@Value("${token.loginName:'admin'}")
private String loginName;
@Value("${token.password:'admin'}")
private String password;
public DeviceController() {
super.setModuleDesc("设备");
}
@Override
protected void init(Map<String, Object> model, Context context) {
this.addDict(model, "deviceSrc", paramService.getParamBySecondOrganize("Device","deviceSrc"));
this.addDict(model, "deviceStatus", paramService.getParamBySecondOrganize("Device","deviceStatus"));
this.addDict(model, "source", paramService.getParamBySecondOrganize("Device","source"));
this.addDict(model, "deviceSrc", paramService.getParamBySecondOrganize("Device", "deviceSrc"));
this.addDict(model, "deviceStatus", paramService.getParamBySecondOrganize("Device", "deviceStatus"));
this.addDict(model, "source", paramService.getParamBySecondOrganize("Device", "source"));
this.addDict(model, "enabled", EnabledEnum.getEnumMap());
super.init(model, context);
}
/**
* 设备激活
*/
@PostMapping(value = "active")
public Rest<Void> deviceActive(@RequestBody DeviceEntity deviceEntity) {
log.info("设备激活：{}", deviceEntity.getDeviceCode());
String busiDesc = this.getModuleDesc() + "设备激活";
Rest<Void> rest = Rest.ok(busiDesc + " 【成功】");
try {
this.service.active(deviceEntity.getDeviceCode(), getContext());
recordSysLog(request, busiDesc + " 【成功】");
} catch (Exception e) {
log.error("设备激活消息", e);
rest = Rest.fail(super.convertException(e));
}
return rest;
}
/**
* 设备启用停用
*/
@PostMapping(value = "enable")
public String deviceEnable(@RequestBody DeviceEntity deviceEntity) {
JSONObject jsonObject = new JSONObject();
Map<String, Object> model = new HashMap<>();
String busiDesc = this.getModuleDesc() + "设备";
try {
this.service.deviceEnabled(deviceEntity.getId(), deviceEntity.getEnabled(), getContext());
recordSysLog(request, busiDesc + EnabledEnum.getByValue(deviceEntity.getEnabled()).getDesc() + " 【成功】");
jsonObject.put(KEY_RESULT_DATA, model);
jsonObject.put(KEY_RESULT_CODE, VALUE_RESULT_SUCCESS);
} catch (Exception e) {
log.error("设备启用停用消息", e);
jsonObject.put(KEY_RESULT_CODE, VALUE_RESULT_FAILURE);
jsonObject.put(KEY_RESULT_MSG, super.convertException(e));
}
return jsonObject.toJSONString();
}
@Override
protected int saveAfter(DeviceEntity entity, Map<String, Object> model, Context context) throws AppException {
if (ObjectUtils.isEmpty(entity.getUpdateTime())) {
String token = getToken();
DeviceReq deviceReq = new DeviceReq();
deviceReq.setReceiveMethod(DeviceMethodEnum.ADD.getValue());
deviceReq.setDeviceName(entity.getDeviceName());
deviceReq.setDeviceCode(entity.getDeviceCode());
deviceReq.setProductCode(entity.getProductCode());
deviceReq.setIp(entity.getIp());
deviceReq.setPort(entity.getPort());
deviceReq.setSiteId(1L);
deviceReq.setSiteCode("511500000000-0001");
deviceReq.setSiteName("宜宾市民中心");
deviceReq.setLeadingOfficial(entity.getLeadingOfficial());
deviceReq.setLeadingOfficialTelephone(entity.getLeadingOfficialTelephone());
deviceReq.setSource(1);
deviceReq.setDeviceStatus(entity.getDeviceStatus());
Rest<String> rest = deviceFeign.deviceCall(deviceReq, token);
log.info("添加结果：{}", JSON.toJSONString(rest));
} else {
String token = getToken();
DeviceReq deviceReq = new DeviceReq();
deviceReq.setReceiveMethod(DeviceMethodEnum.UPDATE.getValue());
deviceReq.setDeviceName(entity.getDeviceName());
deviceReq.setDeviceCode(entity.getDeviceCode());
deviceReq.setProductCode(entity.getProductCode());
deviceReq.setIp(entity.getIp());
deviceReq.setPort(entity.getPort());
deviceReq.setSiteId(1L);
deviceReq.setSiteCode("511500000000-0001");
deviceReq.setSiteName("宜宾市民中心");
deviceReq.setLeadingOfficial(entity.getLeadingOfficial());
deviceReq.setLeadingOfficialTelephone(entity.getLeadingOfficialTelephone());
deviceReq.setSource(1);
deviceReq.setDeviceStatus(entity.getDeviceStatus());
Rest<String> rest = deviceFeign.deviceCall(deviceReq, token);
log.info("更新结果：{}", JSON.toJSONString(rest));
}
return super.saveAfter(entity, model, context);
}
@Override
protected void deleteBefore(Long[] ids, Context context) throws AppException {
super.deleteBefore(ids, context);
String token = getToken();
DeviceQuery deviceQuery = new DeviceQuery();
deviceQuery.setIdList(Arrays.asList(ids));
List<DeviceEntity> deviceEntities = this.service.find(deviceQuery, context);
for (DeviceEntity entity : deviceEntities) {
DeviceReq deviceReq = new DeviceReq();
deviceReq.setReceiveMethod(DeviceMethodEnum.DEL.getValue());
deviceReq.setDeviceCode(entity.getDeviceCode());
Rest<String> rest = deviceFeign.deviceCall(deviceReq, token);
log.info("删除结果：{}", JSON.toJSONString(rest));
}
}
private String getToken() {
LoginForm loginForm = new LoginForm();
loginForm.setLoginName(loginName);
loginForm.setPassword(password);
Rest<String> rest = deviceFeign.getToken(loginForm);
String token = rest.getData();
return token;
}
}
\ No newline at end of file
sample-form-manager/src/main/resources/sqlmap/module/device/DeviceMapper.xml
View file @ c6ba21e2
This source diff could not be displayed because it is too large. You can view the blob instead.
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment