Skip to content

D
device-platform
Commit 5761b10c authored by 赵啸非's avatar 赵啸非
Browse files
Options

修改设备管理

parent 0f289e4a
Hide whitespace changes
Inline Side-by-side
Showing with 2129 additions and 1576 deletions
db/module.sql
View file @ 5761b10c
......@@ -16,6 +16,7 @@ CREATE TABLE mortals_stp_device(
`deviceFirmname` varchar(20) COMMENT '设备生产厂商名称',
`deviceOnlineStatus` tinyint(2) NOT NULL COMMENT '在线状态 (0.离线，1.在线)',
`status` tinyint(2) NOT NULL COMMENT '启用状态 (0.停止，1.启用)',
`deviceSource` tinyint(2) NOT NULL COMMENT '设备来源，为其它时候上线下线通过查询(0.大厅，1.其它)',
`deviceRemark` varchar(256) COMMENT '备注',
`onlineTime` datetime COMMENT '最近上线时间',
`offlineTime` datetime COMMENT '最近离线时间',
......@@ -25,6 +26,7 @@ CREATE TABLE mortals_stp_device(
`updateTime` datetime COMMENT '更新时间',
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='设备';
-- ----------------------------
-- 设备生产厂商表
-- ----------------------------
......
device-manager-ui/admin/src/router.js
View file @ 5761b10c
......@@ -31,9 +31,7 @@ const router = new Router({
builder('site/list', 'system/site/index'),//站点
...restBuilder('device', 'device'),//
...restBuilder('device/log', 'device/log'),//
...restBuilder('firm', 'firm'),//
//以下为基础路由配置
......
device-manager-ui/admin/src/views/device/dialogshow.vue
View file @ 5761b10c
<template>
<!-- 弹出框表单 -->
<el-dialog :title="title" :visible.sync="open" width="80%" append-to-body>
<el-form ref="form" :model="form" :rules="rules" label-width="120px">
<el-row>
<Field :span="20" label="设备名称" prop="deviceName" v-model="form.deviceName" placeholder="请输入设备名称"/>
<Field :span="20" label="设备编码" prop="deviceCode" v-model="form.deviceCode" type="textarea" placeholder="请输入设备编码"/>
<Field :span="20" label="设备类型" prop="deviceType" v-model="form.deviceType" type="select" :enumData="dict.deviceType" placeholder="请选择设备类型"/>
<Field :span="20" label="设备的MAC地址" prop="deviceMac" v-model="form.deviceMac" placeholder="请输入设备的MAC地址"/>
<Field :span="20" label="中心设备编码" v-model="form.centernum" placeholder="请输入中心设备编码"/>
<Field :span="20" disabled label="设备访问ip" v-model="form.ip" />
<Field :span="20" disabled label="端口" v-model="form.port" />
<Field :span="20" disabled label="站点编号" v-model="form.siteNum" />
<Field
<!-- 弹出框表单 -->
<el-dialog :title="title" :visible.sync="open" width="80%" append-to-body>
<el-form ref="form" :model="form" :rules="rules" label-width="120px">
<el-row>
<Field
:span="20"
label="设备名称"
prop="deviceName"
v-model="form.deviceName"
placeholder="请输入设备名称"
/>
<Field
:span="20"
label="设备编码"
prop="deviceCode"
v-model="form.deviceCode"
placeholder="请输入设备编码"
/>
<Field
:span="20"
label="设备的MAC地址"
prop="deviceMac"
v-model="form.deviceMac"
placeholder="请输入设备的MAC地址"
/>
<Field
:span="20"
label="设备类型"
prop="deviceType"
v-model="form.deviceType"
type="select"
:enumData="dict.deviceType"
placeholder="请选择设备类型"
/>
<Field
:span="20"
label="设备生产商："
placeholder="请选择设备生产商"
......@@ -21,134 +43,152 @@
type="select"
:enumData="dict.deviceFirmId"
/>
<Field :span="20" label="备注" prop="deviceRemark" v-model="form.deviceRemark" type="textarea" placeholder="请输入备注"/>
<Field :span="20" label="启用状态 " prop="status" v-model="form.status" type="radio" :enumData="dict.status" placeholder="请选择启用状态 "/>
<Field
:span="20"
label="备注"
prop="deviceRemark"
v-model="form.deviceRemark"
type="textarea"
placeholder="请输入备注"
/>
</el-row>
<Field
:span="20"
label="启用状态 "
prop="status"
v-model="form.status"
type="radio"
:enumData="dict.status"
placeholder="请选择启用状态 "
/>
</el-form>
<div slot="footer" class="dialog-footer">
<el-button type="primary" v-if="pageInfo.type !== 'view'" @click="submitForm">确 定</el-button>
<el-button @click="cancel">取 消</el-button>
</div>
</el-dialog>
<Field
:span="20"
label="设备来源 "
prop="deviceSource"
v-model="form.deviceSource"
type="radio"
:enumData="dict.deviceSource"
placeholder="请选择设备来源"
/>
</el-row>
</el-form>
<div slot="footer" class="dialog-footer">
<el-button
type="primary"
v-if="pageInfo.type !== 'view'"
@click="submitForm"
>确 定</el-button
>
<el-button @click="cancel">取 消</el-button>
</div>
</el-dialog>
</template>
<script>
import form from "@/assets/mixins/formdialog";
import dialogShow from "./dialogshow";
export default {
mixins: [form],
components: {
dialogShow ,
},
data() {
return {
// 遮罩层
loading: true,
// 弹出层标题
title: "设备",
// 是否显示弹出层
open: false,
toString:[
"deviceType",
"deviceOnlineStatus",
"status",
"deviceFirmId"
],
// 表单校验
rules: {
deviceName: [
{required: true,message: "请输入设备名称", trigger: "blur" },
{max: 20,message: "最多只能录入20个字符",trigger: "blur",},
],
deviceType: [
{required: true,message: "请输入设备类型", trigger: "blur" },
],
deviceOnlineStatus: [
{required: true,message: "请输入在线状态 ", trigger: "blur" },
],
status: [
{required: true,message: "请输入启用状态 ", trigger: "blur" },
],
createTime: [
{required: true,message: "请选择创建时间" },
],
}
};
},
import form from "@/assets/mixins/formdialog";
import dialogShow from "./dialogshow";
export default {
mixins: [form],
components: {
dialogShow,
},
data() {
return {
// 遮罩层
loading: true,
// 弹出层标题
title: "设备",
// 是否显示弹出层
open: false,
toString: ["deviceType", "deviceOnlineStatus", "status", "deviceFirmId"],
// 表单校验
rules: {
deviceName: [
{ required: true, message: "请输入设备名称", trigger: "blur" },
{ max: 20, message: "最多只能录入20个字符", trigger: "blur" },
],
deviceType: [
{ required: true, message: "请输入设备类型", trigger: "blur" },
],
deviceOnlineStatus: [
{ required: true, message: "请输入在线状态 ", trigger: "blur" },
],
status: [
{ required: true, message: "请输入启用状态 ", trigger: "blur" },
],
},
};
},
methods: {
/** 编辑 */
edit(row) {
this.reset()
this.query = { id: row.id };
this.urls.currUrl =this.pageInfo.editUrl;;
this.getData();
this.pageInfo.type="edit"
this.title = "修改设备";
},
/** 新增 */
add(row) {
this.reset()
this.query = { id: row.id };
this.urls.currUrl = this.pageInfo.addUrl;
this.getData();
this.pageInfo.type="add"
this.title = "新增设备";
},
/** 查看*/
view(row) {
this.reset()
this.query = { id: row.id };
this.urls.currUrl =this.pageInfo.viewUrl;;
this.getData();
this.pageInfo.type="view"
this.title = "设备详细";
},
/**取消按钮 */
cancel() {
this.open = false;
},
/**获取数据后弹框 */
afterRender(data) {
this.open = true;
},
methods: {
/** 编辑 */
edit(row) {
this.reset();
this.query = { id: row.id };
this.urls.currUrl = this.pageInfo.editUrl;
this.getData();
this.pageInfo.type = "edit";
this.title = "修改设备";
},
/** 新增 */
add(row) {
this.reset();
this.query = { id: row.id };
this.urls.currUrl = this.pageInfo.addUrl;
this.getData();
this.pageInfo.type = "add";
this.title = "新增设备";
},
/** 查看*/
view(row) {
this.reset();
this.query = { id: row.id };
this.urls.currUrl = this.pageInfo.viewUrl;
this.getData();
this.pageInfo.type = "view";
this.title = "设备详细";
},
/**取消按钮 */
cancel() {
this.open = false;
},
/**获取数据后弹框 */
afterRender(data) {
this.open = true;
},
afterSubmit(data) {
this.open = false;
this.$emit("ok");
},
afterSubmit(data) {
this.open = false;
this.$emit("ok");
},
// 表单重置
reset() {
this.form = {
deviceName : "",
deviceCode : "",
deviceType : 1,
deviceMac : "",
ip : "",
centernum : "",
port : "",
siteNum : "",
deviceFirmId : null,
deviceFirmname : "",
deviceOnlineStatus : 0,
status : 0,
deviceRemark : "",
onlineTime : null,
offlineTime : null,
};
this.resetForm("form");
},
resetForm(refName) {
if (this.$refs[refName]) {
this.$refs[refName].resetFields();
}
},
},
};
// 表单重置
reset() {
this.form = {
deviceName: "",
deviceCode: "",
deviceType: 1,
deviceMac: "",
ip: "",
centernum: "",
port: "",
siteNum: "",
deviceFirmId: null,
deviceFirmname: "",
deviceOnlineStatus: 0,
status: 0,
deviceRemark: "",
onlineTime: null,
offlineTime: null,
};
this.resetForm("form");
},
resetForm(refName) {
if (this.$refs[refName]) {
this.$refs[refName].resetFields();
}
},
},
};
</script>
device-manager-ui/admin/src/views/login/authentication.vue
View file @ 5761b10c
......@@ -34,12 +34,12 @@ export default {
},
loginFail(error) {
this.$message.error(error.message || '请登录');
this.$router.replace({
path: '/login',
query: {
redirect: this.redirect,
}
});
// this.$router.replace({
// path: '/login',
// query: {
// redirect: this.redirect,
// }
// });
},
getUrlKey (name) {
......
device-manager/src/main/java/com/mortals/xhx/busiz/req/DeviceReq.java
View file @ 5761b10c
......@@ -10,19 +10,38 @@ import java.io.Serializable;
@Data
public class DeviceReq implements Serializable {
/**
* 行为
*/
private String action;
/**
* 设备编码 唯一
*/
private String devicenum;
/**
* ip地址
*/
private String ip;
/**
* 站点编码
*/
private String sitenum;
/**
* 上传类型
*/
private Integer type;
/**
* 端口
*/
private String port;
/**
* 中心编码
*/
private String centernum;
......
device-manager/src/main/java/com/mortals/xhx/busiz/rsp/DeviceResp.java 0 → 100644
View file @ 5761b10c
package com.mortals.xhx.busiz.rsp;
import lombok.Data;
import java.io.Serializable;
@Data
public class DeviceResp implements Serializable {
/**
* 在线状态(0在线 1离线）
*/
private String isOnLine;
}
device-manager/src/main/java/com/mortals/xhx/busiz/web/DeviceApiController.java
View file @ 5761b10c
......@@ -9,11 +9,14 @@ import com.mortals.xhx.busiz.req.DeviceReq;
import com.mortals.xhx.busiz.rsp.ApiResp;
import com.mortals.xhx.common.code.ApiRespCodeEnum;
import com.mortals.xhx.common.code.DeviceOnlineStatusEnum;
import com.mortals.xhx.common.utils.SendTaskThreadPool;
import com.mortals.xhx.common.utils.UploadTask;
import com.mortals.xhx.module.device.model.DeviceEntity;
import com.mortals.xhx.module.device.model.DeviceLogEntity;
import com.mortals.xhx.module.device.service.DeviceLogService;
import com.mortals.xhx.module.device.service.DeviceService;
import lombok.extern.apachecommons.CommonsLog;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.ObjectUtils;
import org.springframework.web.bind.annotation.PostMapping;
......@@ -29,15 +32,15 @@ import java.util.Date;
* @date: 2021/8/24 20:28
*/
@RestController
@CommonsLog
@Slf4j
@RequestMapping("/api/device")
public class DeviceApiController {
@Autowired
private DeviceLogService deviceLogService;
@Autowired
private DeviceService deviceService;
@Autowired
private SendTaskThreadPool sendTaskThreadPool;
/**
* 设备数据上报
......@@ -47,73 +50,13 @@ public class DeviceApiController {
*/
@PostMapping("upload")
public String upload(DeviceReq req) {
log.info("【设备数据上报】【请求体】--> " + JSONObject.toJSONString(req));
log.debug("【设备数据上报】【请求体】--> " + JSONObject.toJSONString(req));
ApiResp rsp = new ApiResp<>();
rsp.setMsg(ApiRespCodeEnum.SUCCESS.getLabel());
rsp.setCode(ApiRespCodeEnum.SUCCESS.getValue());
try {
//根据设备编码查询设备
DeviceEntity deviceEntity = deviceService.getExtCache(req.getDevicenum());
boolean bool = false;
if (!ObjectUtils.isEmpty(deviceEntity)) {
if (deviceEntity.getDeviceOnlineStatus() == DeviceOnlineStatusEnum.离线.getValue()) {
bool = true;
}
deviceEntity.setOnlineTime(new Date());
deviceEntity.setDeviceOnlineStatus(DeviceOnlineStatusEnum.在线.getValue());
deviceEntity.setIp(req.getIp());
deviceEntity.setPort(req.getPort());
deviceEntity.setSiteNum(req.getSitenum());
deviceEntity.setCenternum(req.getCenternum());
deviceService.update(deviceEntity);
DeviceLogEntity deviceLogEntity = new DeviceLogEntity();
deviceLogEntity.initAttrValue();
deviceLogEntity.setDeviceId(deviceEntity.getId());
deviceLogEntity.setDeviceName(deviceEntity.getDeviceName());
deviceLogEntity.setDeviceNum(deviceEntity.getDeviceCode());
deviceLogEntity.setContent(JSONObject.toJSONString(req));
deviceLogEntity.setCreateTime(new Date());
deviceLogService.save(deviceLogEntity);
if (bool) {
WebSocketUtil.broadcast(SendToAllRequest.TYPE, new SendToAllRequest().setContent(JSON.toJSONString(deviceEntity)));
}
} else {
//新增设备
deviceEntity = new DeviceEntity();
deviceEntity.initAttrValue();
deviceEntity.setDeviceCode(req.getDevicenum());
deviceEntity.setOnlineTime(new Date());
deviceEntity.setDeviceOnlineStatus(DeviceOnlineStatusEnum.在线.getValue());
deviceEntity.setIp(req.getIp());
deviceEntity.setPort(req.getPort());
deviceEntity.setSiteNum(req.getSitenum());
deviceEntity.setCenternum(req.getCenternum());
deviceEntity.setCreateUserId(1L);
deviceEntity.setCreateTime(new Date());
deviceService.save(deviceEntity);
DeviceLogEntity deviceLogEntity = new DeviceLogEntity();
deviceLogEntity.initAttrValue();
deviceLogEntity.setDeviceId(deviceEntity.getId());
deviceLogEntity.setDeviceName(deviceEntity.getDeviceName());
deviceLogEntity.setDeviceNum(deviceEntity.getDeviceCode());
deviceLogEntity.setContent(JSONObject.toJSONString(req));
deviceLogEntity.setCreateTime(new Date());
deviceLogService.save(deviceLogEntity);
WebSocketUtil.broadcast(SendToAllRequest.TYPE, new SendToAllRequest().setContent(JSON.toJSONString(deviceEntity)));
}
} catch (Exception e) {
log.error("接收数据失败", e);
rsp.setCode(ApiRespCodeEnum.FAILED.getValue());
rsp.setMsg(e.getMessage());
return JSON.toJSONString(rsp);
}
log.info("响应【设备数据上报】【响应体】--> " + JSONObject.toJSONString(rsp));
UploadTask uploadTask = new UploadTask(req, deviceLogService, deviceService);
sendTaskThreadPool.execute(uploadTask);
log.debug("响应【设备数据上报】【响应体】--> " + JSONObject.toJSONString(rsp));
return JSON.toJSONString(rsp);
}
......
device-manager/src/main/java/com/mortals/xhx/common/code/DeviceSourceEnum.java 0 → 100644
View file @ 5761b10c
package com.mortals.xhx.common.code;
import java.util.LinkedHashMap;
import java.util.Map;
/**
* 设备来源，为其它时候上线下线通过查询(0.大厅，1.其它)枚举类
*
* @author zxfei
*/
public enum DeviceSourceEnum {
大厅(0, "大厅"),
其它(1, "其它");
private Integer value;
private String desc;
DeviceSourceEnum(Integer value, String desc) {
this.value = value;
this.desc = desc;
}
public Integer getValue() {
return this.value;
}
public String getDesc() {
return this.desc;
}
public static DeviceSourceEnum getByValue(Integer value) {
for (DeviceSourceEnum deviceSourceEnum : DeviceSourceEnum.values()) {
if (deviceSourceEnum.getValue() == value) {
return deviceSourceEnum;
}
}
return null;
}
/**
* 获取Map集合
*
* @param eItem 不包含项
* @return
*/
public static Map<String, String> getEnumMap(Integer... eItem) {
Map<String, String> resultMap = new LinkedHashMap<>();
for (DeviceSourceEnum item : DeviceSourceEnum.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
device-manager/src/main/java/com/mortals/xhx/common/key/ParamKey.java
View file @ 5761b10c
......@@ -28,4 +28,10 @@ public class ParamKey {
*/
public static String SYS_PARAM_USER_URL = "user_url";
/**
* 设备状态查询url
*/
public static String SYS_PARAM_SEND_QUERY_URL = "send_query_url";
}
device-manager/src/main/java/com/mortals/xhx/common/utils/SendTask.java 0 → 100644
View file @ 5761b10c
package com.mortals.xhx.common.utils;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;
import com.mortals.framework.util.HttpUtil;
import com.mortals.xhx.busiz.rsp.ApiResp;
import com.mortals.xhx.busiz.rsp.DeviceResp;
import com.mortals.xhx.common.code.DeviceOnlineStatusEnum;
import com.mortals.xhx.daemon.task.CustomerInfo;
import com.mortals.xhx.module.device.model.DeviceEntity;
import com.mortals.xhx.module.device.service.DeviceService;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import static com.mortals.framework.util.HttpUtil.HEADER_CONTENT_TYPE;
/**
* 发送任务
*
* @author: zxfei
* @date: 2022/4/28 10:56
* @description:
**/
@Slf4j
@AllArgsConstructor
public class SendTask implements Runnable {
private String sendUrl;
private Long deviceId;
private String content;
private DeviceService deviceService;
@Override
public void run() {
try {
Map<String, String> headers = new HashMap<>();
DeviceEntity deviceEntity = new DeviceEntity();
deviceEntity.setId(deviceId);
headers.put(HEADER_CONTENT_TYPE, "application/json");
String resp = HttpUtil.doPost(sendUrl, headers, content);
ApiResp<DeviceResp> apiResp = JSON.parseObject(resp, new TypeReference<ApiResp<DeviceResp>>(){});
if (apiResp.getCode() == 0) {
if (apiResp.getData().getIsOnLine() == "0") {
deviceEntity.setDeviceOnlineStatus(DeviceOnlineStatusEnum.在线.getValue());
deviceEntity.setOnlineTime(new Date());
} else if (apiResp.getData().getIsOnLine() == "1") {
deviceEntity.setDeviceOnlineStatus(DeviceOnlineStatusEnum.离线.getValue());
deviceEntity.setOfflineTime(new Date());
} else {
deviceEntity.setDeviceOnlineStatus(DeviceOnlineStatusEnum.在线.getValue());
deviceEntity.setOnlineTime(new Date());
}
deviceService.update(deviceEntity);
}
log.debug("http resp:{}", resp);
} catch (Exception e) {
log.error("发送异常：" + e);
}
}
}
device-manager/src/main/java/com/mortals/xhx/common/utils/SendTaskThreadPool.java 0 → 100644
View file @ 5761b10c
package com.mortals.xhx.common.utils;
import org.springframework.stereotype.Component;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
/**
* 发送任务线程池
*
* @author: zxfei
* @date: 2022/4/28 10:52
*/
@Component
public class SendTaskThreadPool {
/**
* 线程池
*/
private ThreadPoolExecutor threadPool;
private int poolSize;
private volatile boolean isInit = false;
private Object lock = new Object();
public void init(Integer threadNum) {
if (poolSize < 0) {
throw new IllegalArgumentException();
}
if (poolSize < Runtime.getRuntime().availableProcessors()) {
poolSize = Runtime.getRuntime().availableProcessors() + 1;
}
if (!isInit) {
synchronized (lock) {
if (!isInit) {
threadPool = (ThreadPoolExecutor) Executors.newFixedThreadPool(threadNum);
isInit = true;
}
}
}
}
public void execute(Runnable command) {
threadPool.execute(command);
}
public void setPoolSize(int poolSize) {
threadPool.setCorePoolSize(poolSize);
threadPool.setMaximumPoolSize(poolSize);
}
public void incrementPoolSize(int delta) {
setPoolSize(threadPool.getCorePoolSize() + delta);
}
public synchronized void close() {
if (threadPool != null) {
threadPool.shutdown();
threadPool = null;
isInit = false;
}
}
}
device-manager/src/main/java/com/mortals/xhx/common/utils/UploadTask.java 0 → 100644
View file @ 5761b10c
package com.mortals.xhx.common.utils;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.TypeReference;
import com.mortals.framework.util.HttpUtil;
import com.mortals.xhx.base.framework.ws.message.SendToAllRequest;
import com.mortals.xhx.base.framework.ws.util.WebSocketUtil;
import com.mortals.xhx.busiz.req.DeviceReq;
import com.mortals.xhx.busiz.rsp.ApiResp;
import com.mortals.xhx.busiz.rsp.DeviceResp;
import com.mortals.xhx.common.code.DeviceOnlineStatusEnum;
import com.mortals.xhx.module.device.model.DeviceEntity;
import com.mortals.xhx.module.device.model.DeviceLogEntity;
import com.mortals.xhx.module.device.service.DeviceLogService;
import com.mortals.xhx.module.device.service.DeviceService;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.ObjectUtils;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import static com.mortals.framework.util.HttpUtil.HEADER_CONTENT_TYPE;
/**
* 上报任务
*
* @author: zxfei
* @date: 2022/4/28 10:56
* @description:
**/
@Slf4j
@AllArgsConstructor
public class UploadTask implements Runnable {
private DeviceReq req;
private DeviceLogService deviceLogService;
private DeviceService deviceService;
@Override
public void run() {
try {
DeviceEntity deviceEntity = deviceService.getExtCache(req.getDevicenum());
boolean bool = false;
if (!ObjectUtils.isEmpty(deviceEntity)) {
if (deviceEntity.getDeviceOnlineStatus() == DeviceOnlineStatusEnum.离线.getValue()) {
bool = true;
}
deviceEntity.setOnlineTime(new Date());
deviceEntity.setDeviceOnlineStatus(DeviceOnlineStatusEnum.在线.getValue());
deviceEntity.setIp(req.getIp());
deviceEntity.setPort(req.getPort());
deviceEntity.setSiteNum(req.getSitenum());
deviceEntity.setCenternum(req.getCenternum());
deviceService.update(deviceEntity);
DeviceLogEntity deviceLogEntity = new DeviceLogEntity();
deviceLogEntity.initAttrValue();
deviceLogEntity.setDeviceId(deviceEntity.getId());
deviceLogEntity.setDeviceName(deviceEntity.getDeviceName());
deviceLogEntity.setDeviceNum(deviceEntity.getDeviceCode());
deviceLogEntity.setContent(JSONObject.toJSONString(req));
deviceLogEntity.setCreateTime(new Date());
deviceLogService.save(deviceLogEntity);
if (bool) {
WebSocketUtil.broadcast(SendToAllRequest.TYPE, new SendToAllRequest().setContent(JSON.toJSONString(deviceEntity)));
}
} else {
//新增设备
deviceEntity = new DeviceEntity();
deviceEntity.initAttrValue();
deviceEntity.setDeviceCode(req.getDevicenum());
deviceEntity.setOnlineTime(new Date());
deviceEntity.setDeviceOnlineStatus(DeviceOnlineStatusEnum.在线.getValue());
deviceEntity.setIp(req.getIp());
deviceEntity.setPort(req.getPort());
deviceEntity.setSiteNum(req.getSitenum());
deviceEntity.setCenternum(req.getCenternum());
deviceEntity.setCreateUserId(1L);
deviceEntity.setCreateTime(new Date());
deviceService.save(deviceEntity);
DeviceLogEntity deviceLogEntity = new DeviceLogEntity();
deviceLogEntity.initAttrValue();
deviceLogEntity.setDeviceId(deviceEntity.getId());
deviceLogEntity.setDeviceName(deviceEntity.getDeviceName());
deviceLogEntity.setDeviceNum(deviceEntity.getDeviceCode());
deviceLogEntity.setContent(JSONObject.toJSONString(req));
deviceLogEntity.setCreateTime(new Date());
deviceLogService.save(deviceLogEntity);
WebSocketUtil.broadcast(SendToAllRequest.TYPE, new SendToAllRequest().setContent(JSON.toJSONString(deviceEntity)));
}
} catch (Exception e) {
log.error("异常：" ,e);
}
}
}
device-manager/src/main/java/com/mortals/xhx/daemon/applicationservice/DemoStartService.java
View file @ 5761b10c
package com.mortals.xhx.daemon.applicationservice;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import com.mortals.framework.springcloud.service.IApplicationService;
import com.mortals.xhx.common.utils.SendTaskThreadPool;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import com.mortals.framework.springcloud.service.IApplicationService;
/**
* 应用级服务，在应用启动、停止过程中调用
*
* 缺陷：类加载完成后就调用，会由于某些组件还未初始化而导致服务异常，
* 比如Kafka的连接以及订阅初始化比较靠后，在服务启动过程中就调用操作kafka相关API，将导致失败
* 比如开启Socket监听端口，可能端口都接收到连接请求了，但数据库连接还未初始化完成，导致请求处理失败
* 比如定时任务，任务执行时，相关缓存还未初始化，导致处理失败
*
* 应用场景：
* 1、无依赖其它模块或框架的数据初始化等操作
* @author GM
* @date 2020年7月15日
*/
@Component
@Slf4j
public class DemoStartService implements IApplicationService {
private static Log logger = LogFactory.getLog(DemoStartService.class);
@Autowired
private SendTaskThreadPool sendTaskThreadPool;
@Override
public void start() {
logger.info("开始服务..[配置已加载完成，但部分框架还未初始化，比如：Kafka]");
int coreThreadNum = Runtime.getRuntime().availableProcessors();
sendTaskThreadPool.init(coreThreadNum*2);
log.info("开始服务..[配置已加载完成，但部分框架还未初始化，比如：Kafka]");
}
@Override
public void stop() {
logger.info("停止服务..");
log.info("停止服务..");
}
}
device-manager/src/main/java/com/mortals/xhx/daemon/task/DeviceStatTaskImpl.java
View file @ 5761b10c
package com.mortals.xhx.daemon.task;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.mortals.framework.ap.GlobalSysInfo;
import com.mortals.framework.exception.AppException;
import com.mortals.framework.service.ITask;
......@@ -10,7 +11,10 @@ import com.mortals.xhx.base.framework.ws.message.SendToAllRequest;
import com.mortals.xhx.base.framework.ws.message.UserJoinNoticeRequest;
import com.mortals.xhx.base.framework.ws.util.WebSocketUtil;
import com.mortals.xhx.common.code.DeviceOnlineStatusEnum;
import com.mortals.xhx.common.code.DeviceSourceEnum;
import com.mortals.xhx.common.key.ParamKey;
import com.mortals.xhx.common.utils.SendTask;
import com.mortals.xhx.common.utils.SendTaskThreadPool;
import com.mortals.xhx.module.device.model.DeviceLogEntity;
import com.mortals.xhx.module.device.model.DeviceLogQuery;
import com.mortals.xhx.module.device.service.DeviceLogService;
......@@ -38,12 +42,15 @@ public class DeviceStatTaskImpl implements ITaskExcuteService {
@Autowired
private DeviceLogService deviceLogService;
@Autowired
private SendTaskThreadPool sendTaskThreadPool;
@Override
public void excuteTask(ITask task) throws AppException {
log.debug("设备状态统计，开始执行");
doDeviceUpOrDown();
doDeviceLogDel();
doDeviceQuery();
log.debug("设备状态统计，结束执行");
}
......@@ -56,6 +63,7 @@ public class DeviceStatTaskImpl implements ITaskExcuteService {
try {
//获取所有设备，针对每个设备查询最近指定秒的日志，如果没有则更新下线
deviceService.getCacheList().stream()
.filter(f -> f.getDeviceSource() == DeviceSourceEnum.大厅.getValue())
.filter(f -> f.getDeviceOnlineStatus() == DeviceOnlineStatusEnum.在线.getValue())
.peek(device -> {
DeviceLogQuery query = new DeviceLogQuery();
......@@ -68,14 +76,14 @@ public class DeviceStatTaskImpl implements ITaskExcuteService {
device.setDeviceOnlineStatus(DeviceOnlineStatusEnum.离线.getValue());
deviceService.update(device);
WebSocketUtil.broadcast(SendToAllRequest.TYPE,new SendToAllRequest().setContent(JSON.toJSONString(device)));
WebSocketUtil.broadcast(SendToAllRequest.TYPE, new SendToAllRequest().setContent(JSON.toJSONString(device)));
}
}).count();
} catch (Exception e) {
log.error("更新设备状态任务异常，结束执行", e);
}
log.info("更新设备状态任务，结束执行");
log.debug("更新设备状态任务，结束执行");
}
......@@ -95,7 +103,29 @@ public class DeviceStatTaskImpl implements ITaskExcuteService {
} catch (Exception e) {
log.error("设备日志删除任务异常，结束执行", e);
}
log.info("设备日志删除任务，结束执行");
log.debug("设备日志删除任务，结束执行");
}
/**
* 定时查询更新其它设备状态
*/
private void doDeviceQuery() {
try {
deviceService.getCacheList().parallelStream()
.filter(f -> f.getDeviceSource() == DeviceSourceEnum.其它.getValue())
.peek(device -> {
String sendUrl = GlobalSysInfo.getParamValue(ParamKey.SYS_PARAM_SEND_QUERY_URL,"http://127.0.0.1:18211/m/test/equipStateQuery");
JSONObject jsonObject = new JSONObject();
jsonObject.put("macAddress",device.getDeviceMac());
SendTask sendTask = new SendTask(sendUrl, device.getId(), jsonObject.toJSONString(), deviceService);
sendTaskThreadPool.execute(sendTask);
}).count();
} catch (Exception e) {
log.error("查询设备状态任务异常，结束执行", e);
}
log.debug("查询设备状态任务，结束执行");
}
......
device-manager/src/main/java/com/mortals/xhx/module/device/model/DeviceEntity.java
View file @ 5761b10c
......@@ -8,288 +8,306 @@ import com.mortals.framework.annotation.Excel;
import com.mortals.framework.model.BaseEntityLong;
import com.mortals.xhx.module.device.model.vo.DeviceVo;
/**
* 设备实体对象
*
* @author zxfei
* @date 2022-03-09
*/
* 设备实体对象
*
* @author zxfei
* @date 2022-05-06
*/
public class DeviceEntity extends DeviceVo {
private static final long serialVersionUID = 1L;
/**
* 设备名称
*/
* 设备名称
*/
@Excel(name = "设备名称")
private String deviceName;
/**
* 设备编码
*/
* 设备编码
*/
private String deviceCode;
/**
* 设备类型（1.呼叫器，2.窗口屏, 3.评价器，4.集中屏, 5.排号机，6.im设备, 7.样表设备，8.取件柜, 9.信息发布,10.导视机,11.开标室设备,12.背靠背）
*/
* 设备类型（1.呼叫器，2.窗口屏, 3.评价器，4.集中屏, 5.排号机，6.im设备, 7.样表设备，8.取件柜, 9.信息发布,10.导视机,11.开标室设备,12.背靠背）
*/
private Integer deviceType;
/**
* 设备的MAC地址
*/
* 设备的MAC地址
*/
private String deviceMac;
/**
* 设备访问ip
*/
* 设备访问ip
*/
private String ip;
/**
* 中心设备编码
*/
* 中心设备编码
*/
private String centernum;
/**
* 端口
*/
* 端口
*/
private String port;
/**
* 站点编号
*/
* 站点编号
*/
private String siteNum;
/**
* 设备生产厂商ID
*/
* 设备生产厂商ID
*/
private Long deviceFirmId;
/**
* 设备生产厂商名称
*/
* 设备生产厂商名称
*/
@Excel(name = "设备生产厂商名称")
private String deviceFirmname;
/**
* 在线状态 (0.离线，1.在线)
*/
* 在线状态 (0.离线，1.在线)
*/
private Integer deviceOnlineStatus;
/**
* 启用状态 (0.停止，1.启用)
*/
* 启用状态 (0.停止，1.启用)
*/
private Integer status;
/**
* 备注
*/
* 设备来源，为其它时候上线下线通过查询(0.大厅，1.其它)
*/
private Integer deviceSource;
/**
* 备注
*/
private String deviceRemark;
/**
* 最近上线时间
*/
* 最近上线时间
*/
private Date onlineTime;
/**
* 最近离线时间
*/
* 最近离线时间
*/
private Date offlineTime;
public DeviceEntity(){}
/**
* 获取 设备名称
* @return String
*/
* 获取 设备名称
* @return String
*/
public String getDeviceName(){
return deviceName;
}
/**
* 设置 设备名称
* @param deviceName
*/
* 设置 设备名称
* @param deviceName
*/
public void setDeviceName(String deviceName){
this.deviceName = deviceName;
}
/**
* 获取 设备编码
* @return String
*/
* 获取 设备编码
* @return String
*/
public String getDeviceCode(){
return deviceCode;
}
/**
* 设置 设备编码
* @param deviceCode
*/
* 设置 设备编码
* @param deviceCode
*/
public void setDeviceCode(String deviceCode){
this.deviceCode = deviceCode;
}
/**
* 获取 设备类型（1.呼叫器，2.窗口屏, 3.评价器，4.集中屏, 5.排号机，6.im设备, 7.样表设备，8.取件柜, 9.信息发布,10.导视机,11.开标室设备,12.背靠背）
* @return Integer
*/
* 获取 设备类型（1.呼叫器，2.窗口屏, 3.评价器，4.集中屏, 5.排号机，6.im设备, 7.样表设备，8.取件柜, 9.信息发布,10.导视机,11.开标室设备,12.背靠背）
* @return Integer
*/
public Integer getDeviceType(){
return deviceType;
}
/**
* 设置 设备类型（1.呼叫器，2.窗口屏, 3.评价器，4.集中屏, 5.排号机，6.im设备, 7.样表设备，8.取件柜, 9.信息发布,10.导视机,11.开标室设备,12.背靠背）
* @param deviceType
*/
* 设置 设备类型（1.呼叫器，2.窗口屏, 3.评价器，4.集中屏, 5.排号机，6.im设备, 7.样表设备，8.取件柜, 9.信息发布,10.导视机,11.开标室设备,12.背靠背）
* @param deviceType
*/
public void setDeviceType(Integer deviceType){
this.deviceType = deviceType;
}
/**
* 获取 设备的MAC地址
* @return String
*/
* 获取 设备的MAC地址
* @return String
*/
public String getDeviceMac(){
return deviceMac;
}
/**
* 设置 设备的MAC地址
* @param deviceMac
*/
* 设置 设备的MAC地址
* @param deviceMac
*/
public void setDeviceMac(String deviceMac){
this.deviceMac = deviceMac;
}
/**
* 获取 设备访问ip
* @return String
*/
* 获取 设备访问ip
* @return String
*/
public String getIp(){
return ip;
}
/**
* 设置 设备访问ip
* @param ip
*/
* 设置 设备访问ip
* @param ip
*/
public void setIp(String ip){
this.ip = ip;
}
/**
* 获取 中心设备编码
* @return String
*/
* 获取 中心设备编码
* @return String
*/
public String getCenternum(){
return centernum;
}
/**
* 设置 中心设备编码
* @param centernum
*/
* 设置 中心设备编码
* @param centernum
*/
public void setCenternum(String centernum){
this.centernum = centernum;
}
/**
* 获取 端口
* @return String
*/
* 获取 端口
* @return String
*/
public String getPort(){
return port;
}
/**
* 设置 端口
* @param port
*/
* 设置 端口
* @param port
*/
public void setPort(String port){
this.port = port;
}
/**
* 获取 站点编号
* @return String
*/
* 获取 站点编号
* @return String
*/
public String getSiteNum(){
return siteNum;
}
/**
* 设置 站点编号
* @param siteNum
*/
* 设置 站点编号
* @param siteNum
*/
public void setSiteNum(String siteNum){
this.siteNum = siteNum;
}
/**
* 获取 设备生产厂商ID
* @return Long
*/
* 获取 设备生产厂商ID
* @return Long
*/
public Long getDeviceFirmId(){
return deviceFirmId;
}
/**
* 设置 设备生产厂商ID
* @param deviceFirmId
*/
* 设置 设备生产厂商ID
* @param deviceFirmId
*/
public void setDeviceFirmId(Long deviceFirmId){
this.deviceFirmId = deviceFirmId;
}
/**
* 获取 设备生产厂商名称
* @return String
*/
* 获取 设备生产厂商名称
* @return String
*/
public String getDeviceFirmname(){
return deviceFirmname;
}
/**
* 设置 设备生产厂商名称
* @param deviceFirmname
*/
* 设置 设备生产厂商名称
* @param deviceFirmname
*/
public void setDeviceFirmname(String deviceFirmname){
this.deviceFirmname = deviceFirmname;
}
/**
* 获取 在线状态 (0.离线，1.在线)
* @return Integer
*/
* 获取 在线状态 (0.离线，1.在线)
* @return Integer
*/
public Integer getDeviceOnlineStatus(){
return deviceOnlineStatus;
}
/**
* 设置 在线状态 (0.离线，1.在线)
* @param deviceOnlineStatus
*/
* 设置 在线状态 (0.离线，1.在线)
* @param deviceOnlineStatus
*/
public void setDeviceOnlineStatus(Integer deviceOnlineStatus){
this.deviceOnlineStatus = deviceOnlineStatus;
}
/**
* 获取 启用状态 (0.停止，1.启用)
* @return Integer
*/
* 获取 启用状态 (0.停止，1.启用)
* @return Integer
*/
public Integer getStatus(){
return status;
}
/**
* 设置 启用状态 (0.停止，1.启用)
* @param status
*/
* 设置 启用状态 (0.停止，1.启用)
* @param status
*/
public void setStatus(Integer status){
this.status = status;
}
/**
* 获取 备注
* @return String
*/
* 获取 设备来源，为其它时候上线下线通过查询(0.大厅，1.其它)
* @return Integer
*/
public Integer getDeviceSource(){
return deviceSource;
}
/**
* 设置 设备来源，为其它时候上线下线通过查询(0.大厅，1.其它)
* @param deviceSource
*/
public void setDeviceSource(Integer deviceSource){
this.deviceSource = deviceSource;
}
/**
* 获取 备注
* @return String
*/
public String getDeviceRemark(){
return deviceRemark;
}
/**
* 设置 备注
* @param deviceRemark
*/
* 设置 备注
* @param deviceRemark
*/
public void setDeviceRemark(String deviceRemark){
this.deviceRemark = deviceRemark;
}
/**
* 获取 最近上线时间
* @return Date
*/
* 获取 最近上线时间
* @return Date
*/
public Date getOnlineTime(){
return onlineTime;
}
/**
* 设置 最近上线时间
* @param onlineTime
*/
* 设置 最近上线时间
* @param onlineTime
*/
public void setOnlineTime(Date onlineTime){
this.onlineTime = onlineTime;
}
/**
* 获取 最近离线时间
* @return Date
*/
* 获取 最近离线时间
* @return Date
*/
public Date getOfflineTime(){
return offlineTime;
}
/**
* 设置 最近离线时间
* @param offlineTime
*/
* 设置 最近离线时间
* @param offlineTime
*/
public void setOfflineTime(Date offlineTime){
this.offlineTime = offlineTime;
}
......@@ -299,7 +317,7 @@ public class DeviceEntity extends DeviceVo {
@Override
public int hashCode() {
return this.getId().hashCode();
return this.getId().hashCode();
}
@Override
public boolean equals(Object obj) {
......@@ -307,7 +325,7 @@ public class DeviceEntity extends DeviceVo {
if (obj instanceof DeviceEntity) {
DeviceEntity tmp = (DeviceEntity) obj;
if (this.getId() == tmp.getId()) {
return true;
return true;
}
}
return false;
......@@ -327,6 +345,7 @@ public class DeviceEntity extends DeviceVo {
sb.append(",deviceFirmname:").append(getDeviceFirmname());
sb.append(",deviceOnlineStatus:").append(getDeviceOnlineStatus());
sb.append(",status:").append(getStatus());
sb.append(",deviceSource:").append(getDeviceSource());
sb.append(",deviceRemark:").append(getDeviceRemark());
sb.append(",onlineTime:").append(getOnlineTime());
sb.append(",offlineTime:").append(getOfflineTime());
......@@ -335,34 +354,36 @@ public class DeviceEntity extends DeviceVo {
public void initAttrValue(){
this.deviceName = "";
this.deviceName = "";
this.deviceCode = "";
this.deviceCode = "";
this.deviceType = 1;
this.deviceType = 1;
this.deviceMac = "";
this.deviceMac = "";
this.ip = "";
this.ip = "";
this.centernum = "";
this.centernum = "";
this.port = "";
this.port = "";
this.siteNum = "";
this.siteNum = "";
this.deviceFirmId = null;
this.deviceFirmId = null;
this.deviceFirmname = "";
this.deviceFirmname = "";
this.deviceOnlineStatus = 0;
this.deviceOnlineStatus = 0;
this.status = 0;
this.status = 0;
this.deviceSource = 0;
this.deviceRemark = "";
this.deviceRemark = "";
this.onlineTime = null;
this.onlineTime = null;
this.offlineTime = null;
this.offlineTime = null;
}
}
\ No newline at end of file
device-manager/src/main/java/com/mortals/xhx/module/device/model/DeviceQuery.java
View file @ 5761b10c
......@@ -4,11 +4,11 @@ import java.util.Date;
import java.util.List;
import com.mortals.xhx.module.device.model.DeviceEntity;
/**
* 设备查询对象
*
* @author zxfei
* @date 2022-03-09
*/
* 设备查询对象
*
* @author zxfei
* @date 2022-05-06
*/
public class DeviceQuery extends DeviceEntity {
/** 开始 主键ID，主键，自增长 */
private Long idStart;
......@@ -94,6 +94,18 @@ public class DeviceQuery extends DeviceEntity {
/** 启用状态 (0.停止，1.启用)列表 */
private List <Integer> statusList;
/** 开始 设备来源，为其它时候上线下线通过查询(0.大厅，1.其它) */
private Integer deviceSourceStart;
/** 结束 设备来源，为其它时候上线下线通过查询(0.大厅，1.其它) */
private Integer deviceSourceEnd;
/** 增加 设备来源，为其它时候上线下线通过查询(0.大厅，1.其它) */
private Integer deviceSourceIncrement;
/** 设备来源，为其它时候上线下线通过查询(0.大厅，1.其它)列表 */
private List <Integer> deviceSourceList;
/** 备注 */
private List<String> deviceRemarkList;
......@@ -154,1234 +166,1343 @@ 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;
}
/**
* 获取 设备名称
* @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 deviceCodeList
*/
* 获取 设备编码
* @return deviceCodeList
*/
public List<String> getDeviceCodeList(){
return this.deviceCodeList;
}
/**
* 设置 设备编码
* @param deviceCodeList
*/
* 设置 设备编码
* @param deviceCodeList
*/
public void setDeviceCodeList(List<String> deviceCodeList){
this.deviceCodeList = deviceCodeList;
}
/**
* 获取 开始 设备类型（1.呼叫器，2.窗口屏, 3.评价器，4.集中屏, 5.排号机，6.im设备, 7.样表设备，8.取件柜, 9.信息发布,10.导视机,11.开标室设备,12.背靠背）
* @return deviceTypeStart
*/
* 获取 开始 设备类型（1.呼叫器，2.窗口屏, 3.评价器，4.集中屏, 5.排号机，6.im设备, 7.样表设备，8.取件柜, 9.信息发布,10.导视机,11.开标室设备,12.背靠背）
* @return deviceTypeStart
*/
public Integer getDeviceTypeStart(){
return this.deviceTypeStart;
}
/**
* 设置 开始 设备类型（1.呼叫器，2.窗口屏, 3.评价器，4.集中屏, 5.排号机，6.im设备, 7.样表设备，8.取件柜, 9.信息发布,10.导视机,11.开标室设备,12.背靠背）
* @param deviceTypeStart
*/
* 设置 开始 设备类型（1.呼叫器，2.窗口屏, 3.评价器，4.集中屏, 5.排号机，6.im设备, 7.样表设备，8.取件柜, 9.信息发布,10.导视机,11.开标室设备,12.背靠背）
* @param deviceTypeStart
*/
public void setDeviceTypeStart(Integer deviceTypeStart){
this.deviceTypeStart = deviceTypeStart;
}
/**
* 获取 结束 设备类型（1.呼叫器，2.窗口屏, 3.评价器，4.集中屏, 5.排号机，6.im设备, 7.样表设备，8.取件柜, 9.信息发布,10.导视机,11.开标室设备,12.背靠背）
* @return $deviceTypeEnd
*/
* 获取 结束 设备类型（1.呼叫器，2.窗口屏, 3.评价器，4.集中屏, 5.排号机，6.im设备, 7.样表设备，8.取件柜, 9.信息发布,10.导视机,11.开标室设备,12.背靠背）
* @return $deviceTypeEnd
*/
public Integer getDeviceTypeEnd(){
return this.deviceTypeEnd;
}
/**
* 设置 结束 设备类型（1.呼叫器，2.窗口屏, 3.评价器，4.集中屏, 5.排号机，6.im设备, 7.样表设备，8.取件柜, 9.信息发布,10.导视机,11.开标室设备,12.背靠背）
* @param deviceTypeEnd
*/
* 设置 结束 设备类型（1.呼叫器，2.窗口屏, 3.评价器，4.集中屏, 5.排号机，6.im设备, 7.样表设备，8.取件柜, 9.信息发布,10.导视机,11.开标室设备,12.背靠背）
* @param deviceTypeEnd
*/
public void setDeviceTypeEnd(Integer deviceTypeEnd){
this.deviceTypeEnd = deviceTypeEnd;
}
/**
* 获取 增加 设备类型（1.呼叫器，2.窗口屏, 3.评价器，4.集中屏, 5.排号机，6.im设备, 7.样表设备，8.取件柜, 9.信息发布,10.导视机,11.开标室设备,12.背靠背）
* @return deviceTypeIncrement
*/
* 获取 增加 设备类型（1.呼叫器，2.窗口屏, 3.评价器，4.集中屏, 5.排号机，6.im设备, 7.样表设备，8.取件柜, 9.信息发布,10.导视机,11.开标室设备,12.背靠背）
* @return deviceTypeIncrement
*/
public Integer getDeviceTypeIncrement(){
return this.deviceTypeIncrement;
}
/**
* 设置 增加 设备类型（1.呼叫器，2.窗口屏, 3.评价器，4.集中屏, 5.排号机，6.im设备, 7.样表设备，8.取件柜, 9.信息发布,10.导视机,11.开标室设备,12.背靠背）
* @param deviceTypeIncrement
*/
* 设置 增加 设备类型（1.呼叫器，2.窗口屏, 3.评价器，4.集中屏, 5.排号机，6.im设备, 7.样表设备，8.取件柜, 9.信息发布,10.导视机,11.开标室设备,12.背靠背）
* @param deviceTypeIncrement
*/
public void setDeviceTypeIncrement(Integer deviceTypeIncrement){
this.deviceTypeIncrement = deviceTypeIncrement;
}
/**
* 获取 设备类型（1.呼叫器，2.窗口屏, 3.评价器，4.集中屏, 5.排号机，6.im设备, 7.样表设备，8.取件柜, 9.信息发布,10.导视机,11.开标室设备,12.背靠背）
* @return deviceTypeList
*/
* 获取 设备类型（1.呼叫器，2.窗口屏, 3.评价器，4.集中屏, 5.排号机，6.im设备, 7.样表设备，8.取件柜, 9.信息发布,10.导视机,11.开标室设备,12.背靠背）
* @return deviceTypeList
*/
public List<Integer> getDeviceTypeList(){
return this.deviceTypeList;
}
/**
* 设置 设备类型（1.呼叫器，2.窗口屏, 3.评价器，4.集中屏, 5.排号机，6.im设备, 7.样表设备，8.取件柜, 9.信息发布,10.导视机,11.开标室设备,12.背靠背）
* @param deviceTypeList
*/
* 设置 设备类型（1.呼叫器，2.窗口屏, 3.评价器，4.集中屏, 5.排号机，6.im设备, 7.样表设备，8.取件柜, 9.信息发布,10.导视机,11.开标室设备,12.背靠背）
* @param deviceTypeList
*/
public void setDeviceTypeList(List<Integer> deviceTypeList){
this.deviceTypeList = deviceTypeList;
}
/**
* 获取 设备的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;
}
/**
* 获取 设备访问ip
* @return ipList
*/
* 获取 设备访问ip
* @return ipList
*/
public List<String> getIpList(){
return this.ipList;
}
/**
* 设置 设备访问ip
* @param ipList
*/
* 设置 设备访问ip
* @param ipList
*/
public void setIpList(List<String> ipList){
this.ipList = ipList;
}
/**
* 获取 中心设备编码
* @return centernumList
*/
* 获取 中心设备编码
* @return centernumList
*/
public List<String> getCenternumList(){
return this.centernumList;
}
/**
* 设置 中心设备编码
* @param centernumList
*/
* 设置 中心设备编码
* @param centernumList
*/
public void setCenternumList(List<String> centernumList){
this.centernumList = centernumList;
}
/**
* 获取 端口
* @return portList
*/
* 获取 端口
* @return portList
*/
public List<String> getPortList(){
return this.portList;
}
/**
* 设置 端口
* @param portList
*/
* 设置 端口
* @param portList
*/
public void setPortList(List<String> portList){
this.portList = portList;
}
/**
* 获取 站点编号
* @return siteNumList
*/
* 获取 站点编号
* @return siteNumList
*/
public List<String> getSiteNumList(){
return this.siteNumList;
}
/**
* 设置 站点编号
* @param siteNumList
*/
* 设置 站点编号
* @param siteNumList
*/
public void setSiteNumList(List<String> siteNumList){
this.siteNumList = siteNumList;
}
/**
* 获取 开始 设备生产厂商ID
* @return deviceFirmIdStart
*/
* 获取 开始 设备生产厂商ID
* @return deviceFirmIdStart
*/
public Long getDeviceFirmIdStart(){
return this.deviceFirmIdStart;
}
/**
* 设置 开始 设备生产厂商ID
* @param deviceFirmIdStart
*/
* 设置 开始 设备生产厂商ID
* @param deviceFirmIdStart
*/
public void setDeviceFirmIdStart(Long deviceFirmIdStart){
this.deviceFirmIdStart = deviceFirmIdStart;
}
/**
* 获取 结束 设备生产厂商ID
* @return $deviceFirmIdEnd
*/
* 获取 结束 设备生产厂商ID
* @return $deviceFirmIdEnd
*/
public Long getDeviceFirmIdEnd(){
return this.deviceFirmIdEnd;
}
/**
* 设置 结束 设备生产厂商ID
* @param deviceFirmIdEnd
*/
* 设置 结束 设备生产厂商ID
* @param deviceFirmIdEnd
*/
public void setDeviceFirmIdEnd(Long deviceFirmIdEnd){
this.deviceFirmIdEnd = deviceFirmIdEnd;
}
/**
* 获取 增加 设备生产厂商ID
* @return deviceFirmIdIncrement
*/
* 获取 增加 设备生产厂商ID
* @return deviceFirmIdIncrement
*/
public Long getDeviceFirmIdIncrement(){
return this.deviceFirmIdIncrement;
}
/**
* 设置 增加 设备生产厂商ID
* @param deviceFirmIdIncrement
*/
* 设置 增加 设备生产厂商ID
* @param deviceFirmIdIncrement
*/
public void setDeviceFirmIdIncrement(Long deviceFirmIdIncrement){
this.deviceFirmIdIncrement = deviceFirmIdIncrement;
}
/**
* 获取 设备生产厂商ID
* @return deviceFirmIdList
*/
* 获取 设备生产厂商ID
* @return deviceFirmIdList
*/
public List<Long> getDeviceFirmIdList(){
return this.deviceFirmIdList;
}
/**
* 设置 设备生产厂商ID
* @param deviceFirmIdList
*/
* 设置 设备生产厂商ID
* @param deviceFirmIdList
*/
public void setDeviceFirmIdList(List<Long> deviceFirmIdList){
this.deviceFirmIdList = deviceFirmIdList;
}
/**
* 获取 设备生产厂商名称
* @return deviceFirmnameList
*/
* 获取 设备生产厂商名称
* @return deviceFirmnameList
*/
public List<String> getDeviceFirmnameList(){
return this.deviceFirmnameList;
}
/**
* 设置 设备生产厂商名称
* @param deviceFirmnameList
*/
* 设置 设备生产厂商名称
* @param deviceFirmnameList
*/
public void setDeviceFirmnameList(List<String> deviceFirmnameList){
this.deviceFirmnameList = deviceFirmnameList;
}
/**
* 获取 开始 在线状态 (0.离线，1.在线)
* @return deviceOnlineStatusStart
*/
* 获取 开始 在线状态 (0.离线，1.在线)
* @return deviceOnlineStatusStart
*/
public Integer getDeviceOnlineStatusStart(){
return this.deviceOnlineStatusStart;
}
/**
* 设置 开始 在线状态 (0.离线，1.在线)
* @param deviceOnlineStatusStart
*/
* 设置 开始 在线状态 (0.离线，1.在线)
* @param deviceOnlineStatusStart
*/
public void setDeviceOnlineStatusStart(Integer deviceOnlineStatusStart){
this.deviceOnlineStatusStart = deviceOnlineStatusStart;
}
/**
* 获取 结束 在线状态 (0.离线，1.在线)
* @return $deviceOnlineStatusEnd
*/
* 获取 结束 在线状态 (0.离线，1.在线)
* @return $deviceOnlineStatusEnd
*/
public Integer getDeviceOnlineStatusEnd(){
return this.deviceOnlineStatusEnd;
}
/**
* 设置 结束 在线状态 (0.离线，1.在线)
* @param deviceOnlineStatusEnd
*/
* 设置 结束 在线状态 (0.离线，1.在线)
* @param deviceOnlineStatusEnd
*/
public void setDeviceOnlineStatusEnd(Integer deviceOnlineStatusEnd){
this.deviceOnlineStatusEnd = deviceOnlineStatusEnd;
}
/**
* 获取 增加 在线状态 (0.离线，1.在线)
* @return deviceOnlineStatusIncrement
*/
* 获取 增加 在线状态 (0.离线，1.在线)
* @return deviceOnlineStatusIncrement
*/
public Integer getDeviceOnlineStatusIncrement(){
return this.deviceOnlineStatusIncrement;
}
/**
* 设置 增加 在线状态 (0.离线，1.在线)
* @param deviceOnlineStatusIncrement
*/
* 设置 增加 在线状态 (0.离线，1.在线)
* @param deviceOnlineStatusIncrement
*/
public void setDeviceOnlineStatusIncrement(Integer deviceOnlineStatusIncrement){
this.deviceOnlineStatusIncrement = deviceOnlineStatusIncrement;
}
/**
* 获取 在线状态 (0.离线，1.在线)
* @return deviceOnlineStatusList
*/
* 获取 在线状态 (0.离线，1.在线)
* @return deviceOnlineStatusList
*/
public List<Integer> getDeviceOnlineStatusList(){
return this.deviceOnlineStatusList;
}
/**
* 设置 在线状态 (0.离线，1.在线)
* @param deviceOnlineStatusList
*/
* 设置 在线状态 (0.离线，1.在线)
* @param deviceOnlineStatusList
*/
public void setDeviceOnlineStatusList(List<Integer> deviceOnlineStatusList){
this.deviceOnlineStatusList = deviceOnlineStatusList;
}
/**
* 获取 开始 启用状态 (0.停止，1.启用)
* @return statusStart
*/
* 获取 开始 启用状态 (0.停止，1.启用)
* @return statusStart
*/
public Integer getStatusStart(){
return this.statusStart;
}
/**
* 设置 开始 启用状态 (0.停止，1.启用)
* @param statusStart
*/
* 设置 开始 启用状态 (0.停止，1.启用)
* @param statusStart
*/
public void setStatusStart(Integer statusStart){
this.statusStart = statusStart;
}
/**
* 获取 结束 启用状态 (0.停止，1.启用)
* @return $statusEnd
*/
* 获取 结束 启用状态 (0.停止，1.启用)
* @return $statusEnd
*/
public Integer getStatusEnd(){
return this.statusEnd;
}
/**
* 设置 结束 启用状态 (0.停止，1.启用)
* @param statusEnd
*/
* 设置 结束 启用状态 (0.停止，1.启用)
* @param statusEnd
*/
public void setStatusEnd(Integer statusEnd){
this.statusEnd = statusEnd;
}
/**
* 获取 增加 启用状态 (0.停止，1.启用)
* @return statusIncrement
*/
* 获取 增加 启用状态 (0.停止，1.启用)
* @return statusIncrement
*/
public Integer getStatusIncrement(){
return this.statusIncrement;
}
/**
* 设置 增加 启用状态 (0.停止，1.启用)
* @param statusIncrement
*/
* 设置 增加 启用状态 (0.停止，1.启用)
* @param statusIncrement
*/
public void setStatusIncrement(Integer statusIncrement){
this.statusIncrement = statusIncrement;
}
/**
* 获取 启用状态 (0.停止，1.启用)
* @return statusList
*/
* 获取 启用状态 (0.停止，1.启用)
* @return statusList
*/
public List<Integer> getStatusList(){
return this.statusList;
}
/**
* 设置 启用状态 (0.停止，1.启用)
* @param statusList
*/
* 设置 启用状态 (0.停止，1.启用)
* @param statusList
*/
public void setStatusList(List<Integer> statusList){
this.statusList = statusList;
}
/**
* 获取 备注
* @return deviceRemarkList
*/
* 获取 开始 设备来源，为其它时候上线下线通过查询(0.大厅，1.其它)
* @return deviceSourceStart
*/
public Integer getDeviceSourceStart(){
return this.deviceSourceStart;
}
/**
* 设置 开始 设备来源，为其它时候上线下线通过查询(0.大厅，1.其它)
* @param deviceSourceStart
*/
public void setDeviceSourceStart(Integer deviceSourceStart){
this.deviceSourceStart = deviceSourceStart;
}
/**
* 获取 结束 设备来源，为其它时候上线下线通过查询(0.大厅，1.其它)
* @return $deviceSourceEnd
*/
public Integer getDeviceSourceEnd(){
return this.deviceSourceEnd;
}
/**
* 设置 结束 设备来源，为其它时候上线下线通过查询(0.大厅，1.其它)
* @param deviceSourceEnd
*/
public void setDeviceSourceEnd(Integer deviceSourceEnd){
this.deviceSourceEnd = deviceSourceEnd;
}
/**
* 获取 增加 设备来源，为其它时候上线下线通过查询(0.大厅，1.其它)
* @return deviceSourceIncrement
*/
public Integer getDeviceSourceIncrement(){
return this.deviceSourceIncrement;
}
/**
* 设置 增加 设备来源，为其它时候上线下线通过查询(0.大厅，1.其它)
* @param deviceSourceIncrement
*/
public void setDeviceSourceIncrement(Integer deviceSourceIncrement){
this.deviceSourceIncrement = deviceSourceIncrement;
}
/**
* 获取 设备来源，为其它时候上线下线通过查询(0.大厅，1.其它)
* @return deviceSourceList
*/
public List<Integer> getDeviceSourceList(){
return this.deviceSourceList;
}
/**
* 设置 设备来源，为其它时候上线下线通过查询(0.大厅，1.其它)
* @param deviceSourceList
*/
public void setDeviceSourceList(List<Integer> deviceSourceList){
this.deviceSourceList = deviceSourceList;
}
/**
* 获取 备注
* @return deviceRemarkList
*/
public List<String> getDeviceRemarkList(){
return this.deviceRemarkList;
}
/**
* 设置 备注
* @param deviceRemarkList
*/
* 设置 备注
* @param deviceRemarkList
*/
public void setDeviceRemarkList(List<String> deviceRemarkList){
this.deviceRemarkList = deviceRemarkList;
}
/**
* 获取 开始 最近上线时间
* @return onlineTimeStart
*/
* 获取 开始 最近上线时间
* @return onlineTimeStart
*/
public String getOnlineTimeStart(){
return this.onlineTimeStart;
}
/**
* 设置 开始 最近上线时间
* @param onlineTimeStart
*/
* 设置 开始 最近上线时间
* @param onlineTimeStart
*/
public void setOnlineTimeStart(String onlineTimeStart){
this.onlineTimeStart = onlineTimeStart;
}
/**
* 获取 结束 最近上线时间
* @return onlineTimeEnd
*/
* 获取 结束 最近上线时间
* @return onlineTimeEnd
*/
public String getOnlineTimeEnd(){
return this.onlineTimeEnd;
}
/**
* 设置 结束 最近上线时间
* @param onlineTimeEnd
*/
* 设置 结束 最近上线时间
* @param onlineTimeEnd
*/
public void setOnlineTimeEnd(String onlineTimeEnd){
this.onlineTimeEnd = onlineTimeEnd;
}
/**
* 获取 开始 最近离线时间
* @return offlineTimeStart
*/
* 获取 开始 最近离线时间
* @return offlineTimeStart
*/
public String getOfflineTimeStart(){
return this.offlineTimeStart;
}
/**
* 设置 开始 最近离线时间
* @param offlineTimeStart
*/
* 设置 开始 最近离线时间
* @param offlineTimeStart
*/
public void setOfflineTimeStart(String offlineTimeStart){
this.offlineTimeStart = offlineTimeStart;
}
/**
* 获取 结束 最近离线时间
* @return offlineTimeEnd
*/
* 获取 结束 最近离线时间
* @return offlineTimeEnd
*/
public String getOfflineTimeEnd(){
return this.offlineTimeEnd;
}
/**
* 设置 结束 最近离线时间
* @param offlineTimeEnd
*/
* 设置 结束 最近离线时间
* @param offlineTimeEnd
*/
public void setOfflineTimeEnd(String offlineTimeEnd){
this.offlineTimeEnd = offlineTimeEnd;
}
/**
* 获取 开始 创建用户
* @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 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 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，主键，自增长
* @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;
}
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;
}
/**
* 设置 设备类型（1.呼叫器，2.窗口屏, 3.评价器，4.集中屏, 5.排号机，6.im设备, 7.样表设备，8.取件柜, 9.信息发布,10.导视机,11.开标室设备,12.背靠背）
* @param deviceType
*/
* 设置 设备类型（1.呼叫器，2.窗口屏, 3.评价器，4.集中屏, 5.排号机，6.im设备, 7.样表设备，8.取件柜, 9.信息发布,10.导视机,11.开标室设备,12.背靠背）
* @param deviceType
*/
public DeviceQuery deviceType(Integer deviceType){
setDeviceType(deviceType);
return this;
}
/**
* 设置 开始 设备类型（1.呼叫器，2.窗口屏, 3.评价器，4.集中屏, 5.排号机，6.im设备, 7.样表设备，8.取件柜, 9.信息发布,10.导视机,11.开标室设备,12.背靠背）
* @param deviceTypeStart
*/
setDeviceType(deviceType);
return this;
}
/**
* 设置 开始 设备类型（1.呼叫器，2.窗口屏, 3.评价器，4.集中屏, 5.排号机，6.im设备, 7.样表设备，8.取件柜, 9.信息发布,10.导视机,11.开标室设备,12.背靠背）
* @param deviceTypeStart
*/
public DeviceQuery deviceTypeStart(Integer deviceTypeStart){
this.deviceTypeStart = deviceTypeStart;
return this;
this.deviceTypeStart = deviceTypeStart;
return this;
}
/**
* 设置 结束 设备类型（1.呼叫器，2.窗口屏, 3.评价器，4.集中屏, 5.排号机，6.im设备, 7.样表设备，8.取件柜, 9.信息发布,10.导视机,11.开标室设备,12.背靠背）
* @param deviceTypeEnd
*/
* 设置 结束 设备类型（1.呼叫器，2.窗口屏, 3.评价器，4.集中屏, 5.排号机，6.im设备, 7.样表设备，8.取件柜, 9.信息发布,10.导视机,11.开标室设备,12.背靠背）
* @param deviceTypeEnd
*/
public DeviceQuery deviceTypeEnd(Integer deviceTypeEnd){
this.deviceTypeEnd = deviceTypeEnd;
return this;
this.deviceTypeEnd = deviceTypeEnd;
return this;
}
/**
* 设置 增加 设备类型（1.呼叫器，2.窗口屏, 3.评价器，4.集中屏, 5.排号机，6.im设备, 7.样表设备，8.取件柜, 9.信息发布,10.导视机,11.开标室设备,12.背靠背）
* @param deviceTypeIncrement
*/
* 设置 增加 设备类型（1.呼叫器，2.窗口屏, 3.评价器，4.集中屏, 5.排号机，6.im设备, 7.样表设备，8.取件柜, 9.信息发布,10.导视机,11.开标室设备,12.背靠背）
* @param deviceTypeIncrement
*/
public DeviceQuery deviceTypeIncrement(Integer deviceTypeIncrement){
this.deviceTypeIncrement = deviceTypeIncrement;
return this;
this.deviceTypeIncrement = deviceTypeIncrement;
return this;
}
/**
* 设置 设备类型（1.呼叫器，2.窗口屏, 3.评价器，4.集中屏, 5.排号机，6.im设备, 7.样表设备，8.取件柜, 9.信息发布,10.导视机,11.开标室设备,12.背靠背）
* @param deviceTypeList
*/
* 设置 设备类型（1.呼叫器，2.窗口屏, 3.评价器，4.集中屏, 5.排号机，6.im设备, 7.样表设备，8.取件柜, 9.信息发布,10.导视机,11.开标室设备,12.背靠背）
* @param deviceTypeList
*/
public DeviceQuery deviceTypeList(List<Integer> deviceTypeList){
this.deviceTypeList = deviceTypeList;
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;
}
/**
* 设置 设备访问ip
* @param ip
*/
/**
* 设置 设备访问ip
* @param ip
*/
public DeviceQuery ip(String ip){
setIp(ip);
return this;
return this;
}
/**
* 设置 设备访问ip
* @param ipList
*/
* 设置 设备访问ip
* @param ipList
*/
public DeviceQuery ipList(List<String> ipList){
this.ipList = ipList;
return this;
return this;
}
/**
* 设置 中心设备编码
* @param centernum
*/
/**
* 设置 中心设备编码
* @param centernum
*/
public DeviceQuery centernum(String centernum){
setCenternum(centernum);
return this;
return this;
}
/**
* 设置 中心设备编码
* @param centernumList
*/
* 设置 中心设备编码
* @param centernumList
*/
public DeviceQuery centernumList(List<String> centernumList){
this.centernumList = centernumList;
return this;
return this;
}
/**
* 设置 端口
* @param port
*/
/**
* 设置 端口
* @param port
*/
public DeviceQuery port(String port){
setPort(port);
return this;
return this;
}
/**
* 设置 端口
* @param portList
*/
* 设置 端口
* @param portList
*/
public DeviceQuery portList(List<String> portList){
this.portList = portList;
return this;
return this;
}
/**
* 设置 站点编号
* @param siteNum
*/
/**
* 设置 站点编号
* @param siteNum
*/
public DeviceQuery siteNum(String siteNum){
setSiteNum(siteNum);
return this;
return this;
}
/**
* 设置 站点编号
* @param siteNumList
*/
* 设置 站点编号
* @param siteNumList
*/
public DeviceQuery siteNumList(List<String> siteNumList){
this.siteNumList = siteNumList;
return this;
return this;
}
/**
* 设置 设备生产厂商ID
* @param deviceFirmId
*/
* 设置 设备生产厂商ID
* @param deviceFirmId
*/
public DeviceQuery deviceFirmId(Long deviceFirmId){
setDeviceFirmId(deviceFirmId);
return this;
}
/**
* 设置 开始 设备生产厂商ID
* @param deviceFirmIdStart
*/
setDeviceFirmId(deviceFirmId);
return this;
}
/**
* 设置 开始 设备生产厂商ID
* @param deviceFirmIdStart
*/
public DeviceQuery deviceFirmIdStart(Long deviceFirmIdStart){
this.deviceFirmIdStart = deviceFirmIdStart;
return this;
this.deviceFirmIdStart = deviceFirmIdStart;
return this;
}
/**
* 设置 结束 设备生产厂商ID
* @param deviceFirmIdEnd
*/
* 设置 结束 设备生产厂商ID
* @param deviceFirmIdEnd
*/
public DeviceQuery deviceFirmIdEnd(Long deviceFirmIdEnd){
this.deviceFirmIdEnd = deviceFirmIdEnd;
return this;
this.deviceFirmIdEnd = deviceFirmIdEnd;
return this;
}
/**
* 设置 增加 设备生产厂商ID
* @param deviceFirmIdIncrement
*/
* 设置 增加 设备生产厂商ID
* @param deviceFirmIdIncrement
*/
public DeviceQuery deviceFirmIdIncrement(Long deviceFirmIdIncrement){
this.deviceFirmIdIncrement = deviceFirmIdIncrement;
return this;
this.deviceFirmIdIncrement = deviceFirmIdIncrement;
return this;
}
/**
* 设置 设备生产厂商ID
* @param deviceFirmIdList
*/
* 设置 设备生产厂商ID
* @param deviceFirmIdList
*/
public DeviceQuery deviceFirmIdList(List<Long> deviceFirmIdList){
this.deviceFirmIdList = deviceFirmIdList;
return this;
}
return this;
}
/**
* 设置 设备生产厂商名称
* @param deviceFirmname
*/
/**
* 设置 设备生产厂商名称
* @param deviceFirmname
*/
public DeviceQuery deviceFirmname(String deviceFirmname){
setDeviceFirmname(deviceFirmname);
return this;
return this;
}
/**
* 设置 设备生产厂商名称
* @param deviceFirmnameList
*/
* 设置 设备生产厂商名称
* @param deviceFirmnameList
*/
public DeviceQuery deviceFirmnameList(List<String> deviceFirmnameList){
this.deviceFirmnameList = deviceFirmnameList;
return this;
return this;
}
/**
* 设置 在线状态 (0.离线，1.在线)
* @param deviceOnlineStatus
*/
* 设置 在线状态 (0.离线，1.在线)
* @param deviceOnlineStatus
*/
public DeviceQuery deviceOnlineStatus(Integer deviceOnlineStatus){
setDeviceOnlineStatus(deviceOnlineStatus);
return this;
}
/**
* 设置 开始 在线状态 (0.离线，1.在线)
* @param deviceOnlineStatusStart
*/
setDeviceOnlineStatus(deviceOnlineStatus);
return this;
}
/**
* 设置 开始 在线状态 (0.离线，1.在线)
* @param deviceOnlineStatusStart
*/
public DeviceQuery deviceOnlineStatusStart(Integer deviceOnlineStatusStart){
this.deviceOnlineStatusStart = deviceOnlineStatusStart;
return this;
this.deviceOnlineStatusStart = deviceOnlineStatusStart;
return this;
}
/**
* 设置 结束 在线状态 (0.离线，1.在线)
* @param deviceOnlineStatusEnd
*/
* 设置 结束 在线状态 (0.离线，1.在线)
* @param deviceOnlineStatusEnd
*/
public DeviceQuery deviceOnlineStatusEnd(Integer deviceOnlineStatusEnd){
this.deviceOnlineStatusEnd = deviceOnlineStatusEnd;
return this;
this.deviceOnlineStatusEnd = deviceOnlineStatusEnd;
return this;
}
/**
* 设置 增加 在线状态 (0.离线，1.在线)
* @param deviceOnlineStatusIncrement
*/
* 设置 增加 在线状态 (0.离线，1.在线)
* @param deviceOnlineStatusIncrement
*/
public DeviceQuery deviceOnlineStatusIncrement(Integer deviceOnlineStatusIncrement){
this.deviceOnlineStatusIncrement = deviceOnlineStatusIncrement;
return this;
this.deviceOnlineStatusIncrement = deviceOnlineStatusIncrement;
return this;
}
/**
* 设置 在线状态 (0.离线，1.在线)
* @param deviceOnlineStatusList
*/
* 设置 在线状态 (0.离线，1.在线)
* @param deviceOnlineStatusList
*/
public DeviceQuery deviceOnlineStatusList(List<Integer> deviceOnlineStatusList){
this.deviceOnlineStatusList = deviceOnlineStatusList;
return this;
}
return this;
}
/**
* 设置 启用状态 (0.停止，1.启用)
* @param status
*/
* 设置 启用状态 (0.停止，1.启用)
* @param status
*/
public DeviceQuery status(Integer status){
setStatus(status);
return this;
}
/**
* 设置 开始 启用状态 (0.停止，1.启用)
* @param statusStart
*/
setStatus(status);
return this;
}
/**
* 设置 开始 启用状态 (0.停止，1.启用)
* @param statusStart
*/
public DeviceQuery statusStart(Integer statusStart){
this.statusStart = statusStart;
return this;
this.statusStart = statusStart;
return this;
}
/**
* 设置 结束 启用状态 (0.停止，1.启用)
* @param statusEnd
*/
* 设置 结束 启用状态 (0.停止，1.启用)
* @param statusEnd
*/
public DeviceQuery statusEnd(Integer statusEnd){
this.statusEnd = statusEnd;
return this;
this.statusEnd = statusEnd;
return this;
}
/**
* 设置 增加 启用状态 (0.停止，1.启用)
* @param statusIncrement
*/
* 设置 增加 启用状态 (0.停止，1.启用)
* @param statusIncrement
*/
public DeviceQuery statusIncrement(Integer statusIncrement){
this.statusIncrement = statusIncrement;
return this;
this.statusIncrement = statusIncrement;
return this;
}
/**
* 设置 启用状态 (0.停止，1.启用)
* @param statusList
*/
* 设置 启用状态 (0.停止，1.启用)
* @param statusList
*/
public DeviceQuery statusList(List<Integer> statusList){
this.statusList = statusList;
return this;
}
return this;
}
/**
* 设置 设备来源，为其它时候上线下线通过查询(0.大厅，1.其它)
* @param deviceSource
*/
public DeviceQuery deviceSource(Integer deviceSource){
setDeviceSource(deviceSource);
return this;
}
/**
* 设置 开始 设备来源，为其它时候上线下线通过查询(0.大厅，1.其它)
* @param deviceSourceStart
*/
public DeviceQuery deviceSourceStart(Integer deviceSourceStart){
this.deviceSourceStart = deviceSourceStart;
return this;
}
/**
* 设置 结束 设备来源，为其它时候上线下线通过查询(0.大厅，1.其它)
* @param deviceSourceEnd
*/
public DeviceQuery deviceSourceEnd(Integer deviceSourceEnd){
this.deviceSourceEnd = deviceSourceEnd;
return this;
}
/**
* 设置 备注
* @param deviceRemark
*/
/**
* 设置 增加 设备来源，为其它时候上线下线通过查询(0.大厅，1.其它)
* @param deviceSourceIncrement
*/
public DeviceQuery deviceSourceIncrement(Integer deviceSourceIncrement){
this.deviceSourceIncrement = deviceSourceIncrement;
return this;
}
/**
* 设置 设备来源，为其它时候上线下线通过查询(0.大厅，1.其它)
* @param deviceSourceList
*/
public DeviceQuery deviceSourceList(List<Integer> deviceSourceList){
this.deviceSourceList = deviceSourceList;
return this;
}
/**
* 设置 备注
* @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;
}
/**
* 设置 创建用户
* @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;
}
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;
}
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;
}
......
device-manager/src/main/java/com/mortals/xhx/module/device/service/impl/DeviceServiceImpl.java
View file @ 5761b10c
package com.mortals.xhx.module.device.service.impl;
import com.mortals.framework.exception.AppException;
import com.mortals.framework.model.Context;
import org.springframework.stereotype.Service;
import com.mortals.framework.service.impl.AbstractCRUDCacheServiceImpl;
import com.mortals.xhx.module.device.dao.DeviceDao;
import com.mortals.xhx.module.device.model.DeviceEntity;
import com.mortals.xhx.module.device.service.DeviceService;
import org.springframework.util.ObjectUtils;
/**
* DeviceService
* 设备 service实现
......@@ -19,4 +23,13 @@ public class DeviceServiceImpl extends AbstractCRUDCacheServiceImpl<DeviceDao, D
protected String getExtKey(DeviceEntity data) {
return data.getDeviceCode();
}
@Override
protected void saveBefore(DeviceEntity entity, Context context) throws AppException {
if(ObjectUtils.isEmpty(entity.getDeviceCode())){
entity.setDeviceCode(entity.getDeviceMac());
}
super.saveBefore(entity, context);
}
}
\ No newline at end of file
device-manager/src/main/java/com/mortals/xhx/module/device/web/DeviceController.java
View file @ 5761b10c
......@@ -69,9 +69,8 @@ public class DeviceController extends BaseCRUDJsonMappingController<DeviceServic
this.addDict(model, "deviceOnlineStatus", paramService.getParamBySecondOrganize("Device", "deviceOnlineStatus"));
this.addDict(model, "status", paramService.getParamBySecondOrganize("Device", "status"));
this.addDict(model, "deviceFirmId", firmService.find(new FirmQuery()).stream().collect(Collectors.toMap(x -> x.getId().toString(), y -> y.getFirmName())));
this.addDict(model, "deviceSource", paramService.getParamBySecondOrganize("Device","deviceSource"));
Map<Boolean, Long> collect = this.service.find(new DeviceQuery()).stream().collect(Collectors.partitioningBy(item -> (item.getDeviceOnlineStatus() == DeviceOnlineStatusEnum.在线.getValue()), Collectors.counting()));
model.put("onlineCount", collect.get(true));
model.put("offlineCount", collect.get(false));
super.init(request, response, form, model, context);
......
device-manager/src/main/resources/sqlmap/module/device/DeviceMapper.xml
View file @ 5761b10c
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"mybatis-3-mapper.dtd">
"mybatis-3-mapper.dtd">
<mapper namespace="com.mortals.xhx.module.device.dao.ibatis.DeviceDaoImpl">
<!-- 字段和属性映射 -->
<resultMap type="DeviceEntity" id="DeviceEntity-Map">
<id property="id" column="id" />
<result property="deviceName" column="deviceName" />
<result property="deviceCode" column="deviceCode" />
<result property="deviceType" column="deviceType" />
<result property="deviceMac" column="deviceMac" />
<result property="ip" column="ip" />
<result property="centernum" column="centernum" />
<result property="port" column="port" />
<result property="siteNum" column="siteNum" />
<result property="deviceFirmId" column="deviceFirmId" />
<result property="deviceFirmname" column="deviceFirmname" />
<result property="deviceOnlineStatus" column="deviceOnlineStatus" />
<result property="status" column="status" />
<result property="deviceRemark" column="deviceRemark" />
<result property="onlineTime" column="onlineTime" />
<result property="offlineTime" column="offlineTime" />
<result property="createUserId" column="createUserId" />
<result property="createTime" column="createTime" />
<result property="updateUserId" column="updateUserId" />
<result property="updateTime" column="updateTime" />
<id property="id" column="id" />
<result property="deviceName" column="deviceName" />
<result property="deviceCode" column="deviceCode" />
<result property="deviceType" column="deviceType" />
<result property="deviceMac" column="deviceMac" />
<result property="ip" column="ip" />
<result property="centernum" column="centernum" />
<result property="port" column="port" />
<result property="siteNum" column="siteNum" />
<result property="deviceFirmId" column="deviceFirmId" />
<result property="deviceFirmname" column="deviceFirmname" />
<result property="deviceOnlineStatus" column="deviceOnlineStatus" />
<result property="status" column="status" />
<result property="deviceSource" column="deviceSource" />
<result property="deviceRemark" column="deviceRemark" />
<result property="onlineTime" column="onlineTime" />
<result property="offlineTime" column="offlineTime" />
<result property="createUserId" column="createUserId" />
<result property="createTime" column="createTime" />
<result property="updateUserId" column="updateUserId" />
<result property="updateTime" column="updateTime" />
</resultMap>
<!-- 表所有列 -->
<sql id="_columns">
<trim suffixOverrides="," suffix="">
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('id') or colPickMode == 1 and data.containsKey('id')))">
a.id as id,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('deviceName') or colPickMode == 1 and data.containsKey('deviceName')))">
a.deviceName as deviceName,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('deviceCode') or colPickMode == 1 and data.containsKey('deviceCode')))">
a.deviceCode as deviceCode,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('deviceType') or colPickMode == 1 and data.containsKey('deviceType')))">
a.deviceType as deviceType,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('deviceMac') or colPickMode == 1 and data.containsKey('deviceMac')))">
a.deviceMac as deviceMac,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('ip') or colPickMode == 1 and data.containsKey('ip')))">
a.ip as ip,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('centernum') or colPickMode == 1 and data.containsKey('centernum')))">
a.centernum as centernum,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('port') or colPickMode == 1 and data.containsKey('port')))">
a.port as port,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('siteNum') or colPickMode == 1 and data.containsKey('siteNum')))">
a.siteNum as siteNum,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('deviceFirmId') or colPickMode == 1 and data.containsKey('deviceFirmId')))">
a.deviceFirmId as deviceFirmId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('deviceFirmname') or colPickMode == 1 and data.containsKey('deviceFirmname')))">
a.deviceFirmname as deviceFirmname,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('deviceOnlineStatus') or colPickMode == 1 and data.containsKey('deviceOnlineStatus')))">
a.deviceOnlineStatus as deviceOnlineStatus,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('status') or colPickMode == 1 and data.containsKey('status')))">
a.status as status,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('deviceRemark') or colPickMode == 1 and data.containsKey('deviceRemark')))">
a.deviceRemark as deviceRemark,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('onlineTime') or colPickMode == 1 and data.containsKey('onlineTime')))">
a.onlineTime as onlineTime,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('offlineTime') or colPickMode == 1 and data.containsKey('offlineTime')))">
a.offlineTime as offlineTime,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createUserId') or colPickMode == 1 and data.containsKey('createUserId')))">
a.createUserId as createUserId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createTime') or colPickMode == 1 and data.containsKey('createTime')))">
a.createTime as createTime,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateUserId') or colPickMode == 1 and data.containsKey('updateUserId')))">
a.updateUserId as updateUserId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateTime') or colPickMode == 1 and data.containsKey('updateTime')))">
a.updateTime as updateTime,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('id') or colPickMode == 1 and data.containsKey('id')))">
a.id,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('deviceName') or colPickMode == 1 and data.containsKey('deviceName')))">
a.deviceName,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('deviceCode') or colPickMode == 1 and data.containsKey('deviceCode')))">
a.deviceCode,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('deviceType') or colPickMode == 1 and data.containsKey('deviceType')))">
a.deviceType,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('deviceMac') or colPickMode == 1 and data.containsKey('deviceMac')))">
a.deviceMac,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('ip') or colPickMode == 1 and data.containsKey('ip')))">
a.ip,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('centernum') or colPickMode == 1 and data.containsKey('centernum')))">
a.centernum,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('port') or colPickMode == 1 and data.containsKey('port')))">
a.port,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('siteNum') or colPickMode == 1 and data.containsKey('siteNum')))">
a.siteNum,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('deviceFirmId') or colPickMode == 1 and data.containsKey('deviceFirmId')))">
a.deviceFirmId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('deviceFirmname') or colPickMode == 1 and data.containsKey('deviceFirmname')))">
a.deviceFirmname,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('deviceOnlineStatus') or colPickMode == 1 and data.containsKey('deviceOnlineStatus')))">
a.deviceOnlineStatus,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('status') or colPickMode == 1 and data.containsKey('status')))">
a.status,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('deviceSource') or colPickMode == 1 and data.containsKey('deviceSource')))">
a.deviceSource,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('deviceRemark') or colPickMode == 1 and data.containsKey('deviceRemark')))">
a.deviceRemark,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('onlineTime') or colPickMode == 1 and data.containsKey('onlineTime')))">
a.onlineTime,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('offlineTime') or colPickMode == 1 and data.containsKey('offlineTime')))">
a.offlineTime,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createUserId') or colPickMode == 1 and data.containsKey('createUserId')))">
a.createUserId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createTime') or colPickMode == 1 and data.containsKey('createTime')))">
a.createTime,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateUserId') or colPickMode == 1 and data.containsKey('updateUserId')))">
a.updateUserId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateTime') or colPickMode == 1 and data.containsKey('updateTime')))">
a.updateTime,
</if>
</trim>
</sql>
<!-- 新增 区分主键自增加还是业务插入 -->
<insert id="insert" parameterType="DeviceEntity" useGeneratedKeys="true" keyProperty="id">
insert into mortals_stp_device
(deviceName,deviceCode,deviceType,deviceMac,ip,centernum,port,siteNum,deviceFirmId,deviceFirmname,deviceOnlineStatus,status,deviceRemark,onlineTime,offlineTime,createUserId,createTime,updateUserId,updateTime)
(deviceName,deviceCode,deviceType,deviceMac,ip,centernum,port,siteNum,deviceFirmId,deviceFirmname,deviceOnlineStatus,status,deviceSource,deviceRemark,onlineTime,offlineTime,createUserId,createTime,updateUserId,updateTime)
VALUES
(#{deviceName},#{deviceCode},#{deviceType},#{deviceMac},#{ip},#{centernum},#{port},#{siteNum},#{deviceFirmId},#{deviceFirmname},#{deviceOnlineStatus},#{status},#{deviceRemark},#{onlineTime},#{offlineTime},#{createUserId},#{createTime},#{updateUserId},#{updateTime})
(#{deviceName},#{deviceCode},#{deviceType},#{deviceMac},#{ip},#{centernum},#{port},#{siteNum},#{deviceFirmId},#{deviceFirmname},#{deviceOnlineStatus},#{status},#{deviceSource},#{deviceRemark},#{onlineTime},#{offlineTime},#{createUserId},#{createTime},#{updateUserId},#{updateTime})
</insert>
<!-- 批量新增 -->
<insert id="insertBatch" parameterType="paramDto">
insert into mortals_stp_device
(deviceName,deviceCode,deviceType,deviceMac,ip,centernum,port,siteNum,deviceFirmId,deviceFirmname,deviceOnlineStatus,status,deviceRemark,onlineTime,offlineTime,createUserId,createTime,updateUserId,updateTime)
(deviceName,deviceCode,deviceType,deviceMac,ip,centernum,port,siteNum,deviceFirmId,deviceFirmname,deviceOnlineStatus,status,deviceSource,deviceRemark,onlineTime,offlineTime,createUserId,createTime,updateUserId,updateTime)
VALUES
<foreach collection="data.dataList" item="item" index="index" separator="," >
(#{item.deviceName},#{item.deviceCode},#{item.deviceType},#{item.deviceMac},#{item.ip},#{item.centernum},#{item.port},#{item.siteNum},#{item.deviceFirmId},#{item.deviceFirmname},#{item.deviceOnlineStatus},#{item.status},#{item.deviceRemark},#{item.onlineTime},#{item.offlineTime},#{item.createUserId},#{item.createTime},#{item.updateUserId},#{item.updateTime})
(#{item.deviceName},#{item.deviceCode},#{item.deviceType},#{item.deviceMac},#{item.ip},#{item.centernum},#{item.port},#{item.siteNum},#{item.deviceFirmId},#{item.deviceFirmname},#{item.deviceOnlineStatus},#{item.status},#{item.deviceSource},#{item.deviceRemark},#{item.onlineTime},#{item.offlineTime},#{item.createUserId},#{item.createTime},#{item.updateUserId},#{item.updateTime})
</foreach>
</insert>
......@@ -166,6 +170,12 @@
<if test="(colPickMode==0 and data.containsKey('statusIncrement')) or (colPickMode==1 and !data.containsKey('statusIncrement'))">
a.status=ifnull(a.status,0) + #{data.statusIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('deviceSource')) or (colPickMode==1 and !data.containsKey('deviceSource'))">
a.deviceSource=#{data.deviceSource},
</if>
<if test="(colPickMode==0 and data.containsKey('deviceSourceIncrement')) or (colPickMode==1 and !data.containsKey('deviceSourceIncrement'))">
a.deviceSource=ifnull(a.deviceSource,0) + #{data.deviceSourceIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('deviceRemark')) or (colPickMode==1 and !data.containsKey('deviceRemark'))">
a.deviceRemark=#{data.deviceRemark},
</if>
......@@ -205,169 +215,181 @@
<update id="updateBatch" parameterType="paramDto">
update mortals_stp_device as a
<trim prefix="set" suffixOverrides=",">
<trim prefix="deviceName=(case" suffix="ELSE deviceName end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('deviceName')) or (colPickMode==1 and !item.containsKey('deviceName'))">
when a.id=#{item.id} then #{item.deviceName}
</if>
</foreach>
</trim>
<trim prefix="deviceCode=(case" suffix="ELSE deviceCode end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('deviceCode')) or (colPickMode==1 and !item.containsKey('deviceCode'))">
when a.id=#{item.id} then #{item.deviceCode}
</if>
</foreach>
</trim>
<trim prefix="deviceType=(case" suffix="ELSE deviceType end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('deviceType')) or (colPickMode==1 and !item.containsKey('deviceType'))">
when a.id=#{item.id} then #{item.deviceType}
</when>
<when test="(colPickMode==0 and item.containsKey('deviceTypeIncrement')) or (colPickMode==1 and !item.containsKey('deviceTypeIncrement'))">
when a.id=#{item.id} then ifnull(a.deviceType,0) + #{item.deviceTypeIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="deviceMac=(case" suffix="ELSE deviceMac end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('deviceMac')) or (colPickMode==1 and !item.containsKey('deviceMac'))">
when a.id=#{item.id} then #{item.deviceMac}
</if>
</foreach>
</trim>
<trim prefix="ip=(case" suffix="ELSE ip end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('ip')) or (colPickMode==1 and !item.containsKey('ip'))">
when a.id=#{item.id} then #{item.ip}
</if>
</foreach>
</trim>
<trim prefix="centernum=(case" suffix="ELSE centernum end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('centernum')) or (colPickMode==1 and !item.containsKey('centernum'))">
when a.id=#{item.id} then #{item.centernum}
</if>
</foreach>
</trim>
<trim prefix="port=(case" suffix="ELSE port end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('port')) or (colPickMode==1 and !item.containsKey('port'))">
when a.id=#{item.id} then #{item.port}
</if>
</foreach>
</trim>
<trim prefix="siteNum=(case" suffix="ELSE siteNum end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('siteNum')) or (colPickMode==1 and !item.containsKey('siteNum'))">
when a.id=#{item.id} then #{item.siteNum}
</if>
</foreach>
</trim>
<trim prefix="deviceFirmId=(case" suffix="ELSE deviceFirmId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('deviceFirmId')) or (colPickMode==1 and !item.containsKey('deviceFirmId'))">
when a.id=#{item.id} then #{item.deviceFirmId}
</when>
<when test="(colPickMode==0 and item.containsKey('deviceFirmIdIncrement')) or (colPickMode==1 and !item.containsKey('deviceFirmIdIncrement'))">
when a.id=#{item.id} then ifnull(a.deviceFirmId,0) + #{item.deviceFirmIdIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="deviceFirmname=(case" suffix="ELSE deviceFirmname end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('deviceFirmname')) or (colPickMode==1 and !item.containsKey('deviceFirmname'))">
when a.id=#{item.id} then #{item.deviceFirmname}
</if>
</foreach>
</trim>
<trim prefix="deviceOnlineStatus=(case" suffix="ELSE deviceOnlineStatus end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('deviceOnlineStatus')) or (colPickMode==1 and !item.containsKey('deviceOnlineStatus'))">
when a.id=#{item.id} then #{item.deviceOnlineStatus}
</when>
<when test="(colPickMode==0 and item.containsKey('deviceOnlineStatusIncrement')) or (colPickMode==1 and !item.containsKey('deviceOnlineStatusIncrement'))">
when a.id=#{item.id} then ifnull(a.deviceOnlineStatus,0) + #{item.deviceOnlineStatusIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="status=(case" suffix="ELSE status end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('status')) or (colPickMode==1 and !item.containsKey('status'))">
when a.id=#{item.id} then #{item.status}
</when>
<when test="(colPickMode==0 and item.containsKey('statusIncrement')) or (colPickMode==1 and !item.containsKey('statusIncrement'))">
when a.id=#{item.id} then ifnull(a.status,0) + #{item.statusIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="deviceRemark=(case" suffix="ELSE deviceRemark end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('deviceRemark')) or (colPickMode==1 and !item.containsKey('deviceRemark'))">
when a.id=#{item.id} then #{item.deviceRemark}
</if>
</foreach>
</trim>
<trim prefix="onlineTime=(case" suffix="ELSE onlineTime end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('onlineTime')) or (colPickMode==1 and !item.containsKey('onlineTime'))">
when a.id=#{item.id} then #{item.onlineTime}
</if>
</foreach>
</trim>
<trim prefix="offlineTime=(case" suffix="ELSE offlineTime end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('offlineTime')) or (colPickMode==1 and !item.containsKey('offlineTime'))">
when a.id=#{item.id} then #{item.offlineTime}
</if>
</foreach>
</trim>
<trim prefix="createUserId=(case" suffix="ELSE createUserId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('createUserId')) or (colPickMode==1 and !item.containsKey('createUserId'))">
when a.id=#{item.id} then #{item.createUserId}
</when>
<when test="(colPickMode==0 and item.containsKey('createUserIdIncrement')) or (colPickMode==1 and !item.containsKey('createUserIdIncrement'))">
when a.id=#{item.id} then ifnull(a.createUserId,0) + #{item.createUserIdIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="createTime=(case" suffix="ELSE createTime end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('createTime')) or (colPickMode==1 and !item.containsKey('createTime'))">
when a.id=#{item.id} then #{item.createTime}
</if>
</foreach>
</trim>
<trim prefix="updateUserId=(case" suffix="ELSE updateUserId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('updateUserId')) or (colPickMode==1 and !item.containsKey('updateUserId'))">
when a.id=#{item.id} then #{item.updateUserId}
</when>
<when test="(colPickMode==0 and item.containsKey('updateUserIdIncrement')) or (colPickMode==1 and !item.containsKey('updateUserIdIncrement'))">
when a.id=#{item.id} then ifnull(a.updateUserId,0) + #{item.updateUserIdIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="updateTime=(case" suffix="ELSE updateTime end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('updateTime')) or (colPickMode==1 and !item.containsKey('updateTime'))">
when a.id=#{item.id} then #{item.updateTime}
</if>
</foreach>
</trim>
<trim prefix="deviceName=(case" suffix="ELSE deviceName end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('deviceName')) or (colPickMode==1 and !item.containsKey('deviceName'))">
when a.id=#{item.id} then #{item.deviceName}
</if>
</foreach>
</trim>
<trim prefix="deviceCode=(case" suffix="ELSE deviceCode end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('deviceCode')) or (colPickMode==1 and !item.containsKey('deviceCode'))">
when a.id=#{item.id} then #{item.deviceCode}
</if>
</foreach>
</trim>
<trim prefix="deviceType=(case" suffix="ELSE deviceType end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('deviceType')) or (colPickMode==1 and !item.containsKey('deviceType'))">
when a.id=#{item.id} then #{item.deviceType}
</when>
<when test="(colPickMode==0 and item.containsKey('deviceTypeIncrement')) or (colPickMode==1 and !item.containsKey('deviceTypeIncrement'))">
when a.id=#{item.id} then ifnull(a.deviceType,0) + #{item.deviceTypeIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="deviceMac=(case" suffix="ELSE deviceMac end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('deviceMac')) or (colPickMode==1 and !item.containsKey('deviceMac'))">
when a.id=#{item.id} then #{item.deviceMac}
</if>
</foreach>
</trim>
<trim prefix="ip=(case" suffix="ELSE ip end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('ip')) or (colPickMode==1 and !item.containsKey('ip'))">
when a.id=#{item.id} then #{item.ip}
</if>
</foreach>
</trim>
<trim prefix="centernum=(case" suffix="ELSE centernum end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('centernum')) or (colPickMode==1 and !item.containsKey('centernum'))">
when a.id=#{item.id} then #{item.centernum}
</if>
</foreach>
</trim>
<trim prefix="port=(case" suffix="ELSE port end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('port')) or (colPickMode==1 and !item.containsKey('port'))">
when a.id=#{item.id} then #{item.port}
</if>
</foreach>
</trim>
<trim prefix="siteNum=(case" suffix="ELSE siteNum end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('siteNum')) or (colPickMode==1 and !item.containsKey('siteNum'))">
when a.id=#{item.id} then #{item.siteNum}
</if>
</foreach>
</trim>
<trim prefix="deviceFirmId=(case" suffix="ELSE deviceFirmId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('deviceFirmId')) or (colPickMode==1 and !item.containsKey('deviceFirmId'))">
when a.id=#{item.id} then #{item.deviceFirmId}
</when>
<when test="(colPickMode==0 and item.containsKey('deviceFirmIdIncrement')) or (colPickMode==1 and !item.containsKey('deviceFirmIdIncrement'))">
when a.id=#{item.id} then ifnull(a.deviceFirmId,0) + #{item.deviceFirmIdIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="deviceFirmname=(case" suffix="ELSE deviceFirmname end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('deviceFirmname')) or (colPickMode==1 and !item.containsKey('deviceFirmname'))">
when a.id=#{item.id} then #{item.deviceFirmname}
</if>
</foreach>
</trim>
<trim prefix="deviceOnlineStatus=(case" suffix="ELSE deviceOnlineStatus end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('deviceOnlineStatus')) or (colPickMode==1 and !item.containsKey('deviceOnlineStatus'))">
when a.id=#{item.id} then #{item.deviceOnlineStatus}
</when>
<when test="(colPickMode==0 and item.containsKey('deviceOnlineStatusIncrement')) or (colPickMode==1 and !item.containsKey('deviceOnlineStatusIncrement'))">
when a.id=#{item.id} then ifnull(a.deviceOnlineStatus,0) + #{item.deviceOnlineStatusIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="status=(case" suffix="ELSE status end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('status')) or (colPickMode==1 and !item.containsKey('status'))">
when a.id=#{item.id} then #{item.status}
</when>
<when test="(colPickMode==0 and item.containsKey('statusIncrement')) or (colPickMode==1 and !item.containsKey('statusIncrement'))">
when a.id=#{item.id} then ifnull(a.status,0) + #{item.statusIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="deviceSource=(case" suffix="ELSE deviceSource end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('deviceSource')) or (colPickMode==1 and !item.containsKey('deviceSource'))">
when a.id=#{item.id} then #{item.deviceSource}
</when>
<when test="(colPickMode==0 and item.containsKey('deviceSourceIncrement')) or (colPickMode==1 and !item.containsKey('deviceSourceIncrement'))">
when a.id=#{item.id} then ifnull(a.deviceSource,0) + #{item.deviceSourceIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="deviceRemark=(case" suffix="ELSE deviceRemark end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('deviceRemark')) or (colPickMode==1 and !item.containsKey('deviceRemark'))">
when a.id=#{item.id} then #{item.deviceRemark}
</if>
</foreach>
</trim>
<trim prefix="onlineTime=(case" suffix="ELSE onlineTime end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('onlineTime')) or (colPickMode==1 and !item.containsKey('onlineTime'))">
when a.id=#{item.id} then #{item.onlineTime}
</if>
</foreach>
</trim>
<trim prefix="offlineTime=(case" suffix="ELSE offlineTime end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('offlineTime')) or (colPickMode==1 and !item.containsKey('offlineTime'))">
when a.id=#{item.id} then #{item.offlineTime}
</if>
</foreach>
</trim>
<trim prefix="createUserId=(case" suffix="ELSE createUserId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('createUserId')) or (colPickMode==1 and !item.containsKey('createUserId'))">
when a.id=#{item.id} then #{item.createUserId}
</when>
<when test="(colPickMode==0 and item.containsKey('createUserIdIncrement')) or (colPickMode==1 and !item.containsKey('createUserIdIncrement'))">
when a.id=#{item.id} then ifnull(a.createUserId,0) + #{item.createUserIdIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="createTime=(case" suffix="ELSE createTime end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('createTime')) or (colPickMode==1 and !item.containsKey('createTime'))">
when a.id=#{item.id} then #{item.createTime}
</if>
</foreach>
</trim>
<trim prefix="updateUserId=(case" suffix="ELSE updateUserId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('updateUserId')) or (colPickMode==1 and !item.containsKey('updateUserId'))">
when a.id=#{item.id} then #{item.updateUserId}
</when>
<when test="(colPickMode==0 and item.containsKey('updateUserIdIncrement')) or (colPickMode==1 and !item.containsKey('updateUserIdIncrement'))">
when a.id=#{item.id} then ifnull(a.updateUserId,0) + #{item.updateUserIdIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="updateTime=(case" suffix="ELSE updateTime end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('updateTime')) or (colPickMode==1 and !item.containsKey('updateTime'))">
when a.id=#{item.id} then #{item.updateTime}
</if>
</foreach>
</trim>
</trim>
where id in
<foreach collection="data.dataList" item="item" index="index" open="(" separator="," close=")">
......@@ -469,461 +491,487 @@
${_conditionType_} a.id=#{${_conditionParam_}.id}
</if>
</if>
<if test="conditionParamRef.containsKey('id')">
<if test="conditionParamRef.id != null ">
${_conditionType_} a.id = #{${_conditionParam_}.id}
</if>
<if test="conditionParamRef.id == null">
${_conditionType_} a.id is null
</if>
</if>
<if test="conditionParamRef.containsKey('idList')">
${_conditionType_} a.id in
<foreach collection="conditionParamRef.idList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('idStart') and conditionParamRef.idStart != null">
${_conditionType_} a.id <![CDATA[ >= ]]> #{${_conditionParam_}.idStart}
<if test="conditionParamRef.containsKey('id')">
<if test="conditionParamRef.id != null ">
${_conditionType_} a.id = #{${_conditionParam_}.id}
</if>
<if test="conditionParamRef.containsKey('idEnd') and conditionParamRef.idEnd != null">
${_conditionType_} a.id <![CDATA[ <= ]]> #{${_conditionParam_}.idEnd}
<if test="conditionParamRef.id == null">
${_conditionType_} a.id is null
</if>
</if>
<if test="conditionParamRef.containsKey('idList')">
${_conditionType_} a.id in
<foreach collection="conditionParamRef.idList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('idStart') and conditionParamRef.idStart != null">
${_conditionType_} a.id <![CDATA[ >= ]]> #{${_conditionParam_}.idStart}
</if>
<if test="conditionParamRef.containsKey('idEnd') and conditionParamRef.idEnd != null">
${_conditionType_} a.id <![CDATA[ <= ]]> #{${_conditionParam_}.idEnd}
</if>
<if test="conditionParamRef.containsKey('deviceName')">
<if test="conditionParamRef.deviceName != null and conditionParamRef.deviceName != ''">
${_conditionType_} a.deviceName like #{${_conditionParam_}.deviceName}
</if>
<if test="conditionParamRef.deviceName == null">
${_conditionType_} a.deviceName is null
</if>
<if test="conditionParamRef.containsKey('deviceName')">
<if test="conditionParamRef.deviceName != null and conditionParamRef.deviceName != ''">
${_conditionType_} a.deviceName like #{${_conditionParam_}.deviceName}
</if>
<if test="conditionParamRef.containsKey('deviceNameList')">
${_conditionType_} a.deviceName in
<foreach collection="conditionParamRef.deviceNameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
<if test="conditionParamRef.deviceName == null">
${_conditionType_} a.deviceName is null
</if>
</if>
<if test="conditionParamRef.containsKey('deviceNameList')">
${_conditionType_} a.deviceName in
<foreach collection="conditionParamRef.deviceNameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('deviceCode')">
<if test="conditionParamRef.deviceCode != null and conditionParamRef.deviceCode != ''">
${_conditionType_} a.deviceCode like #{${_conditionParam_}.deviceCode}
</if>
<if test="conditionParamRef.deviceCode == null">
${_conditionType_} a.deviceCode is null
</if>
</if>
<if test="conditionParamRef.containsKey('deviceCodeList')">
${_conditionType_} a.deviceCode in
<foreach collection="conditionParamRef.deviceCodeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
<if test="conditionParamRef.containsKey('deviceCode')">
<if test="conditionParamRef.deviceCode != null and conditionParamRef.deviceCode != ''">
${_conditionType_} a.deviceCode like #{${_conditionParam_}.deviceCode}
</if>
<if test="conditionParamRef.containsKey('deviceType')">
<if test="conditionParamRef.deviceType != null ">
${_conditionType_} a.deviceType = #{${_conditionParam_}.deviceType}
</if>
<if test="conditionParamRef.deviceType == null">
${_conditionType_} a.deviceType is null
</if>
</if>
<if test="conditionParamRef.containsKey('deviceTypeList')">
${_conditionType_} a.deviceType in
<foreach collection="conditionParamRef.deviceTypeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
<if test="conditionParamRef.deviceCode == null">
${_conditionType_} a.deviceCode is null
</if>
<if test="conditionParamRef.containsKey('deviceTypeStart') and conditionParamRef.deviceTypeStart != null">
${_conditionType_} a.deviceType <![CDATA[ >= ]]> #{${_conditionParam_}.deviceTypeStart}
</if>
<if test="conditionParamRef.containsKey('deviceCodeList')">
${_conditionType_} a.deviceCode in
<foreach collection="conditionParamRef.deviceCodeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('deviceType')">
<if test="conditionParamRef.deviceType != null ">
${_conditionType_} a.deviceType = #{${_conditionParam_}.deviceType}
</if>
<if test="conditionParamRef.containsKey('deviceTypeEnd') and conditionParamRef.deviceTypeEnd != null">
${_conditionType_} a.deviceType <![CDATA[ <= ]]> #{${_conditionParam_}.deviceTypeEnd}
<if test="conditionParamRef.deviceType == null">
${_conditionType_} a.deviceType is null
</if>
</if>
<if test="conditionParamRef.containsKey('deviceTypeList')">
${_conditionType_} a.deviceType in
<foreach collection="conditionParamRef.deviceTypeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('deviceTypeStart') and conditionParamRef.deviceTypeStart != null">
${_conditionType_} a.deviceType <![CDATA[ >= ]]> #{${_conditionParam_}.deviceTypeStart}
</if>
<if test="conditionParamRef.containsKey('deviceTypeEnd') and conditionParamRef.deviceTypeEnd != null">
${_conditionType_} a.deviceType <![CDATA[ <= ]]> #{${_conditionParam_}.deviceTypeEnd}
</if>
<if test="conditionParamRef.containsKey('deviceMac')">
<if test="conditionParamRef.deviceMac != null and conditionParamRef.deviceMac != ''">
${_conditionType_} a.deviceMac like #{${_conditionParam_}.deviceMac}
</if>
<if test="conditionParamRef.deviceMac == null">
${_conditionType_} a.deviceMac is null
</if>
<if test="conditionParamRef.containsKey('deviceMac')">
<if test="conditionParamRef.deviceMac != null and conditionParamRef.deviceMac != ''">
${_conditionType_} a.deviceMac like #{${_conditionParam_}.deviceMac}
</if>
<if test="conditionParamRef.containsKey('deviceMacList')">
${_conditionType_} a.deviceMac in
<foreach collection="conditionParamRef.deviceMacList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
<if test="conditionParamRef.deviceMac == null">
${_conditionType_} a.deviceMac is null
</if>
</if>
<if test="conditionParamRef.containsKey('deviceMacList')">
${_conditionType_} a.deviceMac in
<foreach collection="conditionParamRef.deviceMacList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('ip')">
<if test="conditionParamRef.ip != null and conditionParamRef.ip != ''">
${_conditionType_} a.ip like #{${_conditionParam_}.ip}
</if>
<if test="conditionParamRef.ip == null">
${_conditionType_} a.ip is null
</if>
<if test="conditionParamRef.containsKey('ip')">
<if test="conditionParamRef.ip != null and conditionParamRef.ip != ''">
${_conditionType_} a.ip like #{${_conditionParam_}.ip}
</if>
<if test="conditionParamRef.containsKey('ipList')">
${_conditionType_} a.ip in
<foreach collection="conditionParamRef.ipList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
<if test="conditionParamRef.ip == null">
${_conditionType_} a.ip is null
</if>
</if>
<if test="conditionParamRef.containsKey('ipList')">
${_conditionType_} a.ip in
<foreach collection="conditionParamRef.ipList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('centernum')">
<if test="conditionParamRef.centernum != null and conditionParamRef.centernum != ''">
${_conditionType_} a.centernum like #{${_conditionParam_}.centernum}
</if>
<if test="conditionParamRef.centernum == null">
${_conditionType_} a.centernum is null
</if>
<if test="conditionParamRef.containsKey('centernum')">
<if test="conditionParamRef.centernum != null and conditionParamRef.centernum != ''">
${_conditionType_} a.centernum like #{${_conditionParam_}.centernum}
</if>
<if test="conditionParamRef.containsKey('centernumList')">
${_conditionType_} a.centernum in
<foreach collection="conditionParamRef.centernumList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
<if test="conditionParamRef.centernum == null">
${_conditionType_} a.centernum is null
</if>
</if>
<if test="conditionParamRef.containsKey('centernumList')">
${_conditionType_} a.centernum in
<foreach collection="conditionParamRef.centernumList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('port')">
<if test="conditionParamRef.port != null and conditionParamRef.port != ''">
${_conditionType_} a.port like #{${_conditionParam_}.port}
</if>
<if test="conditionParamRef.port == null">
${_conditionType_} a.port is null
</if>
<if test="conditionParamRef.containsKey('port')">
<if test="conditionParamRef.port != null and conditionParamRef.port != ''">
${_conditionType_} a.port like #{${_conditionParam_}.port}
</if>
<if test="conditionParamRef.containsKey('portList')">
${_conditionType_} a.port in
<foreach collection="conditionParamRef.portList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
<if test="conditionParamRef.port == null">
${_conditionType_} a.port is null
</if>
</if>
<if test="conditionParamRef.containsKey('portList')">
${_conditionType_} a.port in
<foreach collection="conditionParamRef.portList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('siteNum')">
<if test="conditionParamRef.siteNum != null and conditionParamRef.siteNum != ''">
${_conditionType_} a.siteNum like #{${_conditionParam_}.siteNum}
</if>
<if test="conditionParamRef.siteNum == null">
${_conditionType_} a.siteNum is null
</if>
</if>
<if test="conditionParamRef.containsKey('siteNumList')">
${_conditionType_} a.siteNum in
<foreach collection="conditionParamRef.siteNumList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('deviceFirmId')">
<if test="conditionParamRef.deviceFirmId != null ">
${_conditionType_} a.deviceFirmId = #{${_conditionParam_}.deviceFirmId}
</if>
<if test="conditionParamRef.deviceFirmId == null">
${_conditionType_} a.deviceFirmId is null
</if>
<if test="conditionParamRef.containsKey('siteNum')">
<if test="conditionParamRef.siteNum != null and conditionParamRef.siteNum != ''">
${_conditionType_} a.siteNum like #{${_conditionParam_}.siteNum}
</if>
<if test="conditionParamRef.containsKey('deviceFirmIdList')">
${_conditionType_} a.deviceFirmId in
<foreach collection="conditionParamRef.deviceFirmIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
<if test="conditionParamRef.siteNum == null">
${_conditionType_} a.siteNum is null
</if>
<if test="conditionParamRef.containsKey('deviceFirmIdStart') and conditionParamRef.deviceFirmIdStart != null">
${_conditionType_} a.deviceFirmId <![CDATA[ >= ]]> #{${_conditionParam_}.deviceFirmIdStart}
</if>
<if test="conditionParamRef.containsKey('siteNumList')">
${_conditionType_} a.siteNum in
<foreach collection="conditionParamRef.siteNumList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('deviceFirmId')">
<if test="conditionParamRef.deviceFirmId != null ">
${_conditionType_} a.deviceFirmId = #{${_conditionParam_}.deviceFirmId}
</if>
<if test="conditionParamRef.containsKey('deviceFirmIdEnd') and conditionParamRef.deviceFirmIdEnd != null">
${_conditionType_} a.deviceFirmId <![CDATA[ <= ]]> #{${_conditionParam_}.deviceFirmIdEnd}
<if test="conditionParamRef.deviceFirmId == null">
${_conditionType_} a.deviceFirmId is null
</if>
</if>
<if test="conditionParamRef.containsKey('deviceFirmIdList')">
${_conditionType_} a.deviceFirmId in
<foreach collection="conditionParamRef.deviceFirmIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('deviceFirmIdStart') and conditionParamRef.deviceFirmIdStart != null">
${_conditionType_} a.deviceFirmId <![CDATA[ >= ]]> #{${_conditionParam_}.deviceFirmIdStart}
</if>
<if test="conditionParamRef.containsKey('deviceFirmIdEnd') and conditionParamRef.deviceFirmIdEnd != null">
${_conditionType_} a.deviceFirmId <![CDATA[ <= ]]> #{${_conditionParam_}.deviceFirmIdEnd}
</if>
<if test="conditionParamRef.containsKey('deviceFirmname')">
<if test="conditionParamRef.deviceFirmname != null and conditionParamRef.deviceFirmname != ''">
${_conditionType_} a.deviceFirmname like #{${_conditionParam_}.deviceFirmname}
</if>
<if test="conditionParamRef.deviceFirmname == null">
${_conditionType_} a.deviceFirmname is null
</if>
</if>
<if test="conditionParamRef.containsKey('deviceFirmnameList')">
${_conditionType_} a.deviceFirmname in
<foreach collection="conditionParamRef.deviceFirmnameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('deviceOnlineStatus')">
<if test="conditionParamRef.deviceOnlineStatus != null ">
${_conditionType_} a.deviceOnlineStatus = #{${_conditionParam_}.deviceOnlineStatus}
</if>
<if test="conditionParamRef.deviceOnlineStatus == null">
${_conditionType_} a.deviceOnlineStatus is null
</if>
<if test="conditionParamRef.containsKey('deviceFirmname')">
<if test="conditionParamRef.deviceFirmname != null and conditionParamRef.deviceFirmname != ''">
${_conditionType_} a.deviceFirmname like #{${_conditionParam_}.deviceFirmname}
</if>
<if test="conditionParamRef.containsKey('deviceOnlineStatusList')">
${_conditionType_} a.deviceOnlineStatus in
<foreach collection="conditionParamRef.deviceOnlineStatusList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
<if test="conditionParamRef.deviceFirmname == null">
${_conditionType_} a.deviceFirmname is null
</if>
<if test="conditionParamRef.containsKey('deviceOnlineStatusStart') and conditionParamRef.deviceOnlineStatusStart != null">
${_conditionType_} a.deviceOnlineStatus <![CDATA[ >= ]]> #{${_conditionParam_}.deviceOnlineStatusStart}
</if>
<if test="conditionParamRef.containsKey('deviceFirmnameList')">
${_conditionType_} a.deviceFirmname in
<foreach collection="conditionParamRef.deviceFirmnameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('deviceOnlineStatus')">
<if test="conditionParamRef.deviceOnlineStatus != null ">
${_conditionType_} a.deviceOnlineStatus = #{${_conditionParam_}.deviceOnlineStatus}
</if>
<if test="conditionParamRef.containsKey('deviceOnlineStatusEnd') and conditionParamRef.deviceOnlineStatusEnd != null">
${_conditionType_} a.deviceOnlineStatus <![CDATA[ <= ]]> #{${_conditionParam_}.deviceOnlineStatusEnd}
<if test="conditionParamRef.deviceOnlineStatus == null">
${_conditionType_} a.deviceOnlineStatus is null
</if>
</if>
<if test="conditionParamRef.containsKey('deviceOnlineStatusList')">
${_conditionType_} a.deviceOnlineStatus in
<foreach collection="conditionParamRef.deviceOnlineStatusList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('deviceOnlineStatusStart') and conditionParamRef.deviceOnlineStatusStart != null">
${_conditionType_} a.deviceOnlineStatus <![CDATA[ >= ]]> #{${_conditionParam_}.deviceOnlineStatusStart}
</if>
<if test="conditionParamRef.containsKey('deviceOnlineStatusEnd') and conditionParamRef.deviceOnlineStatusEnd != null">
${_conditionType_} a.deviceOnlineStatus <![CDATA[ <= ]]> #{${_conditionParam_}.deviceOnlineStatusEnd}
</if>
<if test="conditionParamRef.containsKey('status')">
<if test="conditionParamRef.status != null ">
${_conditionType_} a.status = #{${_conditionParam_}.status}
</if>
<if test="conditionParamRef.status == null">
${_conditionType_} a.status is null
</if>
<if test="conditionParamRef.containsKey('status')">
<if test="conditionParamRef.status != null ">
${_conditionType_} a.status = #{${_conditionParam_}.status}
</if>
<if test="conditionParamRef.containsKey('statusList')">
${_conditionType_} a.status in
<foreach collection="conditionParamRef.statusList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
<if test="conditionParamRef.status == null">
${_conditionType_} a.status is null
</if>
<if test="conditionParamRef.containsKey('statusStart') and conditionParamRef.statusStart != null">
${_conditionType_} a.status <![CDATA[ >= ]]> #{${_conditionParam_}.statusStart}
</if>
<if test="conditionParamRef.containsKey('statusList')">
${_conditionType_} a.status in
<foreach collection="conditionParamRef.statusList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('statusStart') and conditionParamRef.statusStart != null">
${_conditionType_} a.status <![CDATA[ >= ]]> #{${_conditionParam_}.statusStart}
</if>
<if test="conditionParamRef.containsKey('statusEnd') and conditionParamRef.statusEnd != null">
${_conditionType_} a.status <![CDATA[ <= ]]> #{${_conditionParam_}.statusEnd}
</if>
<if test="conditionParamRef.containsKey('deviceSource')">
<if test="conditionParamRef.deviceSource != null ">
${_conditionType_} a.deviceSource = #{${_conditionParam_}.deviceSource}
</if>
<if test="conditionParamRef.containsKey('statusEnd') and conditionParamRef.statusEnd != null">
${_conditionType_} a.status <![CDATA[ <= ]]> #{${_conditionParam_}.statusEnd}
<if test="conditionParamRef.deviceSource == null">
${_conditionType_} a.deviceSource is null
</if>
</if>
<if test="conditionParamRef.containsKey('deviceSourceList')">
${_conditionType_} a.deviceSource in
<foreach collection="conditionParamRef.deviceSourceList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('deviceSourceStart') and conditionParamRef.deviceSourceStart != null">
${_conditionType_} a.deviceSource <![CDATA[ >= ]]> #{${_conditionParam_}.deviceSourceStart}
</if>
<if test="conditionParamRef.containsKey('deviceSourceEnd') and conditionParamRef.deviceSourceEnd != null">
${_conditionType_} a.deviceSource <![CDATA[ <= ]]> #{${_conditionParam_}.deviceSourceEnd}
</if>
<if test="conditionParamRef.containsKey('deviceRemark')">
<if test="conditionParamRef.deviceRemark != null and conditionParamRef.deviceRemark != ''">
${_conditionType_} a.deviceRemark like #{${_conditionParam_}.deviceRemark}
</if>
<if test="conditionParamRef.deviceRemark == null">
${_conditionType_} a.deviceRemark is null
</if>
<if test="conditionParamRef.containsKey('deviceRemark')">
<if test="conditionParamRef.deviceRemark != null and conditionParamRef.deviceRemark != ''">
${_conditionType_} a.deviceRemark like #{${_conditionParam_}.deviceRemark}
</if>
<if test="conditionParamRef.containsKey('deviceRemarkList')">
${_conditionType_} a.deviceRemark in
<foreach collection="conditionParamRef.deviceRemarkList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
<if test="conditionParamRef.deviceRemark == null">
${_conditionType_} a.deviceRemark is null
</if>
</if>
<if test="conditionParamRef.containsKey('deviceRemarkList')">
${_conditionType_} a.deviceRemark in
<foreach collection="conditionParamRef.deviceRemarkList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('onlineTime')">
<if test="conditionParamRef.onlineTime != null ">
${_conditionType_} a.onlineTime = #{${_conditionParam_}.onlineTime}
</if>
<if test="conditionParamRef.onlineTime == null">
${_conditionType_} a.onlineTime is null
</if>
<if test="conditionParamRef.containsKey('onlineTime')">
<if test="conditionParamRef.onlineTime != null ">
${_conditionType_} a.onlineTime = #{${_conditionParam_}.onlineTime}
</if>
<if test="conditionParamRef.containsKey('onlineTimeStart') and conditionParamRef.onlineTimeStart != null and conditionParamRef.onlineTimeStart!=''">
${_conditionType_} a.onlineTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.onlineTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('onlineTimeEnd') and conditionParamRef.onlineTimeEnd != null and conditionParamRef.onlineTimeEnd!=''">
${_conditionType_} a.onlineTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.onlineTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
<if test="conditionParamRef.onlineTime == null">
${_conditionType_} a.onlineTime is null
</if>
</if>
<if test="conditionParamRef.containsKey('onlineTimeStart') and conditionParamRef.onlineTimeStart != null and conditionParamRef.onlineTimeStart!=''">
${_conditionType_} a.onlineTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.onlineTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('onlineTimeEnd') and conditionParamRef.onlineTimeEnd != null and conditionParamRef.onlineTimeEnd!=''">
${_conditionType_} a.onlineTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.onlineTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('offlineTime')">
<if test="conditionParamRef.offlineTime != null ">
${_conditionType_} a.offlineTime = #{${_conditionParam_}.offlineTime}
</if>
<if test="conditionParamRef.offlineTime == null">
${_conditionType_} a.offlineTime is null
</if>
<if test="conditionParamRef.containsKey('offlineTime')">
<if test="conditionParamRef.offlineTime != null ">
${_conditionType_} a.offlineTime = #{${_conditionParam_}.offlineTime}
</if>
<if test="conditionParamRef.containsKey('offlineTimeStart') and conditionParamRef.offlineTimeStart != null and conditionParamRef.offlineTimeStart!=''">
${_conditionType_} a.offlineTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.offlineTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
<if test="conditionParamRef.offlineTime == null">
${_conditionType_} a.offlineTime is null
</if>
<if test="conditionParamRef.containsKey('offlineTimeEnd') and conditionParamRef.offlineTimeEnd != null and conditionParamRef.offlineTimeEnd!=''">
${_conditionType_} a.offlineTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.offlineTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('createUserId')">
<if test="conditionParamRef.createUserId != null ">
${_conditionType_} a.createUserId = #{${_conditionParam_}.createUserId}
</if>
<if test="conditionParamRef.createUserId == null">
${_conditionType_} a.createUserId is null
</if>
</if>
<if test="conditionParamRef.containsKey('createUserIdList')">
${_conditionType_} a.createUserId in
<foreach collection="conditionParamRef.createUserIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('createUserIdStart') and conditionParamRef.createUserIdStart != null">
${_conditionType_} a.createUserId <![CDATA[ >= ]]> #{${_conditionParam_}.createUserIdStart}
</if>
<if test="conditionParamRef.containsKey('offlineTimeStart') and conditionParamRef.offlineTimeStart != null and conditionParamRef.offlineTimeStart!=''">
${_conditionType_} a.offlineTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.offlineTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('offlineTimeEnd') and conditionParamRef.offlineTimeEnd != null and conditionParamRef.offlineTimeEnd!=''">
${_conditionType_} a.offlineTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.offlineTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('createUserId')">
<if test="conditionParamRef.createUserId != null ">
${_conditionType_} a.createUserId = #{${_conditionParam_}.createUserId}
</if>
<if test="conditionParamRef.containsKey('createUserIdEnd') and conditionParamRef.createUserIdEnd != null">
${_conditionType_} a.createUserId <![CDATA[ <= ]]> #{${_conditionParam_}.createUserIdEnd}
<if test="conditionParamRef.createUserId == null">
${_conditionType_} a.createUserId is null
</if>
</if>
<if test="conditionParamRef.containsKey('createUserIdList')">
${_conditionType_} a.createUserId in
<foreach collection="conditionParamRef.createUserIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('createUserIdStart') and conditionParamRef.createUserIdStart != null">
${_conditionType_} a.createUserId <![CDATA[ >= ]]> #{${_conditionParam_}.createUserIdStart}
</if>
<if test="conditionParamRef.containsKey('createUserIdEnd') and conditionParamRef.createUserIdEnd != null">
${_conditionType_} a.createUserId <![CDATA[ <= ]]> #{${_conditionParam_}.createUserIdEnd}
</if>
<if test="conditionParamRef.containsKey('createTime')">
<if test="conditionParamRef.createTime != null ">
${_conditionType_} a.createTime = #{${_conditionParam_}.createTime}
</if>
<if test="conditionParamRef.createTime == null">
${_conditionType_} a.createTime is null
</if>
</if>
<if test="conditionParamRef.containsKey('createTimeStart') and conditionParamRef.createTimeStart != null and conditionParamRef.createTimeStart!=''">
${_conditionType_} a.createTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
<if test="conditionParamRef.containsKey('createTime')">
<if test="conditionParamRef.createTime != null ">
${_conditionType_} a.createTime = #{${_conditionParam_}.createTime}
</if>
<if test="conditionParamRef.containsKey('createTimeEnd') and conditionParamRef.createTimeEnd != null and conditionParamRef.createTimeEnd!=''">
${_conditionType_} a.createTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
<if test="conditionParamRef.createTime == null">
${_conditionType_} a.createTime is null
</if>
<if test="conditionParamRef.containsKey('updateUserId')">
<if test="conditionParamRef.updateUserId != null ">
${_conditionType_} a.updateUserId = #{${_conditionParam_}.updateUserId}
</if>
<if test="conditionParamRef.updateUserId == null">
${_conditionType_} a.updateUserId is null
</if>
</if>
<if test="conditionParamRef.containsKey('updateUserIdList')">
${_conditionType_} a.updateUserId in
<foreach collection="conditionParamRef.updateUserIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('updateUserIdStart') and conditionParamRef.updateUserIdStart != null">
${_conditionType_} a.updateUserId <![CDATA[ >= ]]> #{${_conditionParam_}.updateUserIdStart}
</if>
<if test="conditionParamRef.containsKey('createTimeStart') and conditionParamRef.createTimeStart != null and conditionParamRef.createTimeStart!=''">
${_conditionType_} a.createTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('createTimeEnd') and conditionParamRef.createTimeEnd != null and conditionParamRef.createTimeEnd!=''">
${_conditionType_} a.createTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('updateUserId')">
<if test="conditionParamRef.updateUserId != null ">
${_conditionType_} a.updateUserId = #{${_conditionParam_}.updateUserId}
</if>
<if test="conditionParamRef.containsKey('updateUserIdEnd') and conditionParamRef.updateUserIdEnd != null">
${_conditionType_} a.updateUserId <![CDATA[ <= ]]> #{${_conditionParam_}.updateUserIdEnd}
<if test="conditionParamRef.updateUserId == null">
${_conditionType_} a.updateUserId is null
</if>
</if>
<if test="conditionParamRef.containsKey('updateUserIdList')">
${_conditionType_} a.updateUserId in
<foreach collection="conditionParamRef.updateUserIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('updateUserIdStart') and conditionParamRef.updateUserIdStart != null">
${_conditionType_} a.updateUserId <![CDATA[ >= ]]> #{${_conditionParam_}.updateUserIdStart}
</if>
<if test="conditionParamRef.containsKey('updateUserIdEnd') and conditionParamRef.updateUserIdEnd != null">
${_conditionType_} a.updateUserId <![CDATA[ <= ]]> #{${_conditionParam_}.updateUserIdEnd}
</if>
<if test="conditionParamRef.containsKey('updateTime')">
<if test="conditionParamRef.updateTime != null ">
${_conditionType_} a.updateTime = #{${_conditionParam_}.updateTime}
</if>
<if test="conditionParamRef.updateTime == null">
${_conditionType_} a.updateTime is null
</if>
<if test="conditionParamRef.containsKey('updateTime')">
<if test="conditionParamRef.updateTime != null ">
${_conditionType_} a.updateTime = #{${_conditionParam_}.updateTime}
</if>
<if test="conditionParamRef.containsKey('updateTimeStart') and conditionParamRef.updateTimeStart != null and conditionParamRef.updateTimeStart!=''">
${_conditionType_} a.updateTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('updateTimeEnd') and conditionParamRef.updateTimeEnd != null and conditionParamRef.updateTimeEnd!=''">
${_conditionType_} a.updateTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
<if test="conditionParamRef.updateTime == null">
${_conditionType_} a.updateTime is null
</if>
</if>
<if test="conditionParamRef.containsKey('updateTimeStart') and conditionParamRef.updateTimeStart != null and conditionParamRef.updateTimeStart!=''">
${_conditionType_} a.updateTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('updateTimeEnd') and conditionParamRef.updateTimeEnd != null and conditionParamRef.updateTimeEnd!=''">
${_conditionType_} a.updateTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if>
</sql>
<sql id="_orderCols_">
<if test="orderColList != null and !orderColList.isEmpty()">
order by
<trim suffixOverrides="," suffix="">
<foreach collection="orderColList" open="" close="" index="index" item="item" separator=",">
${item.colName} ${item.sortKind}
${item.colName} ${item.sortKind}
</foreach>
</trim>
</if>
<if test="(orderColList == null or orderColList.isEmpty()) and orderCol != null and !orderCol.isEmpty()">
order by
<trim suffixOverrides="," suffix="">
<if test="orderCol.containsKey('id')">
a.id
<if test='orderCol.id != null and "DESC".equalsIgnoreCase(orderCol.id)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('deviceName')">
a.deviceName
<if test='orderCol.deviceName != null and "DESC".equalsIgnoreCase(orderCol.deviceName)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('deviceCode')">
a.deviceCode
<if test='orderCol.deviceCode != null and "DESC".equalsIgnoreCase(orderCol.deviceCode)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('deviceType')">
a.deviceType
<if test='orderCol.deviceType != null and "DESC".equalsIgnoreCase(orderCol.deviceType)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('deviceMac')">
a.deviceMac
<if test='orderCol.deviceMac != null and "DESC".equalsIgnoreCase(orderCol.deviceMac)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('ip')">
a.ip
<if test='orderCol.ip != null and "DESC".equalsIgnoreCase(orderCol.ip)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('centernum')">
a.centernum
<if test='orderCol.centernum != null and "DESC".equalsIgnoreCase(orderCol.centernum)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('port')">
a.port
<if test='orderCol.port != null and "DESC".equalsIgnoreCase(orderCol.port)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('siteNum')">
a.siteNum
<if test='orderCol.siteNum != null and "DESC".equalsIgnoreCase(orderCol.siteNum)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('deviceFirmId')">
a.deviceFirmId
<if test='orderCol.deviceFirmId != null and "DESC".equalsIgnoreCase(orderCol.deviceFirmId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('deviceFirmname')">
a.deviceFirmname
<if test='orderCol.deviceFirmname != null and "DESC".equalsIgnoreCase(orderCol.deviceFirmname)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('deviceOnlineStatus')">
a.deviceOnlineStatus
<if test='orderCol.deviceOnlineStatus != null and "DESC".equalsIgnoreCase(orderCol.deviceOnlineStatus)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('status')">
a.status
<if test='orderCol.status != null and "DESC".equalsIgnoreCase(orderCol.status)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('deviceRemark')">
a.deviceRemark
<if test='orderCol.deviceRemark != null and "DESC".equalsIgnoreCase(orderCol.deviceRemark)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('onlineTime')">
a.onlineTime
<if test='orderCol.onlineTime != null and "DESC".equalsIgnoreCase(orderCol.onlineTime)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('offlineTime')">
a.offlineTime
<if test='orderCol.offlineTime != null and "DESC".equalsIgnoreCase(orderCol.offlineTime)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('createUserId')">
a.createUserId
<if test='orderCol.createUserId != null and "DESC".equalsIgnoreCase(orderCol.createUserId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('createTime')">
a.createTime
<if test='orderCol.createTime != null and "DESC".equalsIgnoreCase(orderCol.createTime)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('updateUserId')">
a.updateUserId
<if test='orderCol.updateUserId != null and "DESC".equalsIgnoreCase(orderCol.updateUserId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('updateTime')">
a.updateTime
<if test='orderCol.updateTime != null and "DESC".equalsIgnoreCase(orderCol.updateTime)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('id')">
a.id
<if test='orderCol.id != null and "DESC".equalsIgnoreCase(orderCol.id)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('deviceName')">
a.deviceName
<if test='orderCol.deviceName != null and "DESC".equalsIgnoreCase(orderCol.deviceName)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('deviceCode')">
a.deviceCode
<if test='orderCol.deviceCode != null and "DESC".equalsIgnoreCase(orderCol.deviceCode)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('deviceType')">
a.deviceType
<if test='orderCol.deviceType != null and "DESC".equalsIgnoreCase(orderCol.deviceType)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('deviceMac')">
a.deviceMac
<if test='orderCol.deviceMac != null and "DESC".equalsIgnoreCase(orderCol.deviceMac)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('ip')">
a.ip
<if test='orderCol.ip != null and "DESC".equalsIgnoreCase(orderCol.ip)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('centernum')">
a.centernum
<if test='orderCol.centernum != null and "DESC".equalsIgnoreCase(orderCol.centernum)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('port')">
a.port
<if test='orderCol.port != null and "DESC".equalsIgnoreCase(orderCol.port)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('siteNum')">
a.siteNum
<if test='orderCol.siteNum != null and "DESC".equalsIgnoreCase(orderCol.siteNum)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('deviceFirmId')">
a.deviceFirmId
<if test='orderCol.deviceFirmId != null and "DESC".equalsIgnoreCase(orderCol.deviceFirmId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('deviceFirmname')">
a.deviceFirmname
<if test='orderCol.deviceFirmname != null and "DESC".equalsIgnoreCase(orderCol.deviceFirmname)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('deviceOnlineStatus')">
a.deviceOnlineStatus
<if test='orderCol.deviceOnlineStatus != null and "DESC".equalsIgnoreCase(orderCol.deviceOnlineStatus)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('status')">
a.status
<if test='orderCol.status != null and "DESC".equalsIgnoreCase(orderCol.status)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('deviceSource')">
a.deviceSource
<if test='orderCol.deviceSource != null and "DESC".equalsIgnoreCase(orderCol.deviceSource)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('deviceRemark')">
a.deviceRemark
<if test='orderCol.deviceRemark != null and "DESC".equalsIgnoreCase(orderCol.deviceRemark)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('onlineTime')">
a.onlineTime
<if test='orderCol.onlineTime != null and "DESC".equalsIgnoreCase(orderCol.onlineTime)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('offlineTime')">
a.offlineTime
<if test='orderCol.offlineTime != null and "DESC".equalsIgnoreCase(orderCol.offlineTime)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('createUserId')">
a.createUserId
<if test='orderCol.createUserId != null and "DESC".equalsIgnoreCase(orderCol.createUserId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('createTime')">
a.createTime
<if test='orderCol.createTime != null and "DESC".equalsIgnoreCase(orderCol.createTime)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('updateUserId')">
a.updateUserId
<if test='orderCol.updateUserId != null and "DESC".equalsIgnoreCase(orderCol.updateUserId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('updateTime')">
a.updateTime
<if test='orderCol.updateTime != null and "DESC".equalsIgnoreCase(orderCol.updateTime)'>DESC</if>
,
</if>
</trim>
</if>
</sql>
......
device-manager/src/test/java/com/mortals/httpclient/device/DeviceController.http
View file @ 5761b10c
......@@ -28,7 +28,7 @@ Content-Type: application/json
"status":0,
"deviceRemark":"plxklr",
"onlineTime":"1646755200000",
"offlineTime":"1646755200000",
"offlineTime":"1646755200000"
}
> {%
......@@ -50,4 +50,12 @@ Accept: application/json
###设备上报
POST {{baseUrl}}/api/device/upload
Content-Type: application/json
{
"devicenum":"AB:DD:DF:FD:AD:FA:DA:SS",
"action":"upload"
}
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