添加预警类

db/menu.sql

@@ -225,3 +225,50 @@ INSERT INTO `mortals_xhx_resource` VALUES (null, '设备业务-菜单管理-维
 -- ----------------------------
 INSERT INTO `mortals_xhx_param` VALUES (null, '设备状态 ', 'Device', 'deviceStatus', '1', '离线', 1, 4, 0, 'deviceStatus', NULL, NULL, NULL);
 INSERT INTO `mortals_xhx_param` VALUES (null, '设备状态 ', 'Device', 'deviceStatus', '2', '在线', 1, 4, 0, 'deviceStatus', NULL, NULL, NULL);
+
+-- ----------------------------
+-- 监测预警记录菜单 SQL
+-- ----------------------------
+INSERT INTO `mortals_xhx_menu` VALUES (null, '监测预警记录', '/monitor/alarm/list', 0,'', 1, 1, 0, 0,'',NULL, NULL, NULL, 0, 0, 1, NULL, NULL, NULL);
+
+-- ----------------------------
+-- 监测预警记录资源路径 SQL
+-- ----------------------------
+INSERT INTO `mortals_xhx_resource` VALUES (null, '监测预警记录-菜单管理-查看', '/monitor/alarm/list,/monitor/alarm/view,/monitor/alarm/info,/monitor/alarm/export,/monitor/alarm/exportExcel,/monitor/alarm/downloadTemplate,/monitor/alarm/download', 3, 0, NULL, NULL, NULL, 0);
+INSERT INTO `mortals_xhx_resource` VALUES (null, '监测预警记录-菜单管理-维护', '/monitor/alarm/add,/monitor/alarm/edit,/monitor/alarm/delete,/monitor/alarm/logicDelete,/monitor/alarm/save,/monitor/alarm/importData', 3, 0, NULL, NULL, NULL, 0);
+
+-- ----------------------------
+-- 监测预警记录参数 SQL
+-- ----------------------------
+-- ----------------------------
+-- 用户消息菜单 SQL
+-- ----------------------------
+INSERT INTO `mortals_xhx_menu` VALUES (null, '用户消息', '/notice/list', 0,'', 1, 1, 0, 0,'',NULL, NULL, NULL, 0, 0, 1, NULL, NULL, NULL);
+
+-- ----------------------------
+-- 用户消息资源路径 SQL
+-- ----------------------------
+INSERT INTO `mortals_xhx_resource` VALUES (null, '用户消息-菜单管理-查看', '/notice/list,/notice/view,/notice/info,/notice/export,/notice/exportExcel,/notice/downloadTemplate,/notice/download', 3, 0, NULL, NULL, NULL, 0);
+INSERT INTO `mortals_xhx_resource` VALUES (null, '用户消息-菜单管理-维护', '/notice/add,/notice/edit,/notice/delete,/notice/logicDelete,/notice/save,/notice/importData', 3, 0, NULL, NULL, NULL, 0);
+
+-- ----------------------------
+-- 用户消息参数 SQL
+-- ----------------------------
+INSERT INTO `mortals_xhx_param` VALUES (null, '是否已读 ', 'Notice', 'read', '0', '否', 1, 4, 0, 'read', NULL, NULL, NULL);
+INSERT INTO `mortals_xhx_param` VALUES (null, '是否已读 ', 'Notice', 'read', '1', '是', 1, 4, 0, 'read', NULL, NULL, NULL);
+-- ----------------------------
+-- 监测预警记录详细记录菜单 SQL
+-- ----------------------------
+INSERT INTO `mortals_xhx_menu` VALUES (null, '监测预警记录详细记录', '/monitor/alarm/record/list', 0,'', 1, 1, 0, 0,'',NULL, NULL, NULL, 0, 0, 1, NULL, NULL, NULL);
+
+-- ----------------------------
+-- 监测预警记录详细记录资源路径 SQL
+-- ----------------------------
+INSERT INTO `mortals_xhx_resource` VALUES (null, '监测预警记录详细记录-菜单管理-查看', '/monitor/alarm/record/list,/monitor/alarm/record/view,/monitor/alarm/record/info,/monitor/alarm/record/export,/monitor/alarm/record/exportExcel,/monitor/alarm/record/downloadTemplate,/monitor/alarm/record/download', 3, 0, NULL, NULL, NULL, 0);
+INSERT INTO `mortals_xhx_resource` VALUES (null, '监测预警记录详细记录-菜单管理-维护', '/monitor/alarm/record/add,/monitor/alarm/record/edit,/monitor/alarm/record/delete,/monitor/alarm/record/logicDelete,/monitor/alarm/record/save,/monitor/alarm/record/importData', 3, 0, NULL, NULL, NULL, 0);
+
+-- ----------------------------
+-- 监测预警记录详细记录参数 SQL
+-- ----------------------------
+INSERT INTO `mortals_xhx_param` VALUES (null, '签到方式', 'MonitorAlarmRecord', 'checkInMethod', '0', '自动签到', 1, 4, 0, 'checkInMethod', NULL, NULL, NULL);
+INSERT INTO `mortals_xhx_param` VALUES (null, '签到方式', 'MonitorAlarmRecord', 'checkInMethod', '1', '手动签到', 1, 4, 0, 'checkInMethod', NULL, NULL, NULL);

db/module.sql

@@ -235,7 +235,7 @@ CREATE TABLE mortals_xhx_person(
     `phone` varchar(20)      COMMENT '手机号码',
     `birthday` datetime NOT NULL     COMMENT '出生日期',
     `address` varchar(256) NOT NULL     COMMENT '家庭住址',
-    `photo` varchar(100) NOT NULL     COMMENT '照片路径',
+    `photo` varchar(256) NOT NULL     COMMENT '照片路径',
     `remark` varchar(256)      COMMENT '备注',
     `source` tinyint(2)      COMMENT '注册人员来源(0.预约系统,1.排队叫号系统,2.自助服务系统,99.其它)',
     `inFaceHk` tinyint(2) NOT NULL   DEFAULT '0'  COMMENT '是否添加到海康人脸库(0.否，1.是)',
@@ -256,7 +256,7 @@ CREATE TABLE mortals_xhx_device(
     `siteId` bigint(20)      COMMENT '站点Id',
     `siteName` varchar(256)      COMMENT '站点名称',
     `deviceId` varchar(64)      COMMENT '设备ID，海康',
-    `deviceName` varchar(20) NOT NULL     COMMENT '设备名称',
+    `deviceName` varchar(256) NOT NULL     COMMENT '设备名称',
     `deviceCode` varchar(256)      COMMENT '设备编码',
     `deviceMac` varchar(64)      COMMENT '设备的MAC地址',
     `deviceLocation` varchar(255)    DEFAULT '2'  COMMENT '设备位置',
@@ -266,9 +266,15 @@ CREATE TABLE mortals_xhx_device(
     `build` int(4)      COMMENT '楼栋',
     `leadingOfficial` varchar(20)      COMMENT '负责人',
     `leadingOfficialTelephone` varchar(32)      COMMENT '联系电话',
-    `timeOutPeriod` int(4)      COMMENT '超时时间，单位天',
-    `nearTime` int(4)      COMMENT '临近时间，单位天',
-    `deviceStatus` tinyint(2)      COMMENT '设备状态 (1.离线,2.在线)',
+    `timeOutPeriod` int(4)    DEFAULT '0'  COMMENT '超时时间，单位天',
+    `nearTime` int(4)    DEFAULT '0'  COMMENT '临近时间，单位天',
+    `deviceStatus` tinyint(2)    DEFAULT '2'  COMMENT '设备状态 (1.离线,2.在线)',
+    `regionIndexCode` varchar(128)      COMMENT '区域编码',
+    `cameraTypeName` varchar(32)      COMMENT '类型名称',
+    `cameraType` int(4)      COMMENT '设备类型',
+    `encodeDevIndexCode` varchar(128)      COMMENT '编码',
+    `capabilitySet` varchar(1024)      COMMENT '设备能力',
+    `capabilitySetName` varchar(1024)      COMMENT '设备能力名称',
     `deviceRemark` varchar(256)      COMMENT '备注',
     `createUserId` bigint(20) NOT NULL     COMMENT '创建用户',
     `createTime` datetime NOT NULL     COMMENT '创建时间',
@@ -276,3 +282,68 @@ CREATE TABLE mortals_xhx_device(
     `updateTime` datetime      COMMENT '更新时间',
 PRIMARY KEY  (`id`)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='设备业务';
+
+-- ----------------------------
+-- 监测预警记录表
+-- ----------------------------
+DROP TABLE IF EXISTS `mortals_xhx_monitor_alarm`;
+CREATE TABLE mortals_xhx_monitor_alarm(
+    `id` bigint(20) NOT NULL  AUTO_INCREMENT   COMMENT '主键ID，主键，自增长',
+    `siteId` bigint(20)      COMMENT '站点Id',
+    `siteName` varchar(256)      COMMENT '站点名称',
+    `personId` bigint(20) NOT NULL     COMMENT '人员id',
+    `name` varchar(255)      COMMENT '姓名',
+    `contact` varchar(255)      COMMENT '联系方式',
+    `idNumber` varchar(255) NOT NULL     COMMENT '身份证号码',
+    `identifyNum` int(4)    DEFAULT '0'  COMMENT '识别频次',
+    `lastIdentifyTime` datetime      COMMENT '最后识别时间',
+    `year` int(9) NOT NULL     COMMENT '年',
+    `month` int(9) NOT NULL     COMMENT '月',
+    `day` int(9) NOT NULL     COMMENT '日',
+    `createTime` datetime      COMMENT '创建时间',
+    `createUserId` bigint(20)      COMMENT '创建人id',
+    `updateTime` datetime      COMMENT '更新时间',
+    `updateUserId` bigint(20)      COMMENT '更新人id',
+PRIMARY KEY  (`id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='监测预警记录';
+-- ----------------------------
+-- 监测预警记录详细记录表
+-- ----------------------------
+DROP TABLE IF EXISTS `mortals_xhx_monitor_alarm_record`;
+CREATE TABLE mortals_xhx_monitor_alarm_record(
+    `id` bigint(20) NOT NULL  AUTO_INCREMENT   COMMENT '主键ID，主键，自增长',
+    `alarmId` bigint(20)      COMMENT '告警Id',
+    `reservationService` varchar(50)      COMMENT '预约业务',
+    `reservationNumber` varchar(50)      COMMENT '预约编号',
+    `monitorTime` datetime      COMMENT '监测时间',
+    `monitorDeviceId` bigint(20)      COMMENT '监测设备',
+    `monitorDevice` varchar(255)      COMMENT '监测设备名称',
+    `checkInMethod` tinyint(1)    DEFAULT '0'  COMMENT '签到方式(0.自动签到，1.手动签到)',
+    `monitorCertificate` varchar(255)      COMMENT '监测凭证',
+    `picUri` varchar(255)      COMMENT '相对图片pic',
+    `serverIndexCode` varchar(255)      COMMENT '图片资源唯一标识',
+    `createTime` datetime      COMMENT '创建时间',
+    `createUserId` bigint(20)      COMMENT '创建人id',
+    `updateTime` datetime      COMMENT '更新时间',
+    `updateUserId` bigint(20)      COMMENT '更新人id',
+PRIMARY KEY  (`id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='监测预警记录详细记录';
+-- ----------------------------
+-- 用户消息表
+-- ----------------------------
+DROP TABLE IF EXISTS `mortals_xhx_notice`;
+CREATE TABLE mortals_xhx_notice(
+    `id` bigint(20) NOT NULL  AUTO_INCREMENT   COMMENT '主键ID',
+    `userId` bigint(20)      COMMENT '接收消息的用户的唯一标识符',
+    `title` varchar(255) NOT NULL     COMMENT '消息的标题',
+    `content` varchar(1024) NOT NULL     COMMENT '消息的内容',
+    `read` tinyint(2) NOT NULL   DEFAULT '0'  COMMENT '是否已读 (0.否,1.是)',
+    `priority` int(4) NOT NULL   DEFAULT '0'  COMMENT '消息的优先级，越高表示越紧急，不为空',
+    `expireTime` datetime      COMMENT '消息的过期时间，超过此时间则自动标记为已读',
+    `sourceType` varchar(64) NOT NULL     COMMENT '消息的来源类型，例如“系统”、“好友”等，可以为空',
+    `createTime` datetime      COMMENT '创建时间',
+    `createUserId` bigint(20)      COMMENT '创建人ID',
+    `updateTime` datetime      COMMENT '更新时间',
+    `updateUserId` bigint(20)      COMMENT '更新人ID',
+PRIMARY KEY  (`id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='用户消息';

doc/api.md

@@ -212,6 +212,734 @@ Content-Type: multipart/form-data
 
 ```
 
+## 监测预警记录
+
+### 查询监测预警记录列表
+
+**请求URL:** monitor/alarm/list
+
+**请求方式:** POST
+
+**内容类型:** application/json;charset=utf-8
+
+**简要描述:** 查询监测预警记录
+
+**请求参数:**
+
+参数名称|类型|必填|描述
+:---|:---|:---|:------
+page|Integer|否|当前页
+size|Integer|否|每页条数，值为-1，查询所有记录
+
+**请求样例:**
+```
+  {
+        "page":1,
+        "size":10
+  }
+
+```
+**响应参数:**
+
+参数名称|参数类型|描述
+:---|:---|:------
+code|Integer|结果码（-1.失败，1.成功）
+msg|String|消息
+data|object|数据对象
+ per_page|Integer|每页条数
+ total|Integer|总条数
+ last_page|Integer|总页数
+ current_page|Integer|当前页
+ data|array|结果集列表|数组
+  id|Long|主键ID，主键，自增长
+  siteId|Long|站点Id
+  siteName|String|站点名称
+  personId|Long|人员id
+  name|String|姓名
+  contact|String|联系方式
+  idNumber|String|身份证号码
+  identifyNum|Integer|识别频次
+  lastIdentifyTime|Date|最后识别时间
+  year|Integer|年
+  month|Integer|月
+  day|Integer|日
+  createTime|Date|创建时间
+  createUserId|Long|创建人id
+  updateTime|Date|更新时间
+  updateUserId|Long|更新人id
+dict|object|字典对象
+
+**响应消息样例:**
+```
+{
+    "code":1,
+    "data":{
+    }
+}
+```
+
+### 查看监测预警记录
+
+**请求URL:** monitor/alarm/info
+
+**请求方式:** GET
+
+**内容类型:** application/json;charset=utf-8
+
+**简要描述:** 查看监测预警记录，返回实例详细信息
+
+**请求参数:**
+
+参数名称|类型|必填|描述
+:---|:---|:---|:------
+id|Long|是|ID
+
+**请求样例:**
+```
+    http://localhost/monitor/alarm/info?id=549
+```
+**响应参数:**
+
+参数名称 |参数类型|描述
+:---|:---|:-------
+code|Integer|结果码（-1.失败，1.成功）
+msg|String|消息
+data|object|数据对象
+ id|Long|主键ID，主键，自增长
+ siteId|Long|站点Id
+ siteName|String|站点名称
+ personId|Long|人员id
+ name|String|姓名
+ contact|String|联系方式
+ idNumber|String|身份证号码
+ identifyNum|Integer|识别频次
+ lastIdentifyTime|Date|最后识别时间
+ year|Integer|年
+ month|Integer|月
+ day|Integer|日
+ createTime|Date|创建时间
+ createUserId|Long|创建人id
+ updateTime|Date|更新时间
+ updateUserId|Long|更新人id
+dict|object|字典对象
+
+**响应消息样例:**
+```
+{
+    "code": 1,
+    "data": {
+            "id":5014,
+            "siteId":9732,
+            "siteName":"l3y0h6",
+            "personId":8708,
+            "name":"4z75s0",
+            "contact":"673v6q",
+            "idNumber":"y8fqqz",
+            "identifyNum":4361,
+            "lastIdentifyTime":"2023-04-15",
+            "year":9273,
+            "month":1132,
+            "day":9175,
+            "createTime":"2023-04-15",
+            "createUserId":5906,
+            "updateTime":"2023-04-15",
+            "updateUserId":1152
+        }
+}
+```
+
+### 保存更新监测预警记录
+
+**请求URL:** monitor/alarm/save
+
+**请求方式:** POST
+
+**内容类型:** application/json;charset=utf-8
+
+**简要描述:** 保存或更新监测预警记录：id为空时为新增保存，否则为更新提交
+
+**请求参数:**
+
+参数名称|类型|必填|描述
+:---|:---|:---|:-------
+siteId|Long|否|站点Id
+siteName|String|否|站点名称
+personId|Long|是|人员id
+name|String|否|姓名
+contact|String|否|联系方式
+idNumber|String|是|身份证号码
+identifyNum|Integer|否|识别频次
+lastIdentifyTime|Date|否|最后识别时间
+year|Integer|是|年
+month|Integer|是|月
+day|Integer|是|日
+
+**请求样例:**
+```
+{
+    "siteId":2659,
+    "siteName":"q14jxb",
+    "personId":9673,
+    "name":"25neg3",
+    "contact":"r22oup",
+    "idNumber":"pgndr1",
+    "identifyNum":9027,
+    "lastIdentifyTime":"2023-04-15",
+    "year":7178,
+    "month":5934,
+    "day":3996,
+}
+
+```
+**响应参数:**
+
+参数名称 |参数类型|描述
+:---|:---|:------
+code|Integer|结果码（-1.失败，1.成功）
+msg|String|消息
+data|object|数据对象
+ id|Long|保存后主键id
+ entity|object|保存更新实体
+  id|Long|主键ID，主键，自增长
+  siteId|Long|站点Id
+  siteName|String|站点名称
+  personId|Long|人员id
+  name|String|姓名
+  contact|String|联系方式
+  idNumber|String|身份证号码
+  identifyNum|Integer|识别频次
+  lastIdentifyTime|Date|最后识别时间
+  year|Integer|年
+  month|Integer|月
+  day|Integer|日
+  createTime|Date|创建时间
+  createUserId|Long|创建人id
+  updateTime|Date|更新时间
+  updateUserId|Long|更新人id
+
+**响应消息样例:**
+```
+{
+    "msg":"新增模块成功",
+    "code":1,
+    "data":{}
+    }
+}
+
+```
+
+### 删除监测预警记录
+
+**请求URL:** monitor/alarm/delete
+
+**请求方式:** GET
+
+**内容类型:** application/json;charset=utf-8
+
+**简要描述:** 删除监测预警记录
+
+**请求参数:**
+
+参数名称|类型|必填|描述
+:---|:---|:---|:------
+id|String|是|数组
+
+**请求样例:**
+```
+    http://localhost:8080/monitor/alarm/delete?id=1&id=2'
+```
+**响应参数:**
+
+参数名称 |参数类型|备注|其它
+---|---|---|---
+code|Integer|结果码（-1.失败，1.成功）|-
+msg|String|消息|-
+
+**响应消息样例:**
+```
+{
+    "code":1,
+	"msg":"成功"
+}
+
+```
+## 监测预警记录详细记录
+
+### 查询监测预警记录详细记录列表
+
+**请求URL:** monitor/alarm/record/list
+
+**请求方式:** POST
+
+**内容类型:** application/json;charset=utf-8
+
+**简要描述:** 查询监测预警记录详细记录
+
+**请求参数:**
+
+参数名称|类型|必填|描述
+:---|:---|:---|:------
+page|Integer|否|当前页
+size|Integer|否|每页条数，值为-1，查询所有记录
+
+**请求样例:**
+```
+  {
+        "page":1,
+        "size":10
+  }
+
+```
+**响应参数:**
+
+参数名称|参数类型|描述
+:---|:---|:------
+code|Integer|结果码（-1.失败，1.成功）
+msg|String|消息
+data|object|数据对象
+ per_page|Integer|每页条数
+ total|Integer|总条数
+ last_page|Integer|总页数
+ current_page|Integer|当前页
+ data|array|结果集列表|数组
+  id|Long|主键ID，主键，自增长
+  alarmId|Long|告警Id
+  reservationService|String|预约业务
+  reservationNumber|String|预约编号
+  monitorTime|Date|监测时间
+  monitorDeviceId|Long|监测设备
+  monitorDevice|String|监测设备名称
+  checkInMethod|Integer|签到方式(0.自动签到，1.手动签到)
+  monitorCertificate|String|监测凭证
+  picUri|String|相对图片pic
+  serverIndexCode|String|图片资源唯一标识
+  createTime|Date|创建时间
+  createUserId|Long|创建人id
+  updateTime|Date|更新时间
+  updateUserId|Long|更新人id
+dict|object|字典对象
+ checkInMethod|object|字典属性对象，详见附录
+
+**响应消息样例:**
+```
+{
+    "code":1,
+    "data":{
+    }
+}
+```
+
+### 查看监测预警记录详细记录
+
+**请求URL:** monitor/alarm/record/info
+
+**请求方式:** GET
+
+**内容类型:** application/json;charset=utf-8
+
+**简要描述:** 查看监测预警记录详细记录，返回实例详细信息
+
+**请求参数:**
+
+参数名称|类型|必填|描述
+:---|:---|:---|:------
+id|Long|是|ID
+
+**请求样例:**
+```
+    http://localhost/monitor/alarm/record/info?id=549
+```
+**响应参数:**
+
+参数名称 |参数类型|描述
+:---|:---|:-------
+code|Integer|结果码（-1.失败，1.成功）
+msg|String|消息
+data|object|数据对象
+ id|Long|主键ID，主键，自增长
+ alarmId|Long|告警Id
+ reservationService|String|预约业务
+ reservationNumber|String|预约编号
+ monitorTime|Date|监测时间
+ monitorDeviceId|Long|监测设备
+ monitorDevice|String|监测设备名称
+ checkInMethod|Integer|签到方式(0.自动签到，1.手动签到)
+ monitorCertificate|String|监测凭证
+ picUri|String|相对图片pic
+ serverIndexCode|String|图片资源唯一标识
+ createTime|Date|创建时间
+ createUserId|Long|创建人id
+ updateTime|Date|更新时间
+ updateUserId|Long|更新人id
+dict|object|字典对象
+ checkInMethod|object|字典属性对象，详见附录
+
+**响应消息样例:**
+```
+{
+    "code": 1,
+    "data": {
+            "id":2891,
+            "alarmId":2345,
+            "reservationService":"0h93v8",
+            "reservationNumber":"bfmtx2",
+            "monitorTime":"2023-04-15",
+            "monitorDeviceId":2528,
+            "monitorDevice":"j13kix",
+            "checkInMethod":992,
+            "monitorCertificate":"khocf9",
+            "picUri":"8tty8a",
+            "serverIndexCode":"xkt5da",
+            "createTime":"2023-04-15",
+            "createUserId":6814,
+            "updateTime":"2023-04-15",
+            "updateUserId":5698
+        }
+}
+```
+
+### 保存更新监测预警记录详细记录
+
+**请求URL:** monitor/alarm/record/save
+
+**请求方式:** POST
+
+**内容类型:** application/json;charset=utf-8
+
+**简要描述:** 保存或更新监测预警记录详细记录：id为空时为新增保存，否则为更新提交
+
+**请求参数:**
+
+参数名称|类型|必填|描述
+:---|:---|:---|:-------
+alarmId|Long|否|告警Id
+reservationService|String|否|预约业务
+reservationNumber|String|否|预约编号
+monitorTime|Date|否|监测时间
+monitorDeviceId|Long|否|监测设备
+monitorDevice|String|否|监测设备名称
+checkInMethod|Integer|否|签到方式(0.自动签到，1.手动签到)
+monitorCertificate|String|否|监测凭证
+picUri|String|否|相对图片pic
+serverIndexCode|String|否|图片资源唯一标识
+
+**请求样例:**
+```
+{
+    "alarmId":4516,
+    "reservationService":"siacca",
+    "reservationNumber":"70j934",
+    "monitorTime":"2023-04-15",
+    "monitorDeviceId":7560,
+    "monitorDevice":"uf1pw0",
+    "checkInMethod":5264,
+    "monitorCertificate":"4p6ldb",
+    "picUri":"elawqz",
+    "serverIndexCode":"hqtuyl",
+}
+
+```
+**响应参数:**
+
+参数名称 |参数类型|描述
+:---|:---|:------
+code|Integer|结果码（-1.失败，1.成功）
+msg|String|消息
+data|object|数据对象
+ id|Long|保存后主键id
+ entity|object|保存更新实体
+  id|Long|主键ID，主键，自增长
+  alarmId|Long|告警Id
+  reservationService|String|预约业务
+  reservationNumber|String|预约编号
+  monitorTime|Date|监测时间
+  monitorDeviceId|Long|监测设备
+  monitorDevice|String|监测设备名称
+  checkInMethod|Integer|签到方式(0.自动签到，1.手动签到)
+  monitorCertificate|String|监测凭证
+  picUri|String|相对图片pic
+  serverIndexCode|String|图片资源唯一标识
+  createTime|Date|创建时间
+  createUserId|Long|创建人id
+  updateTime|Date|更新时间
+  updateUserId|Long|更新人id
+
+**响应消息样例:**
+```
+{
+    "msg":"新增模块成功",
+    "code":1,
+    "data":{}
+    }
+}
+
+```
+
+### 删除监测预警记录详细记录
+
+**请求URL:** monitor/alarm/record/delete
+
+**请求方式:** GET
+
+**内容类型:** application/json;charset=utf-8
+
+**简要描述:** 删除监测预警记录详细记录
+
+**请求参数:**
+
+参数名称|类型|必填|描述
+:---|:---|:---|:------
+id|String|是|数组
+
+**请求样例:**
+```
+    http://localhost:8080/monitor/alarm/record/delete?id=1&id=2'
+```
+**响应参数:**
+
+参数名称 |参数类型|备注|其它
+---|---|---|---
+code|Integer|结果码（-1.失败，1.成功）|-
+msg|String|消息|-
+
+**响应消息样例:**
+```
+{
+    "code":1,
+	"msg":"成功"
+}
+
+```
+## 用户消息
+
+### 查询用户消息列表
+
+**请求URL:** notice/list
+
+**请求方式:** POST
+
+**内容类型:** application/json;charset=utf-8
+
+**简要描述:** 查询用户消息
+
+**请求参数:**
+
+参数名称|类型|必填|描述
+:---|:---|:---|:------
+page|Integer|否|当前页
+size|Integer|否|每页条数，值为-1，查询所有记录
+
+**请求样例:**
+```
+  {
+        "page":1,
+        "size":10
+  }
+
+```
+**响应参数:**
+
+参数名称|参数类型|描述
+:---|:---|:------
+code|Integer|结果码（-1.失败，1.成功）
+msg|String|消息
+data|object|数据对象
+ per_page|Integer|每页条数
+ total|Integer|总条数
+ last_page|Integer|总页数
+ current_page|Integer|当前页
+ data|array|结果集列表|数组
+  id|Long|主键ID
+  userId|Long|接收消息的用户的唯一标识符
+  title|String|消息的标题
+  content|String|消息的内容
+  read|Integer|是否已读 (0.否,1.是)
+  priority|Integer|消息的优先级，越高表示越紧急，不为空
+  expireTime|Date|消息的过期时间，超过此时间则自动标记为已读
+  sourceType|String|消息的来源类型，例如“系统”、“好友”等，可以为空
+  createTime|Date|创建时间
+  createUserId|Long|创建人ID
+  updateTime|Date|更新时间
+  updateUserId|Long|更新人ID
+dict|object|字典对象
+ read|object|字典属性对象，详见附录
+
+**响应消息样例:**
+```
+{
+    "code":1,
+    "data":{
+    }
+}
+```
+
+### 查看用户消息
+
+**请求URL:** notice/info
+
+**请求方式:** GET
+
+**内容类型:** application/json;charset=utf-8
+
+**简要描述:** 查看用户消息，返回实例详细信息
+
+**请求参数:**
+
+参数名称|类型|必填|描述
+:---|:---|:---|:------
+id|Long|是|ID
+
+**请求样例:**
+```
+    http://localhost/notice/info?id=549
+```
+**响应参数:**
+
+参数名称 |参数类型|描述
+:---|:---|:-------
+code|Integer|结果码（-1.失败，1.成功）
+msg|String|消息
+data|object|数据对象
+ id|Long|主键ID
+ userId|Long|接收消息的用户的唯一标识符
+ title|String|消息的标题
+ content|String|消息的内容
+ read|Integer|是否已读 (0.否,1.是)
+ priority|Integer|消息的优先级，越高表示越紧急，不为空
+ expireTime|Date|消息的过期时间，超过此时间则自动标记为已读
+ sourceType|String|消息的来源类型，例如“系统”、“好友”等，可以为空
+ createTime|Date|创建时间
+ createUserId|Long|创建人ID
+ updateTime|Date|更新时间
+ updateUserId|Long|更新人ID
+dict|object|字典对象
+ read|object|字典属性对象，详见附录
+
+**响应消息样例:**
+```
+{
+    "code": 1,
+    "data": {
+            "id":6140,
+            "userId":7474,
+            "title":"i6lsun",
+            "content":"9jtr9u",
+            "read":3252,
+            "priority":5976,
+            "expireTime":"2023-04-15",
+            "sourceType":"kq6cx2",
+            "createTime":"2023-04-15",
+            "createUserId":84,
+            "updateTime":"2023-04-15",
+            "updateUserId":4013
+        }
+}
+```
+
+### 保存更新用户消息
+
+**请求URL:** notice/save
+
+**请求方式:** POST
+
+**内容类型:** application/json;charset=utf-8
+
+**简要描述:** 保存或更新用户消息：id为空时为新增保存，否则为更新提交
+
+**请求参数:**
+
+参数名称|类型|必填|描述
+:---|:---|:---|:-------
+userId|Long|否|接收消息的用户的唯一标识符
+title|String|是|消息的标题
+content|String|是|消息的内容
+read|Integer|是|是否已读 (0.否,1.是)
+priority|Integer|是|消息的优先级，越高表示越紧急，不为空
+expireTime|Date|否|消息的过期时间，超过此时间则自动标记为已读
+sourceType|String|是|消息的来源类型，例如“系统”、“好友”等，可以为空
+
+**请求样例:**
+```
+{
+    "userId":8741,
+    "title":"8ilz55",
+    "content":"04ud20",
+    "read":4173,
+    "priority":3717,
+    "expireTime":"2023-04-15",
+    "sourceType":"xheon0",
+}
+
+```
+**响应参数:**
+
+参数名称 |参数类型|描述
+:---|:---|:------
+code|Integer|结果码（-1.失败，1.成功）
+msg|String|消息
+data|object|数据对象
+ id|Long|保存后主键id
+ entity|object|保存更新实体
+  id|Long|主键ID
+  userId|Long|接收消息的用户的唯一标识符
+  title|String|消息的标题
+  content|String|消息的内容
+  read|Integer|是否已读 (0.否,1.是)
+  priority|Integer|消息的优先级，越高表示越紧急，不为空
+  expireTime|Date|消息的过期时间，超过此时间则自动标记为已读
+  sourceType|String|消息的来源类型，例如“系统”、“好友”等，可以为空
+  createTime|Date|创建时间
+  createUserId|Long|创建人ID
+  updateTime|Date|更新时间
+  updateUserId|Long|更新人ID
+
+**响应消息样例:**
+```
+{
+    "msg":"新增模块成功",
+    "code":1,
+    "data":{}
+    }
+}
+
+```
+
+### 删除用户消息
+
+**请求URL:** notice/delete
+
+**请求方式:** GET
+
+**内容类型:** application/json;charset=utf-8
+
+**简要描述:** 删除用户消息
+
+**请求参数:**
+
+参数名称|类型|必填|描述
+:---|:---|:---|:------
+id|String|是|数组
+
+**请求样例:**
+```
+    http://localhost:8080/notice/delete?id=1&id=2'
+```
+**响应参数:**
+
+参数名称 |参数类型|备注|其它
+---|---|---|---
+code|Integer|结果码（-1.失败，1.成功）|-
+msg|String|消息|-
+
+**响应消息样例:**
+```
+{
+    "code":1,
+	"msg":"成功"
+}
+
+```
+
 ## 人员发现记录
 
 ### 查询人员发现记录列表

refined-manager-ui/admin/src/router.js

@@ -54,6 +54,9 @@ const router = new Router({
                 ...restBuilder('care/constraint/track', 'care/constraint/track'), //主动关怀服务追踪
                 ...restBuilder('person', 'person'), //注册人员
                 ...restBuilder('device', 'device'), //设备业务
+                ...restBuilder('notice', 'notice'), //消息
+                ...restBuilder('monitor/alarm', 'monitor/alarm'), //监控预警
+                ...restBuilder('monitor/alarm/record', 'monitor/alarm/record'), //监控预警记录
 
 
                 //以下为基础路由配置

refined-manager-ui/admin/src/views/care/constraint/list.vue

-<template>
-    <div class="page">
-        <LayoutTable :data="tableData" :config="tableConfig">
-                    </LayoutTable>
-      <track-drawer-show ref="trackDrawerShow"  />
-
-        <dialog-show ref="dialogform" @ok="getData" />
-    </div>
-</template>
-
-<script>
-    /** 表单弹出框模式需引入 */
-    import dialogShow from "./dialogshow";
-    import trackDrawerShow from "./trackDrawerShow";
-    import table from "@/assets/mixins/table";
-    export default {
-        name: "CareConstraintList",
-        components: {
-            dialogShow,trackDrawerShow
-},
-        mixins: [table],
-        created() {
-        },
-        methods: {
-            renderTable(tableData) {
-                return (
-                    <el-table stripe data={tableData} class="total-table">
-                    {this.columnSet.map((item) => this.renderTableColumn(item))}
-                    </el-table>
-                );
-            },
-            renderTableColumn(options) {
-                return (
-                    <el-table-column
-                        prop={options.prop}
-                        label={options.label}
-                        width={options.width}
-                    >
-                    </el-table-column>
-                 );
-            },
-            /** 重写新增方法 */
-            toAdd(row) {
-                this.$refs.dialogform.add(row);
-            },
-            /** 重写编辑方法 */
-            toEdit(row) {
-                this.$refs.dialogform.edit(row);
-            },
-            /** 重写查看方法 */
-            toView(row) {
-                this.$refs.dialogform.view(row);
-            },
-
-          handleTrack(row) {
-            this.$refs.trackDrawerShow.view(row);
-          },
-
-          cancelTrack(row) {
-            let _this = this
-            this.$confirm('取消跟踪后，系统将从0开始计算服务频次，是否确认？', "系统服务", {
-              confirmButtonText: "确定",
-              cancelButtonText: "取消",
-              type: "warning"
-            }).then(function () {
-              //todo
-              _this.$post("/care/constraint/save", {
-                id: row.id,
-                serviceFrequency: 0,
-                track: 0,
-              })
-                  .then((res) => {
-                    if (res.code == 1) {
-                      _this.$message.success("取消追踪成功！");
-                      _this.getData();
-                    }
-                  })
-                  .catch((error) => {
-                    _this.$message.error(error.message);
-                  });
-
-            }).then(response => {
-
-            })
-
-          }
-
-        },
-        data() {
-            return {
-                /** 子表列元素 */
-                columnSet:[
-                    {prop:"careId",label:"主动关怀约束Id",width:100},
-                    {prop:"feedbackId",label:"反馈人ID",width:100},
-                    {prop:"feedbackName",label:"反馈人姓名",width:100},
-                    {prop:"feedback",label:"反馈内容",width:100},
-                    {prop:"feedbackTime",label:"跟踪时间",width:100},
-                    {prop:"createMethod",label:"创建方式",width:100},
-                ],
-                config: {
-                    search: [
-                    ],
-                    columns: [
-                        {type: "selection", width: 60},
-                        {type: "index",label: "序号",width: 50},
-
-                        {label: "姓名", prop: "name"},
-
-                        {label: "联系方式", prop: "contact"},
-
-                        {label: "身份证号码", prop: "idCard"},
-
-                        {label: "服务频次", prop: "serviceFrequency", formatter: this.formatter},
-
-                        {label: "跟踪时间", prop: "trackingTime", formatter: this.formatterDate},
-
-                        {label: "创建方式", prop: "createWay",formatter: this.formatter},
-
-                        {label: "操作人员", prop: "operator"},
-
-                        {label: "是否追踪 ", prop: "track",formatter: this.formatter},
-
-                        {
-                            label: "操作",
-                            width: 320,
-                            formatter: row => {
-                                return (
-                                    <div>
-                                      <table-buttons noAdd noView row={row} onEdit={this.toEdit} onView={this.toView} onDel={this.toDel} />
-                                      <span> </span>
-
-                                          <el-button
-                                              size="mini"
-                                              type="text"
-                                              icon="el-icon-open"
-                                              onClick={() => {
-                                                this.handleTrack(row);
-                                              }}
-                                          >
-                                            跟踪反馈
-                                          </el-button>
-                                      <span> </span>
-                                          <el-button
-                                              size="mini"
-                                              type="text"
-                                              icon="el-icon-open"
-                                              onClick={() => {
-                                                this.cancelTrack(row);
-                                              }}
-                                          >
-                                            取消跟踪
-                                          </el-button>
-                                    </div>);
-                            }
-                        }
-                    ]
-                }
-            };
-        }
-    };
-</script>

refined-manager-ui/admin/src/views/monitor/alarm/dialogshow.vue

+<template>
+    <!-- 弹出框表单 -->
+    <el-dialog :title="title" :visible.sync="open" width="90%" append-to-body>
+        <el-form ref="form" :model="form" :rules="rules" label-width="120px">
+            <el-row>
+                                            <Field label="站点Id" prop="siteId" v-model="form.siteId" placeholder="请输入站点Id"/>
+                            <Field label="站点名称" prop="siteName" v-model="form.siteName" type="textarea" placeholder="请输入站点名称"/>
+                            <Field label="人员id" prop="personId" v-model="form.personId" placeholder="请输入人员id"/>
+                            <Field label="姓名" prop="name" v-model="form.name" type="textarea" placeholder="请输入姓名"/>
+                            <Field label="联系方式" prop="contact" v-model="form.contact" type="textarea" placeholder="请输入联系方式"/>
+                            <Field label="身份证号码" prop="idNumber" v-model="form.idNumber" type="textarea" placeholder="请输入身份证号码"/>
+                            <Field label="识别频次" prop="identifyNum" v-model="form.identifyNum" placeholder="请输入识别频次"/>
+                            <Field label="最后识别时间" prop="lastIdentifyTime" v-model="form.lastIdentifyTime" type="date" />
+                            <Field label="年" prop="year" v-model="form.year" placeholder="请输入年"/>
+                            <Field label="月" prop="month" v-model="form.month" placeholder="请输入月"/>
+                            <Field label="日" prop="day" v-model="form.day" 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:[
+                ],
+                // 表单校验
+                rules: {
+                    idNumber: [
+                        {required: true,message: "请输入身份证号码", trigger: "blur" },
+                        {max: 255,message: "最多只能录入255个字符",trigger: "blur",},
+                    ],
+                    year: [
+                        {required: true,message: "请输入年", trigger: "blur" },
+                    ],
+                    month: [
+                        {required: true,message: "请输入月", trigger: "blur" },
+                    ],
+                    day: [
+                        {required: true,message: "请输入日", trigger: "blur" },
+                    ],
+                }
+            };
+        },
+
+        methods: {
+            /** 编辑 */
+            edit(row) {
+                this.reset()
+                this.query = { id: row.id };
+                this.urls.currUrl ="monitor/alarm/edit";
+                this.getData();
+                this.pageInfo.type="edit"
+                this.title = "修改监测预警记录";
+            },
+            /** 新增 */
+            add(row) {
+                this.reset()
+                this.urls.currUrl = "monitor/alarm/add";
+                this.getData();
+                this.pageInfo.type="add"
+                this.title = "新增监测预警记录";
+            },
+            /** 查看*/
+            view(row) {
+                this.reset()
+                this.query = { id: row.id };
+                this.urls.currUrl ="monitor/alarm/view";
+                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");
+            },
+
+            // 表单重置
+            reset() {
+                this.form = {
+                    siteId : null,
+                    siteName : "",
+                    personId : null,
+                    name : "",
+                    contact : "",
+                    idNumber : "",
+                    identifyNum : 0,
+                    lastIdentifyTime : null,
+                    year : null,
+                    month : null,
+                    day : null,
+                };
+                this.resetForm("form");
+            },
+            resetForm(refName) {
+                if (this.$refs[refName]) {
+                    this.$refs[refName].resetFields();
+                }
+            },
+        },
+    };
+</script>

refined-manager-ui/admin/src/views/monitor/alarm/list.vue

+<template>
+    <div class="page">
+        <LayoutTable :data="tableData" :config="tableConfig">
+                    </LayoutTable>
+
+
+        <dialog-show ref="dialogform" @ok="getData" />
+    </div>
+</template>
+
+<script>
+    /** 表单弹出框模式需引入 */
+    import dialogShow from "./dialogshow";
+    import table from "@/assets/mixins/table";
+    export default {
+        name: "MonitorAlarmList",
+        components: {
+            dialogShow
+},
+        mixins: [table],
+        created() {
+        },
+        methods: {
+            /** 重写新增方法 */
+            toAdd(row) {
+                this.$refs.dialogform.add(row);
+            },
+            /** 重写编辑方法 */
+            toEdit(row) {
+                this.$refs.dialogform.edit(row);
+            },
+            /** 重写查看方法 */
+            toView(row) {
+                this.$refs.dialogform.view(row);
+            },
+
+        },
+        data() {
+            return {
+                config: {
+                    search: [
+                    ],
+                    columns: [
+                        {type: "selection", width: 60},
+                        {type: "index",label: "序号",width: 50},
+
+                        {label: "站点Id", prop: "siteId", formatter: this.formatter},
+
+                        {label: "站点名称", prop: "siteName"},
+
+                        {label: "姓名", prop: "name"},
+
+                        {label: "联系方式", prop: "contact"},
+
+                        {label: "身份证号码", prop: "idNumber"},
+
+                        {label: "识别频次", prop: "identifyNum",formatter: this.formatter},
+                        {
+                            label: "操作",
+                            width: 240,
+                            formatter: row => {
+                                return (
+                                    <table-buttons noAdd row={row} onEdit={this.toEdit} onView={this.toView} onDel={this.toDel} />
+                            );
+                            }
+                        }
+                    ]
+                }
+            };
+        }
+    };
+</script>
\ No newline at end of file

refined-manager-ui/admin/src/views/monitor/alarm/record/dialogshow.vue

+<template>
+    <!-- 弹出框表单 -->
+    <el-dialog :title="title" :visible.sync="open" width="90%" append-to-body>
+        <el-form ref="form" :model="form" :rules="rules" label-width="120px">
+            <el-row>
+                                            <Field label="告警Id" prop="alarmId" v-model="form.alarmId" placeholder="请输入告警Id"/>
+                            <Field label="预约业务" prop="reservationService" v-model="form.reservationService" placeholder="请输入预约业务"/>
+                            <Field label="预约编号" prop="reservationNumber" v-model="form.reservationNumber" placeholder="请输入预约编号"/>
+                            <Field label="监测时间" prop="monitorTime" v-model="form.monitorTime" type="date" />
+                            <Field label="监测设备" prop="monitorDeviceId" v-model="form.monitorDeviceId" placeholder="请输入监测设备"/>
+                            <Field label="监测设备名称" prop="monitorDevice" v-model="form.monitorDevice" type="textarea" placeholder="请输入监测设备名称"/>
+                            <Field label="签到方式" prop="checkInMethod" v-model="form.checkInMethod" type="select" :enumData="dict.checkInMethod" placeholder="请选择签到方式"/>
+                            <Field label="监测凭证" prop="monitorCertificate" v-model="form.monitorCertificate" type="textarea" placeholder="请输入监测凭证"/>
+                            <Field label="相对图片pic" prop="picUri" v-model="form.picUri" type="textarea" placeholder="请输入相对图片pic"/>
+                            <Field label="图片资源唯一标识" prop="serverIndexCode" v-model="form.serverIndexCode" type="textarea" 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:[
+                    "checkInMethod",
+                ],
+                // 表单校验
+                rules: {
+                }
+            };
+        },
+
+        methods: {
+            /** 编辑 */
+            edit(row) {
+                this.reset()
+                this.query = { id: row.id };
+                this.urls.currUrl ="monitor/alarm/record/edit";
+                this.getData();
+                this.pageInfo.type="edit"
+                this.title = "修改监测预警记录详细记录";
+            },
+            /** 新增 */
+            add(row) {
+                this.reset()
+                this.urls.currUrl = "monitor/alarm/record/add";
+                this.getData();
+                this.pageInfo.type="add"
+                this.title = "新增监测预警记录详细记录";
+            },
+            /** 查看*/
+            view(row) {
+                this.reset()
+                this.query = { id: row.id };
+                this.urls.currUrl ="monitor/alarm/record/view";
+                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");
+            },
+
+            // 表单重置
+            reset() {
+                this.form = {
+                    alarmId : null,
+                    reservationService : "",
+                    reservationNumber : "",
+                    monitorTime : null,
+                    monitorDeviceId : null,
+                    monitorDevice : "",
+                    checkInMethod : 0,
+                    monitorCertificate : "",
+                    picUri : "",
+                    serverIndexCode : "",
+                };
+                this.resetForm("form");
+            },
+            resetForm(refName) {
+                if (this.$refs[refName]) {
+                    this.$refs[refName].resetFields();
+                }
+            },
+        },
+    };
+</script>

refined-manager-ui/admin/src/views/monitor/alarm/record/list.vue

+<template>
+    <div class="page">
+        <LayoutTable :data="tableData" :config="tableConfig">
+                    </LayoutTable>
+
+
+        <dialog-show ref="dialogform" @ok="getData" />
+    </div>
+</template>
+
+<script>
+    /** 表单弹出框模式需引入 */
+    import dialogShow from "./dialogshow";
+    import table from "@/assets/mixins/table";
+    export default {
+        name: "MonitorAlarmRecordList",
+        components: {
+            dialogShow
+},
+        mixins: [table],
+        created() {
+        },
+        methods: {
+            /** 重写新增方法 */
+            toAdd(row) {
+                this.$refs.dialogform.add(row);
+            },
+            /** 重写编辑方法 */
+            toEdit(row) {
+                this.$refs.dialogform.edit(row);
+            },
+            /** 重写查看方法 */
+            toView(row) {
+                this.$refs.dialogform.view(row);
+            },
+
+        },
+        data() {
+            return {
+                config: {
+                    search: [
+                    ],
+                    columns: [
+                        {type: "selection", width: 60},
+                        {type: "index",label: "序号",width: 50},
+
+                        {label: "告警Id", prop: "alarmId", formatter: this.formatter},
+
+                        {label: "预约业务", prop: "reservationService"},
+
+                        {label: "预约编号", prop: "reservationNumber"},
+
+                        {label: "监测时间", prop: "monitorTime", formatter: this.formatterDate},
+
+                        {label: "监测设备名称", prop: "monitorDevice"},
+
+                        {label: "签到方式", prop: "checkInMethod",formatter: this.formatter},
+
+                        {label: "监测凭证", prop: "monitorCertificate"},
+                        {
+                            label: "操作",
+                            width: 240,
+                            formatter: row => {
+                                return (
+                                    <table-buttons noAdd row={row} onEdit={this.toEdit} onView={this.toView} onDel={this.toDel} />
+                            );
+                            }
+                        }
+                    ]
+                }
+            };
+        }
+    };
+</script>
\ No newline at end of file

refined-manager-ui/admin/src/views/monitor/alarm/record/view.vue

+<template>
+    <layout-view>
+        <el-descriptions  :title="title" :column="column" :size="size" :colon="false" border>
+            <template slot="title">
+                <i class="el-icon-tickets"></i>
+                基本详细信息
+            </template>
+            <template slot="extra">
+                <el-button type="primary" @click="$router.go(-1)" size="small">返回</el-button>
+            </template>
+                                    <el-descriptions-item label="告警Id" label-class-name="labelClass" content-class-name="contentClass">
+                            {{form.alarmId}}
+                        </el-descriptions-item>
+                        <el-descriptions-item label="预约业务" label-class-name="labelClass" content-class-name="contentClass">
+                            {{form.reservationService}}
+                        </el-descriptions-item>
+                        <el-descriptions-item label="预约编号" label-class-name="labelClass" content-class-name="contentClass">
+                            {{form.reservationNumber}}
+                        </el-descriptions-item>
+                        <el-descriptions-item label="监测时间" label-class-name="labelClass" content-class-name="contentClass">
+                            {{ util_formatterDate(form.monitorTime)}}
+                        </el-descriptions-item>
+                        <el-descriptions-item label="监测设备" label-class-name="labelClass" content-class-name="contentClass">
+                            {{form.monitorDeviceId}}
+                        </el-descriptions-item>
+                        <el-descriptions-item label="监测设备名称" label-class-name="labelClass" content-class-name="contentClass">
+                            {{form.monitorDevice}}
+                        </el-descriptions-item>
+                        <el-descriptions-item label="签到方式" label-class-name="labelClass" content-class-name="contentClass">
+                            {{ util_formatters("checkInMethod", form.checkInMethod) }}
+                        </el-descriptions-item>
+                        <el-descriptions-item label="监测凭证" label-class-name="labelClass" content-class-name="contentClass">
+                            {{form.monitorCertificate}}
+                        </el-descriptions-item>
+                        <el-descriptions-item label="相对图片pic" label-class-name="labelClass" content-class-name="contentClass">
+                            {{form.picUri}}
+                        </el-descriptions-item>
+                        <el-descriptions-item label="图片资源唯一标识" label-class-name="labelClass" content-class-name="contentClass">
+                            {{form.serverIndexCode}}
+                        </el-descriptions-item>
+        </el-descriptions>
+
+    </layout-view>
+</template>
+
+<script>
+    import view from "@/assets/mixins/view";
+    export default {
+        mixins: [view],
+        components: {
+        },
+        methods: {
+
+        },
+        data() {
+            return {
+                size:"small",
+                column:2,
+                toString:[
+                    "checkInMethod",
+                ],
+                toArrays: [
+
+                ],
+                toDate: [
+
+                ]
+            }
+        }
+    }
+</script>
+<style lang="less">
+    .labelClass{
+        width: 200px;
+    }
+    .el-descriptions__body{
+        margin-left: 5px;
+        margin-right: 5px;
+        color: #606266;
+        background-color: #FFF;
+    }
+    .contentClass{
+        width: 600px;
+    }
+</style>
\ No newline at end of file

refined-manager-ui/admin/src/views/monitor/alarm/view.vue

+<template>
+    <layout-view>
+        <el-descriptions  :title="title" :column="column" :size="size" :colon="false" border>
+            <template slot="title">
+                <i class="el-icon-tickets"></i>
+                基本详细信息
+            </template>
+            <template slot="extra">
+                <el-button type="primary" @click="$router.go(-1)" size="small">返回</el-button>
+            </template>
+                                    <el-descriptions-item label="站点Id" label-class-name="labelClass" content-class-name="contentClass">
+                            {{form.siteId}}
+                        </el-descriptions-item>
+                        <el-descriptions-item label="站点名称" label-class-name="labelClass" content-class-name="contentClass">
+                            {{form.siteName}}
+                        </el-descriptions-item>
+                        <el-descriptions-item label="人员id" label-class-name="labelClass" content-class-name="contentClass">
+                            {{form.personId}}
+                        </el-descriptions-item>
+                        <el-descriptions-item label="姓名" label-class-name="labelClass" content-class-name="contentClass">
+                            {{form.name}}
+                        </el-descriptions-item>
+                        <el-descriptions-item label="联系方式" label-class-name="labelClass" content-class-name="contentClass">
+                            {{form.contact}}
+                        </el-descriptions-item>
+                        <el-descriptions-item label="身份证号码" label-class-name="labelClass" content-class-name="contentClass">
+                            {{form.idNumber}}
+                        </el-descriptions-item>
+                        <el-descriptions-item label="识别频次" label-class-name="labelClass" content-class-name="contentClass">
+                            {{form.identifyNum}}
+                        </el-descriptions-item>
+                        <el-descriptions-item label="最后识别时间" label-class-name="labelClass" content-class-name="contentClass">
+                            {{ util_formatterDate(form.lastIdentifyTime)}}
+                        </el-descriptions-item>
+                        <el-descriptions-item label="年" label-class-name="labelClass" content-class-name="contentClass">
+                            {{form.year}}
+                        </el-descriptions-item>
+                        <el-descriptions-item label="月" label-class-name="labelClass" content-class-name="contentClass">
+                            {{form.month}}
+                        </el-descriptions-item>
+                        <el-descriptions-item label="日" label-class-name="labelClass" content-class-name="contentClass">
+                            {{form.day}}
+                        </el-descriptions-item>
+        </el-descriptions>
+
+    </layout-view>
+</template>
+
+<script>
+    import view from "@/assets/mixins/view";
+    export default {
+        mixins: [view],
+        components: {
+        },
+        methods: {
+
+        },
+        data() {
+            return {
+                size:"small",
+                column:2,
+                toString:[
+                ],
+                toArrays: [
+
+                ],
+                toDate: [
+
+                ]
+            }
+        }
+    }
+</script>
+<style lang="less">
+    .labelClass{
+        width: 200px;
+    }
+    .el-descriptions__body{
+        margin-left: 5px;
+        margin-right: 5px;
+        color: #606266;
+        background-color: #FFF;
+    }
+    .contentClass{
+        width: 600px;
+    }
+</style>
\ No newline at end of file

refined-manager-ui/admin/src/views/notice/dialogshow.vue

+<template>
+    <!-- 弹出框表单 -->
+    <el-dialog :title="title" :visible.sync="open" width="90%" append-to-body>
+        <el-form ref="form" :model="form" :rules="rules" label-width="120px">
+            <el-row>
+                                            <Field label="接收消息的用户的唯一标识符" prop="userId" v-model="form.userId" placeholder="请输入接收消息的用户的唯一标识符"/>
+                            <Field label="消息的标题" prop="title" v-model="form.title" type="textarea" placeholder="请输入消息的标题"/>
+                            <Field label="消息的内容"><editor v-model="form.content" :min-height="256"/></Field>
+                            <Field label="是否已读 " prop="read" v-model="form.read" type="radio" :enumData="dict.read" />
+                            <Field label="消息的优先级，越高表示越紧急，不为空" prop="priority" v-model="form.priority" placeholder="请输入消息的优先级，越高表示越紧急，不为空"/>
+                            <Field label="消息的过期时间，超过此时间则自动标记为已读" prop="expireTime" v-model="form.expireTime" type="date" />
+                            <Field label="消息的来源类型，例如“系统”、“好友”等，可以为空" prop="sourceType" v-model="form.sourceType" 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";
+    import Editor from '@/components/Editor';
+    export default {
+        mixins: [form],
+        components: {
+            dialogShow ,
+            Editor,
+        },
+        data() {
+            return {
+                // 遮罩层
+                loading: true,
+                // 弹出层标题
+                title: "用户消息",
+                // 是否显示弹出层
+                open: false,
+                toString:[
+                ],
+                // 表单校验
+                rules: {
+                    title: [
+                        {required: true,message: "请输入消息的标题", trigger: "blur" },
+                        {max: 255,message: "最多只能录入255个字符",trigger: "blur",},
+                    ],
+                    content: [
+                        {required: true,message: "请输入消息的内容", trigger: "blur" },
+                        {max: 1024,message: "最多只能录入1024个字符",trigger: "blur",},
+                    ],
+                    priority: [
+                        {required: true,message: "请输入消息的优先级，越高表示越紧急，不为空", trigger: "blur" },
+                    ],
+                    sourceType: [
+                        {required: true,message: "请输入消息的来源类型，例如“系统”、“好友”等，可以为空", trigger: "blur" },
+                        {max: 64,message: "最多只能录入64个字符",trigger: "blur",},
+                    ],
+                }
+            };
+        },
+
+        methods: {
+            /** 编辑 */
+            edit(row) {
+                this.reset()
+                this.query = { id: row.id };
+                this.urls.currUrl ="notice/edit";
+                this.getData();
+                this.pageInfo.type="edit"
+                this.title = "修改用户消息";
+            },
+            /** 新增 */
+            add(row) {
+                this.reset()
+                this.urls.currUrl = "notice/add";
+                this.getData();
+                this.pageInfo.type="add"
+                this.title = "新增用户消息";
+            },
+            /** 查看*/
+            view(row) {
+                this.reset()
+                this.query = { id: row.id };
+                this.urls.currUrl ="notice/view";
+                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");
+            },
+
+            // 表单重置
+            reset() {
+                this.form = {
+                    userId : null,
+                    title : "",
+                    content : "",
+                    read : null,
+                    priority : 0,
+                    expireTime : null,
+                    sourceType : "",
+                };
+                this.resetForm("form");
+            },
+            resetForm(refName) {
+                if (this.$refs[refName]) {
+                    this.$refs[refName].resetFields();
+                }
+            },
+        },
+    };
+</script>

refined-manager-ui/admin/src/views/notice/list.vue

+<template>
+    <div class="page">
+        <LayoutTable :data="tableData" :config="tableConfig">
+                    </LayoutTable>
+
+
+        <dialog-show ref="dialogform" @ok="getData" />
+    </div>
+</template>
+
+<script>
+    /** 表单弹出框模式需引入 */
+    import dialogShow from "./dialogshow";
+    import table from "@/assets/mixins/table";
+    export default {
+        name: "NoticeList",
+        components: {
+            dialogShow
+},
+        mixins: [table],
+        created() {
+        },
+        methods: {
+            /** 重写新增方法 */
+            toAdd(row) {
+                this.$refs.dialogform.add(row);
+            },
+            /** 重写编辑方法 */
+            toEdit(row) {
+                this.$refs.dialogform.edit(row);
+            },
+            /** 重写查看方法 */
+            toView(row) {
+                this.$refs.dialogform.view(row);
+            },
+
+        },
+        data() {
+            return {
+                config: {
+                    search: [
+                    ],
+                    columns: [
+                        {type: "selection", width: 60},
+                        {type: "index",label: "序号",width: 50},
+
+                        {label: "接收消息的用户的唯一标识符", prop: "userId", formatter: this.formatter},
+
+                        {label: "消息的标题", prop: "title"},
+
+                        {label: "消息的内容", prop: "content"},
+
+                        {label: "是否已读 ", prop: "read", formatter: this.formatterDate},
+
+                        {label: "消息的优先级，越高表示越紧急，不为空", prop: "priority",formatter: this.formatter},
+
+                        {label: "消息的来源类型，例如“系统”、“好友”等，可以为空", prop: "sourceType"},
+                        {
+                            label: "操作",
+                            width: 240,
+                            formatter: row => {
+                                return (
+                                    <table-buttons noAdd row={row} onEdit={this.toEdit} onView={this.toView} onDel={this.toDel} />
+                            );
+                            }
+                        }
+                    ]
+                }
+            };
+        }
+    };
+</script>
\ No newline at end of file

refined-manager-ui/admin/src/views/notice/view.vue

+<template>
+    <layout-view>
+        <el-descriptions  :title="title" :column="column" :size="size" :colon="false" border>
+            <template slot="title">
+                <i class="el-icon-tickets"></i>
+                基本详细信息
+            </template>
+            <template slot="extra">
+                <el-button type="primary" @click="$router.go(-1)" size="small">返回</el-button>
+            </template>
+                                    <el-descriptions-item label="接收消息的用户的唯一标识符" label-class-name="labelClass" content-class-name="contentClass">
+                            {{form.userId}}
+                        </el-descriptions-item>
+                        <el-descriptions-item label="消息的标题" label-class-name="labelClass" content-class-name="contentClass">
+                            {{form.title}}
+                        </el-descriptions-item>
+                        <el-descriptions-item label="消息的内容" label-class-name="labelClass" content-class-name="contentClass">
+                            <editor v-model="form.content" :min-height="256"/>
+                        </el-descriptions-item>
+                        <el-descriptions-item label="是否已读 " label-class-name="labelClass" content-class-name="contentClass">
+                            {{ util_formatters("read", form.read) }}
+                        </el-descriptions-item>
+                        <el-descriptions-item label="消息的优先级，越高表示越紧急，不为空" label-class-name="labelClass" content-class-name="contentClass">
+                            {{form.priority}}
+                        </el-descriptions-item>
+                        <el-descriptions-item label="消息的过期时间，超过此时间则自动标记为已读" label-class-name="labelClass" content-class-name="contentClass">
+                            {{ util_formatterDate(form.expireTime)}}
+                        </el-descriptions-item>
+                        <el-descriptions-item label="消息的来源类型，例如“系统”、“好友”等，可以为空" label-class-name="labelClass" content-class-name="contentClass">
+                            {{form.sourceType}}
+                        </el-descriptions-item>
+        </el-descriptions>
+
+    </layout-view>
+</template>
+
+<script>
+    import view from "@/assets/mixins/view";
+    import Editor from '@/components/Editor';
+    export default {
+        mixins: [view],
+        components: {
+            Editor,
+        },
+        methods: {
+
+        },
+        data() {
+            return {
+                size:"small",
+                column:2,
+                toString:[
+                ],
+                toArrays: [
+
+                ],
+                toDate: [
+
+                ]
+            }
+        }
+    }
+</script>
+<style lang="less">
+    .labelClass{
+        width: 200px;
+    }
+    .el-descriptions__body{
+        margin-left: 5px;
+        margin-right: 5px;
+        color: #606266;
+        background-color: #FFF;
+    }
+    .contentClass{
+        width: 600px;
+    }
+</style>
\ No newline at end of file

refined-manager/pom.xml

@@ -34,7 +34,6 @@
 				<profiles.sms.smsSendUrl>http://127.0.0.1:8089/api/index/index</profiles.sms.smsSendUrl>
 				<profiles.sms.apiId>k6BVS1PEbyzcJAE4</profiles.sms.apiId>
 				<profiles.sms.type>3</profiles.sms.type>
-
 				<profiles.hik.host>8.136.255.30:8001</profiles.hik.host>
 				<profiles.hik.appKey>25128371</profiles.hik.appKey>
 				<profiles.hik.appSecret>2m9RcPJOKq5j2QPQM4v5</profiles.hik.appSecret>

refined-manager/src/main/java/com/mortals/xhx/common/code/ReadEnum.java

+package com.mortals.xhx.common.code;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+/**
+* 是否已读 (0.否,1.是)枚举类
+*
+* @author zxfei
+*/
+public enum ReadEnum {
+;
+    private Date value;
+    private String desc;
+
+    ReadEnum(Date value, String desc) {
+        this.value = value;
+        this.desc = desc;
+    }
+
+    public Date getValue() {
+        return this.value;
+    }
+
+    public String getDesc() {
+        return this.desc;
+    }
+
+    public static ReadEnum getByValue(Date value) {
+        for (ReadEnum readEnum : ReadEnum.values()) {
+            if (readEnum.getValue() == value) {
+                return readEnum;
+            }
+        }
+        return null;
+    }
+
+    /**
+    * 获取Map集合
+    *
+    * @param eItem 不包含项
+    * @return
+    */
+    public static Map<String, String> getEnumMap(Date... eItem) {
+        Map<String, String> resultMap = new LinkedHashMap<>();
+        for (ReadEnum item : ReadEnum.values()) {
+            try {
+                boolean hasE = false;
+                for (Date 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

refined-manager/src/main/java/com/mortals/xhx/daemon/task/SyncSiteDeviceTaskImpl.java

 package com.mortals.xhx.daemon.task;
 
+import com.alibaba.fastjson.JSON;
+import com.mortals.framework.common.Rest;
 import com.mortals.framework.exception.AppException;
 import com.mortals.framework.service.ITask;
 import com.mortals.framework.service.ITaskExcuteService;
+import com.mortals.xhx.common.code.YesNoEnum;
+import com.mortals.xhx.module.device.model.DeviceEntity;
+import com.mortals.xhx.module.device.model.DeviceQuery;
 import com.mortals.xhx.module.device.service.DeviceService;
+import com.mortals.xhx.module.hik.camera.model.req.CameraListReq;
+import com.mortals.xhx.module.hik.camera.model.rsp.CameraDataInfo;
+import com.mortals.xhx.module.hik.camera.model.rsp.CameraInfo;
 import com.mortals.xhx.module.hik.camera.service.IHikCameraService;
-import com.mortals.xhx.module.hik.face.model.req.plan.PlanRecognBlackListReq;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
+import org.springframework.util.ObjectUtils;
+
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
 
 /**
  * 同步监控视频点
@@ -31,9 +43,118 @@ public class SyncSiteDeviceTaskImpl implements ITaskExcuteService {
 
     }
 
+    /**
+     *  "altitude": null,
+     *                 "cameraIndexCode": "d271545ad77c4fb28728101d765d76bb",
+     *                 "cameraName": "Camera 02",
+     *                 "cameraType": 0,
+     *                 "cameraTypeName": "枪机",
+     *                 "capabilitySet": "event_audio,io,MixMixedRoot,MixRoot,event_veh_recognition,face,event_vss,record,vss,ptz,event_io,net,maintenance,event_device,status,event_body,event_face,event_rule,event_veh",
+     *                 "capabilitySetName": "音频事件能力,IO能力,,,车辆识别事件能力,人脸识别能力,视频事件能力,录像能力,视频能力,云台能力,IO事件能力,网络参数配置能力,设备维护能力,设备事件能力,状态能力,人体事件能力,人脸事件能力,行为分析事件能力,车辆事件能力",
+     *                 "intelligentSet": null,
+     *                 "intelligentSetName": null,
+     *                 "channelNo": "2",
+     *                 "channelType": "analog",
+     *                 "channelTypeName": "模拟通道",
+     *                 "createTime": "2023-04-10T13:59:08.194+08:00",
+     *                 "encodeDevIndexCode": "f01277c1d6f842b581e6931fa7cc34b4",
+     *                 "encodeDevResourceType": null,
+     *                 "encodeDevResourceTypeName": null,
+     *                 "gbIndexCode": null,
+     *                 "installLocation": null,
+     *                 "keyBoardCode": null,
+     *                 "latitude": null,
+     *                 "longitude": null,
+     *                 "pixel": null,
+     *                 "ptz": null,
+     *                 "ptzName": null,
+     *                 "ptzController": null,
+     *                 "ptzControllerName": null,
+     *                 "recordLocation": null,
+     *                 "recordLocationName": null,
+     *                 "regionIndexCode": "root000000",
+     *                 "status": null,
+     *                 "statusName": null,
+     *                 "transType": 1,
+     *                 "transTypeName": "TCP",
+     *                 "treatyType": null,
+     *                 "treatyTypeName": null,
+     *                 "viewshed": null,
+     *                 "updateTime": "2023-04-10T15:11:56.446+08:00"
+     */
     private void syncDevice() {
 
-        PlanRecognBlackListReq planRecognBlackListReq = new PlanRecognBlackListReq();
+
+        CameraListReq cameraListReq = new CameraListReq();
+        cameraListReq.setPageNo(1);
+        cameraListReq.setPageSize(200);
+
+        Rest<CameraDataInfo> rest = hikCameraService.findCameraList(cameraListReq);
+        if (rest.getCode() == YesNoEnum.YES.getValue()) {
+            List<CameraInfo> cameraDataInfoList = rest.getData().getList();
+            log.info("视频设备总数量：{}", cameraDataInfoList.size());
+            if (!ObjectUtils.isEmpty(cameraDataInfoList)) {
+
+                List<DeviceEntity> newDeviceList = cameraDataInfoList.stream().map(camera -> {
+                    DeviceEntity deviceEntity = new DeviceEntity();
+                    deviceEntity.initAttrValue();
+                    deviceEntity.setDeviceName(camera.getCameraName());
+                    deviceEntity.setDeviceId(camera.getCameraIndexCode());
+                    deviceEntity.setDeviceCode(camera.getCameraIndexCode());
+                    deviceEntity.setCameraType(camera.getCameraType());
+                    deviceEntity.setCameraTypeName(camera.getCameraTypeName());
+                    deviceEntity.setCapabilitySet(camera.getCapabilitySet());
+                    deviceEntity.setCapabilitySetName(camera.getCapabilitySetName());
+                    deviceEntity.setRegionIndexCode(camera.getRegionIndexCode());
+                    deviceEntity.setEncodeDevIndexCode(camera.getEncodeDevIndexCode());
+                    deviceEntity.setCreateTime(camera.getCreateTime());
+                    deviceEntity.setUpdateTime(camera.getUpdateTime());
+                    return deviceEntity;
+                }).collect(Collectors.toList());
+
+                List<DeviceEntity> oldDeviceList = deviceService.find(new DeviceQuery());
+                Map<String, DeviceEntity> oldDeviceMap = oldDeviceList.stream().collect(Collectors.toMap(x -> x.getDeviceCode(), y -> y, (o, n) -> n));
+                Map<String, DeviceEntity> newDeviceMap = newDeviceList.stream().collect(Collectors.toMap(x -> x.getDeviceCode(), y -> y, (o, n) -> n));
+
+
+                List<DeviceEntity> saveDeviceList = newDeviceList.stream().map(item -> {
+                    if (!oldDeviceMap.containsKey(item.getDeviceCode())) {
+                        item.setCreateUserId(1L);
+                        item.setCreateUserName("系统管理员");
+                        return item;
+                    }
+                    return null;
+                }).filter(f -> f != null).collect(Collectors.toList());
+
+                //做差集
+                List<Long> delDeviceList = oldDeviceList.stream().map(item -> {
+                    if (!newDeviceMap.containsKey(item.getDeviceCode())) {
+                        return item.getId();
+                    }
+                    return null;
+                }).filter(f -> f != null).collect(Collectors.toList());
+
+
+                if (!ObjectUtils.isEmpty(saveDeviceList)) {
+                    log.info("设备新增，size:{}", saveDeviceList.size());
+                    deviceService.save(saveDeviceList);
+                }
+
+                if (!ObjectUtils.isEmpty(delDeviceList)) {
+                    log.info("设备删除，size:{}", delDeviceList.size());
+                    deviceService.remove(delDeviceList,null);
+                }
+
+            }
+
+
+        }else{
+            log.info("同步设备异常=>{}", JSON.toJSONString(rest));
+        }
+
+
+
+
         // planRecognBlackListReq.set
 
         //hikCameraService.findPlanRecognBlackList()

refined-manager/src/main/java/com/mortals/xhx/daemon/task/SyncUserTaskImpl.java

+package com.mortals.xhx.daemon.task;
+
+import com.alibaba.fastjson.JSON;
+import com.mortals.framework.common.Rest;
+import com.mortals.framework.exception.AppException;
+import com.mortals.framework.service.ITask;
+import com.mortals.framework.service.ITaskExcuteService;
+import com.mortals.xhx.base.system.user.model.UserEntity;
+import com.mortals.xhx.base.system.user.model.UserQuery;
+import com.mortals.xhx.base.system.user.service.UserService;
+import com.mortals.xhx.common.code.YesNoEnum;
+import com.mortals.xhx.common.pdu.RespData;
+import com.mortals.xhx.common.pdu.user.UserPdu;
+import com.mortals.xhx.feign.user.IUserFeign;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnExpression;
+import org.springframework.stereotype.Service;
+import org.springframework.util.ObjectUtils;
+
+import java.util.List;
+
+/**
+ * 同步用户,唯一标识为用户名。
+ */
+@Slf4j
+@Service("SyncUserTask")
+@ConditionalOnExpression("'${platform.type:null}'=='cloud'")
+public class SyncUserTaskImpl implements ITaskExcuteService {
+
+    @Autowired
+    private IUserFeign userFeign;
+    @Autowired
+    private UserService userService;
+
+    @Override
+    public void excuteTask(ITask task) throws AppException {
+        log.info("同步用户任务");
+        UserPdu userPdu = new UserPdu();
+        userPdu.setPage(1);
+        userPdu.setSize(-1);
+        Rest<RespData<List<UserPdu>>> resp = userFeign.list(userPdu);
+
+        if (resp.getCode() == YesNoEnum.YES.getValue()) {
+            //同步更新用户，以loginname为唯一标识，密码默认与用户相同
+            resp.getData().getData().forEach(user -> {
+                log.info("loginName:{}", user.getLoginName());
+                UserEntity tempEntity = userService.selectOne(new UserQuery().loginName(user.getLoginName()));
+                if (ObjectUtils.isEmpty(tempEntity)) {
+                    UserEntity userEntity = new UserEntity();
+                    BeanUtils.copyProperties(user, userEntity, new String[]{"id","lastLoginTime", "lastLoginAddress"});
+                    log.info("新增:{}", JSON.toJSONString(userEntity));
+                    userService.getUserDao().insert(userEntity);
+                }else {
+                    //更新基本信息
+                    UserEntity userEntity = new UserEntity();
+                    BeanUtils.copyProperties(user, userEntity, new String[]{"loginPwd","userType","status","lastLoginTime", "lastLoginAddress"});
+                    log.info("更新:{}", JSON.toJSONString(userEntity));
+                    userService.getUserDao().update(userEntity);
+                }
+            });
+        }
+    }
+
+
+    @Override
+    public void stopTask(ITask task) throws AppException {
+
+    }
+
+
+}

refined-manager/src/main/java/com/mortals/xhx/daemon/task/SyncUserToHikTaskImpl.java

+package com.mortals.xhx.daemon.task;
+
+import cn.hutool.core.codec.Base64;
+import cn.hutool.core.io.FileUtil;
+import com.alibaba.fastjson.JSON;
+import com.mortals.framework.common.Rest;
+import com.mortals.framework.exception.AppException;
+import com.mortals.framework.service.ITask;
+import com.mortals.framework.service.ITaskExcuteService;
+import com.mortals.xhx.base.system.upload.service.UploadService;
+import com.mortals.xhx.base.system.user.model.UserEntity;
+import com.mortals.xhx.base.system.user.model.UserQuery;
+import com.mortals.xhx.base.system.user.service.UserService;
+import com.mortals.xhx.common.code.YesNoEnum;
+import com.mortals.xhx.common.pdu.RespData;
+import com.mortals.xhx.common.pdu.user.UserPdu;
+import com.mortals.xhx.feign.user.IUserFeign;
+import com.mortals.xhx.module.hik.face.service.IHikFaceService;
+import com.mortals.xhx.module.person.model.PersonEntity;
+import com.mortals.xhx.module.person.model.PersonQuery;
+import com.mortals.xhx.module.person.service.PersonService;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnExpression;
+import org.springframework.stereotype.Service;
+import org.springframework.util.ObjectUtils;
+
+import java.util.List;
+
+/**
+ * 同步用户到海康指定库。
+ */
+@Slf4j
+@Service("SyncUserToHikTask")
+public class SyncUserToHikTaskImpl implements ITaskExcuteService {
+
+    @Autowired
+    private PersonService personService;
+    @Autowired
+    private IHikFaceService hikFaceService;
+    @Autowired
+    private UploadService uploadService;
+
+    @Override
+    public void excuteTask(ITask task) throws AppException {
+        log.info("同步用户人脸到海康任务");
+        List<PersonEntity> personUnHikList = personService.find(new PersonQuery().inFaceHk(YesNoEnum.NO.getValue()));
+        if (!ObjectUtils.isEmpty(personUnHikList)) {
+            for (PersonEntity personEntity : personUnHikList) {
+                //查询图片并转成base64
+                if (!ObjectUtils.isEmpty(personEntity.getPhoto())) {
+                    String filePath = uploadService.getFilePath(personEntity.getPhoto());
+                    byte[] bytes = FileUtil.readBytes(filePath);
+                    if (bytes.length > 0) {
+                        String picBase64Data = Base64.encode(bytes);
+
+                        //log.info("picBase64Data=>{}", picBase64Data);
+
+                    }
+
+
+                }
+                // FileUtil.read
+
+            }
+        }
+
+
+    }
+
+
+    @Override
+    public void stopTask(ITask task) throws AppException {
+
+    }
+
+
+}

refined-manager/src/main/java/com/mortals/xhx/module/device/model/DeviceEntity.java

@@ -7,11 +7,11 @@ import com.mortals.framework.annotation.Excel;
 import com.mortals.framework.model.BaseEntityLong;
 import com.mortals.xhx.module.device.model.vo.DeviceVo;
 /**
-* 设备业务实体对象
-*
-* @author zxfei
-* @date 2023-04-09
-*/
+ * 设备业务实体对象
+ *
+ * @author zxfei
+ * @date 2023-04-14
+ */
 
 public class DeviceEntity extends DeviceVo {
     private static final long serialVersionUID = 1L;
@@ -80,6 +80,30 @@ public class DeviceEntity extends DeviceVo {
      * 设备状态 (1.离线,2.在线)
      */
     private Integer deviceStatus;
+    /**
+     * 区域编码
+     */
+    private String regionIndexCode;
+    /**
+     * 类型名称
+     */
+    private String cameraTypeName;
+    /**
+     * 设备类型
+     */
+    private Integer cameraType;
+    /**
+     * 编码
+     */
+    private String encodeDevIndexCode;
+    /**
+     * 设备能力
+     */
+    private String capabilitySet;
+    /**
+     * 设备能力名称
+     */
+    private String capabilitySetName;
     /**
      * 备注
      */
@@ -312,6 +336,90 @@ public class DeviceEntity extends DeviceVo {
     public void setDeviceStatus(Integer deviceStatus){
         this.deviceStatus = deviceStatus;
     }
+    /**
+     * 获取 区域编码
+     * @return String
+     */
+    public String getRegionIndexCode(){
+        return regionIndexCode;
+    }
+    /**
+     * 设置 区域编码
+     * @param regionIndexCode
+     */
+    public void setRegionIndexCode(String regionIndexCode){
+        this.regionIndexCode = regionIndexCode;
+    }
+    /**
+     * 获取 类型名称
+     * @return String
+     */
+    public String getCameraTypeName(){
+        return cameraTypeName;
+    }
+    /**
+     * 设置 类型名称
+     * @param cameraTypeName
+     */
+    public void setCameraTypeName(String cameraTypeName){
+        this.cameraTypeName = cameraTypeName;
+    }
+    /**
+     * 获取 设备类型
+     * @return Integer
+     */
+    public Integer getCameraType(){
+        return cameraType;
+    }
+    /**
+     * 设置 设备类型
+     * @param cameraType
+     */
+    public void setCameraType(Integer cameraType){
+        this.cameraType = cameraType;
+    }
+    /**
+     * 获取 编码
+     * @return String
+     */
+    public String getEncodeDevIndexCode(){
+        return encodeDevIndexCode;
+    }
+    /**
+     * 设置 编码
+     * @param encodeDevIndexCode
+     */
+    public void setEncodeDevIndexCode(String encodeDevIndexCode){
+        this.encodeDevIndexCode = encodeDevIndexCode;
+    }
+    /**
+     * 获取 设备能力
+     * @return String
+     */
+    public String getCapabilitySet(){
+        return capabilitySet;
+    }
+    /**
+     * 设置 设备能力
+     * @param capabilitySet
+     */
+    public void setCapabilitySet(String capabilitySet){
+        this.capabilitySet = capabilitySet;
+    }
+    /**
+     * 获取 设备能力名称
+     * @return String
+     */
+    public String getCapabilitySetName(){
+        return capabilitySetName;
+    }
+    /**
+     * 设置 设备能力名称
+     * @param capabilitySetName
+     */
+    public void setCapabilitySetName(String capabilitySetName){
+        this.capabilitySetName = capabilitySetName;
+    }
     /**
      * 获取 备注
      * @return String
@@ -364,6 +472,12 @@ public class DeviceEntity extends DeviceVo {
         sb.append(",timeOutPeriod:").append(getTimeOutPeriod());
         sb.append(",nearTime:").append(getNearTime());
         sb.append(",deviceStatus:").append(getDeviceStatus());
+        sb.append(",regionIndexCode:").append(getRegionIndexCode());
+        sb.append(",cameraTypeName:").append(getCameraTypeName());
+        sb.append(",cameraType:").append(getCameraType());
+        sb.append(",encodeDevIndexCode:").append(getEncodeDevIndexCode());
+        sb.append(",capabilitySet:").append(getCapabilitySet());
+        sb.append(",capabilitySetName:").append(getCapabilitySetName());
         sb.append(",deviceRemark:").append(getDeviceRemark());
         return sb.toString();
     }
@@ -396,11 +510,23 @@ public class DeviceEntity extends DeviceVo {
 
         this.leadingOfficialTelephone = "";
 
-            this.timeOutPeriod = null;
+        this.timeOutPeriod = 0;
+
+        this.nearTime = 0;
+
+        this.deviceStatus = 2;
+
+        this.regionIndexCode = "";
+
+        this.cameraTypeName = "";
+
+        this.cameraType = null;
+
+        this.encodeDevIndexCode = "";
 
-            this.nearTime = null;
+        this.capabilitySet = "";
 
-            this.deviceStatus = null;
+        this.capabilitySetName = "";
 
         this.deviceRemark = "";
     }

refined-manager/src/main/java/com/mortals/xhx/module/device/model/DeviceQuery.java

@@ -3,11 +3,11 @@ package com.mortals.xhx.module.device.model;
 import java.util.List;
 import com.mortals.xhx.module.device.model.DeviceEntity;
 /**
-* 设备业务查询对象
-*
-* @author zxfei
-* @date 2023-04-09
-*/
+ * 设备业务查询对象
+ *
+ * @author zxfei
+ * @date 2023-04-14
+ */
 public class DeviceQuery extends DeviceEntity {
     /** 开始 主键ID，主键，自增长 */
     private Long idStart;
@@ -164,6 +164,46 @@ public class DeviceQuery extends DeviceEntity {
     /** 设备状态 (1.离线,2.在线)排除列表 */
     private List <Integer> deviceStatusNotList;
 
+    /** 区域编码 */
+    private List<String> regionIndexCodeList;
+
+    /** 区域编码排除列表 */
+    private List <String> regionIndexCodeNotList;
+    /** 类型名称 */
+    private List<String> cameraTypeNameList;
+
+    /** 类型名称排除列表 */
+    private List <String> cameraTypeNameNotList;
+    /** 开始 设备类型 */
+    private Integer cameraTypeStart;
+
+    /** 结束 设备类型 */
+    private Integer cameraTypeEnd;
+
+    /** 增加 设备类型 */
+    private Integer cameraTypeIncrement;
+
+    /** 设备类型列表 */
+    private List <Integer> cameraTypeList;
+
+    /** 设备类型排除列表 */
+    private List <Integer> cameraTypeNotList;
+
+    /** 编码 */
+    private List<String> encodeDevIndexCodeList;
+
+    /** 编码排除列表 */
+    private List <String> encodeDevIndexCodeNotList;
+    /** 设备能力 */
+    private List<String> capabilitySetList;
+
+    /** 设备能力排除列表 */
+    private List <String> capabilitySetNotList;
+    /** 设备能力名称 */
+    private List<String> capabilitySetNameList;
+
+    /** 设备能力名称排除列表 */
+    private List <String> capabilitySetNameNotList;
     /** 备注 */
     private List<String> deviceRemarkList;
 
@@ -1106,6 +1146,247 @@ public class DeviceQuery extends DeviceEntity {
     }
 
 
+    /**
+     * 获取 区域编码
+     * @return regionIndexCodeList
+     */
+    public List<String> getRegionIndexCodeList(){
+        return this.regionIndexCodeList;
+    }
+
+    /**
+     * 设置 区域编码
+     * @param regionIndexCodeList
+     */
+    public void setRegionIndexCodeList(List<String> regionIndexCodeList){
+        this.regionIndexCodeList = regionIndexCodeList;
+    }
+
+    /**
+     * 获取 区域编码
+     * @return regionIndexCodeNotList
+     */
+    public List<String> getRegionIndexCodeNotList(){
+        return this.regionIndexCodeNotList;
+    }
+
+    /**
+     * 设置 区域编码
+     * @param regionIndexCodeNotList
+     */
+    public void setRegionIndexCodeNotList(List<String> regionIndexCodeNotList){
+        this.regionIndexCodeNotList = regionIndexCodeNotList;
+    }
+
+    /**
+     * 获取 类型名称
+     * @return cameraTypeNameList
+     */
+    public List<String> getCameraTypeNameList(){
+        return this.cameraTypeNameList;
+    }
+
+    /**
+     * 设置 类型名称
+     * @param cameraTypeNameList
+     */
+    public void setCameraTypeNameList(List<String> cameraTypeNameList){
+        this.cameraTypeNameList = cameraTypeNameList;
+    }
+
+    /**
+     * 获取 类型名称
+     * @return cameraTypeNameNotList
+     */
+    public List<String> getCameraTypeNameNotList(){
+        return this.cameraTypeNameNotList;
+    }
+
+    /**
+     * 设置 类型名称
+     * @param cameraTypeNameNotList
+     */
+    public void setCameraTypeNameNotList(List<String> cameraTypeNameNotList){
+        this.cameraTypeNameNotList = cameraTypeNameNotList;
+    }
+
+    /**
+     * 获取 开始 设备类型
+     * @return cameraTypeStart
+     */
+    public Integer getCameraTypeStart(){
+        return this.cameraTypeStart;
+    }
+
+    /**
+     * 设置 开始 设备类型
+     * @param cameraTypeStart
+     */
+    public void setCameraTypeStart(Integer cameraTypeStart){
+        this.cameraTypeStart = cameraTypeStart;
+    }
+
+    /**
+     * 获取 结束 设备类型
+     * @return $cameraTypeEnd
+     */
+    public Integer getCameraTypeEnd(){
+        return this.cameraTypeEnd;
+    }
+
+    /**
+     * 设置 结束 设备类型
+     * @param cameraTypeEnd
+     */
+    public void setCameraTypeEnd(Integer cameraTypeEnd){
+        this.cameraTypeEnd = cameraTypeEnd;
+    }
+
+    /**
+     * 获取 增加 设备类型
+     * @return cameraTypeIncrement
+     */
+    public Integer getCameraTypeIncrement(){
+        return this.cameraTypeIncrement;
+    }
+
+    /**
+     * 设置 增加 设备类型
+     * @param cameraTypeIncrement
+     */
+    public void setCameraTypeIncrement(Integer cameraTypeIncrement){
+        this.cameraTypeIncrement = cameraTypeIncrement;
+    }
+
+    /**
+     * 获取 设备类型
+     * @return cameraTypeList
+     */
+    public List<Integer> getCameraTypeList(){
+        return this.cameraTypeList;
+    }
+
+    /**
+     * 设置 设备类型
+     * @param cameraTypeList
+     */
+    public void setCameraTypeList(List<Integer> cameraTypeList){
+        this.cameraTypeList = cameraTypeList;
+    }
+
+    /**
+     * 获取 设备类型
+     * @return cameraTypeNotList
+     */
+    public List<Integer> getCameraTypeNotList(){
+        return this.cameraTypeNotList;
+    }
+
+    /**
+     * 设置 设备类型
+     * @param cameraTypeNotList
+     */
+    public void setCameraTypeNotList(List<Integer> cameraTypeNotList){
+        this.cameraTypeNotList = cameraTypeNotList;
+    }
+
+
+    /**
+     * 获取 编码
+     * @return encodeDevIndexCodeList
+     */
+    public List<String> getEncodeDevIndexCodeList(){
+        return this.encodeDevIndexCodeList;
+    }
+
+    /**
+     * 设置 编码
+     * @param encodeDevIndexCodeList
+     */
+    public void setEncodeDevIndexCodeList(List<String> encodeDevIndexCodeList){
+        this.encodeDevIndexCodeList = encodeDevIndexCodeList;
+    }
+
+    /**
+     * 获取 编码
+     * @return encodeDevIndexCodeNotList
+     */
+    public List<String> getEncodeDevIndexCodeNotList(){
+        return this.encodeDevIndexCodeNotList;
+    }
+
+    /**
+     * 设置 编码
+     * @param encodeDevIndexCodeNotList
+     */
+    public void setEncodeDevIndexCodeNotList(List<String> encodeDevIndexCodeNotList){
+        this.encodeDevIndexCodeNotList = encodeDevIndexCodeNotList;
+    }
+
+    /**
+     * 获取 设备能力
+     * @return capabilitySetList
+     */
+    public List<String> getCapabilitySetList(){
+        return this.capabilitySetList;
+    }
+
+    /**
+     * 设置 设备能力
+     * @param capabilitySetList
+     */
+    public void setCapabilitySetList(List<String> capabilitySetList){
+        this.capabilitySetList = capabilitySetList;
+    }
+
+    /**
+     * 获取 设备能力
+     * @return capabilitySetNotList
+     */
+    public List<String> getCapabilitySetNotList(){
+        return this.capabilitySetNotList;
+    }
+
+    /**
+     * 设置 设备能力
+     * @param capabilitySetNotList
+     */
+    public void setCapabilitySetNotList(List<String> capabilitySetNotList){
+        this.capabilitySetNotList = capabilitySetNotList;
+    }
+
+    /**
+     * 获取 设备能力名称
+     * @return capabilitySetNameList
+     */
+    public List<String> getCapabilitySetNameList(){
+        return this.capabilitySetNameList;
+    }
+
+    /**
+     * 设置 设备能力名称
+     * @param capabilitySetNameList
+     */
+    public void setCapabilitySetNameList(List<String> capabilitySetNameList){
+        this.capabilitySetNameList = capabilitySetNameList;
+    }
+
+    /**
+     * 获取 设备能力名称
+     * @return capabilitySetNameNotList
+     */
+    public List<String> getCapabilitySetNameNotList(){
+        return this.capabilitySetNameNotList;
+    }
+
+    /**
+     * 设置 设备能力名称
+     * @param capabilitySetNameNotList
+     */
+    public void setCapabilitySetNameNotList(List<String> capabilitySetNameNotList){
+        this.capabilitySetNameNotList = capabilitySetNameNotList;
+    }
+
     /**
      * 获取 备注
      * @return deviceRemarkList
@@ -1933,6 +2214,155 @@ public class DeviceQuery extends DeviceEntity {
     }
 
 
+    /**
+     * 设置 区域编码
+     * @param regionIndexCode
+     */
+    public DeviceQuery regionIndexCode(String regionIndexCode){
+        setRegionIndexCode(regionIndexCode);
+        return this;
+    }
+
+    /**
+     * 设置 区域编码
+     * @param regionIndexCodeList
+     */
+    public DeviceQuery regionIndexCodeList(List<String> regionIndexCodeList){
+        this.regionIndexCodeList = regionIndexCodeList;
+        return this;
+    }
+
+
+    /**
+     * 设置 类型名称
+     * @param cameraTypeName
+     */
+    public DeviceQuery cameraTypeName(String cameraTypeName){
+        setCameraTypeName(cameraTypeName);
+        return this;
+    }
+
+    /**
+     * 设置 类型名称
+     * @param cameraTypeNameList
+     */
+    public DeviceQuery cameraTypeNameList(List<String> cameraTypeNameList){
+        this.cameraTypeNameList = cameraTypeNameList;
+        return this;
+    }
+
+    /**
+     * 设置  设备类型
+     * @param cameraType
+     */
+    public DeviceQuery cameraType(Integer cameraType){
+        setCameraType(cameraType);
+        return this;
+    }
+
+    /**
+     * 设置 开始 设备类型
+     * @param cameraTypeStart
+     */
+    public DeviceQuery cameraTypeStart(Integer cameraTypeStart){
+        this.cameraTypeStart = cameraTypeStart;
+        return this;
+    }
+
+    /**
+     * 设置 结束 设备类型
+     * @param cameraTypeEnd
+     */
+    public DeviceQuery cameraTypeEnd(Integer cameraTypeEnd){
+        this.cameraTypeEnd = cameraTypeEnd;
+        return this;
+    }
+
+    /**
+     * 设置 增加 设备类型
+     * @param cameraTypeIncrement
+     */
+    public DeviceQuery cameraTypeIncrement(Integer cameraTypeIncrement){
+        this.cameraTypeIncrement = cameraTypeIncrement;
+        return this;
+    }
+
+    /**
+     * 设置 设备类型
+     * @param cameraTypeList
+     */
+    public DeviceQuery cameraTypeList(List<Integer> cameraTypeList){
+        this.cameraTypeList = cameraTypeList;
+        return this;
+    }
+
+    /**
+     * 设置 设备类型
+     * @param cameraTypeNotList
+     */
+    public DeviceQuery cameraTypeNotList(List<Integer> cameraTypeNotList){
+        this.cameraTypeNotList = cameraTypeNotList;
+        return this;
+    }
+
+
+    /**
+     * 设置 编码
+     * @param encodeDevIndexCode
+     */
+    public DeviceQuery encodeDevIndexCode(String encodeDevIndexCode){
+        setEncodeDevIndexCode(encodeDevIndexCode);
+        return this;
+    }
+
+    /**
+     * 设置 编码
+     * @param encodeDevIndexCodeList
+     */
+    public DeviceQuery encodeDevIndexCodeList(List<String> encodeDevIndexCodeList){
+        this.encodeDevIndexCodeList = encodeDevIndexCodeList;
+        return this;
+    }
+
+
+    /**
+     * 设置 设备能力
+     * @param capabilitySet
+     */
+    public DeviceQuery capabilitySet(String capabilitySet){
+        setCapabilitySet(capabilitySet);
+        return this;
+    }
+
+    /**
+     * 设置 设备能力
+     * @param capabilitySetList
+     */
+    public DeviceQuery capabilitySetList(List<String> capabilitySetList){
+        this.capabilitySetList = capabilitySetList;
+        return this;
+    }
+
+
+    /**
+     * 设置 设备能力名称
+     * @param capabilitySetName
+     */
+    public DeviceQuery capabilitySetName(String capabilitySetName){
+        setCapabilitySetName(capabilitySetName);
+        return this;
+    }
+
+    /**
+     * 设置 设备能力名称
+     * @param capabilitySetNameList
+     */
+    public DeviceQuery capabilitySetNameList(List<String> capabilitySetNameList){
+        this.capabilitySetNameList = capabilitySetNameList;
+        return this;
+    }
+
+
     /**
      * 设置 备注
      * @param deviceRemark

refined-manager/src/main/java/com/mortals/xhx/module/hik/camera/model/rsp/CameraDataInfo.java

 package com.mortals.xhx.module.hik.camera.model.rsp;
 
-import com.alibaba.fastjson.annotation.JSONField;
 import lombok.Data;
 
+import java.util.List;
+
 @Data
-public class CameraDataInfo{
-	private String regionIndexCode;
-	private String altitude;
-	private String capabilitySetName;
-	private String channelNo;
-	private String latitude;
-	private String channelType;
-	private String keyBoardCode;
-	private String ptzControllerName;
-	private String viewshed;
-	private String cameraIndexCode;
-	private String recordLocation;
-	private String cameraTypeName;
-	private String intelligentSet;
-	private String encodeDevResourceType;
-	private String statusName;
-	private String encodeDevResourceTypeName;
-	private String recordLocationName;
-	private String treatyTypeName;
-	private String channelTypeName;
-	private String transTypeName;
-	private int pixel;
-	private String cameraName;
-	private String longitude;
-	private String installLocation;
-	private String ptzName;
-	@JSONField(format = "yyyy-MM-dd'T'HH:mm:ssXXX")
-	private Data updateTime;
-	private String gbIndexCode;
-	private int ptzController;
-	private int cameraType;
-	private String treatyType;
-	private String intelligentSetName;
-	private int transType;
-	@JSONField(format = "yyyy-MM-dd'T'HH:mm:ssXXX")
-	private Data createTime;
-	private int ptz;
-	private String capabilitySet;
-	private String encodeDevIndexCode;
-	private int status;
+public class CameraDataInfo {
+    private List<CameraInfo> list;
+    private Integer total;
+    private Integer totalPage;
+    private Integer pageNo;
 }

refined-manager/src/main/java/com/mortals/xhx/module/hik/camera/model/rsp/CameraInfo.java

+package com.mortals.xhx.module.hik.camera.model.rsp;
+
+import com.alibaba.fastjson.annotation.JSONField;
+import lombok.Data;
+
+import java.util.Date;
+
+@Data
+public class CameraInfo {
+	private String regionIndexCode;
+	private String altitude;
+	private String capabilitySetName;
+	private String channelNo;
+	private String latitude;
+	private String channelType;
+	private String keyBoardCode;
+	private String ptzControllerName;
+	private String viewshed;
+	private String cameraIndexCode;
+	private String recordLocation;
+	private String cameraTypeName;
+	private String intelligentSet;
+	private String encodeDevResourceType;
+	private String statusName;
+	private String encodeDevResourceTypeName;
+	private String recordLocationName;
+	private String treatyTypeName;
+	private String channelTypeName;
+	private String transTypeName;
+	private int pixel;
+	private String cameraName;
+	private String longitude;
+	private String installLocation;
+	private String ptzName;
+	@JSONField(format = "yyyy-MM-dd'T'HH:mm:ssXXX")
+	private Date updateTime;
+	private String gbIndexCode;
+	private int ptzController;
+	private int cameraType;
+	private String treatyType;
+	private String intelligentSetName;
+	private int transType;
+	@JSONField(format = "yyyy-MM-dd'T'HH:mm:ssXXX")
+	private Date createTime;
+	private int ptz;
+	private String capabilitySet;
+	private String encodeDevIndexCode;
+	private int status;
+}
\ No newline at end of file

refined-manager/src/main/java/com/mortals/xhx/module/hik/camera/service/IHikCameraService.java

@@ -4,10 +4,6 @@ package com.mortals.xhx.module.hik.camera.service;
 import com.mortals.framework.common.Rest;
 import com.mortals.xhx.module.hik.camera.model.req.CameraListReq;
 import com.mortals.xhx.module.hik.camera.model.rsp.CameraDataInfo;
-import com.mortals.xhx.module.hik.face.model.req.plan.PlanRecognBlackListReq;
-import com.mortals.xhx.module.hik.face.model.rsp.plan.PlanRecognBlackInfo;
-
-import java.util.List;
 
 /**
  * 海康人员接口对接类
@@ -20,6 +16,6 @@ public interface IHikCameraService {
      * @param cameraListReq
      * @return
      */
-    Rest<List<CameraDataInfo>> findCameraList(CameraListReq cameraListReq);
+    Rest<CameraDataInfo> findCameraList(CameraListReq cameraListReq);
 
 }

refined-manager/src/main/java/com/mortals/xhx/module/hik/camera/service/impl/HikCameraServiceImpl.java

@@ -8,8 +8,8 @@ import com.mortals.framework.common.Rest;
 import com.mortals.xhx.module.hik.AbstractHikService;
 import com.mortals.xhx.module.hik.camera.model.req.CameraListReq;
 import com.mortals.xhx.module.hik.camera.model.rsp.CameraDataInfo;
+import com.mortals.xhx.module.hik.camera.model.rsp.CameraInfo;
 import com.mortals.xhx.module.hik.camera.service.IHikCameraService;
-import com.mortals.xhx.module.hik.face.model.rsp.plan.PlanRecognBlackInfo;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
 
@@ -27,7 +27,7 @@ public class HikCameraServiceImpl extends AbstractHikService implements IHikCame
 
 
     @Override
-    public Rest<List<CameraDataInfo>> findCameraList(CameraListReq cameraListReq) {
+    public Rest<CameraDataInfo> findCameraList(CameraListReq cameraListReq) {
         ArtemisConfig config = getArtemisConfig();
         String getCamsApi = ARTEMIS_PATH + "/api/resource/v1/cameras";
         path.put(protocol, getCamsApi);
@@ -35,7 +35,7 @@ public class HikCameraServiceImpl extends AbstractHikService implements IHikCame
             log.info("camera list req=>{}", JSON.toJSONString(cameraListReq));
             String respJson = ArtemisHttpUtil.doPostStringArtemis(config, path, JSON.toJSONString(cameraListReq), null, null, "application/json");
             log.info("camera list resp=>{}", respJson);
-            Rest<List<CameraDataInfo>> rest = JSON.parseObject(respJson, new TypeReference<Rest<List<CameraDataInfo>>>() {
+            Rest<CameraDataInfo> rest = JSON.parseObject(respJson, new TypeReference<Rest<CameraDataInfo>>() {
             });
             if (rest.getCode() == 0) {
                 return Rest.ok(rest.getData());

refined-manager/src/main/java/com/mortals/xhx/module/monitor/dao/MonitorAlarmDao.java

+package com.mortals.xhx.module.monitor.dao;
+
+import com.mortals.framework.dao.ICRUDDao;
+import com.mortals.xhx.module.monitor.model.MonitorAlarmEntity;
+import java.util.List;
+/**
+* 监测预警记录Dao
+* 监测预警记录 DAO接口
+*
+* @author zxfei
+* @date 2023-04-15
+*/
+
+public interface  MonitorAlarmDao extends ICRUDDao<MonitorAlarmEntity,Long>{
+
+
+}

refined-manager/src/main/java/com/mortals/xhx/module/monitor/dao/MonitorAlarmRecordDao.java

+package com.mortals.xhx.module.monitor.dao;
+
+import com.mortals.framework.dao.ICRUDDao;
+import com.mortals.xhx.module.monitor.model.MonitorAlarmRecordEntity;
+import java.util.List;
+/**
+* 监测预警记录详细记录Dao
+* 监测预警记录详细记录 DAO接口
+*
+* @author zxfei
+* @date 2023-04-15
+*/
+
+public interface  MonitorAlarmRecordDao extends ICRUDDao<MonitorAlarmRecordEntity,Long>{
+
+
+}

refined-manager/src/main/java/com/mortals/xhx/module/monitor/dao/ibatis/MonitorAlarmDaoImpl.java

+package com.mortals.xhx.module.monitor.dao.ibatis;
+
+
+import org.springframework.stereotype.Repository;
+import com.mortals.xhx.module.monitor.dao.MonitorAlarmDao;
+import com.mortals.xhx.module.monitor.model.MonitorAlarmEntity;
+import java.util.Date;
+import com.mortals.framework.dao.ibatis.BaseCRUDDaoMybatis;
+import java.util.List;
+/**
+* 监测预警记录DaoImpl DAO接口
+*
+* @author zxfei
+* @date 2023-04-15
+*/
+@Repository("monitorAlarmDao")
+public class MonitorAlarmDaoImpl extends BaseCRUDDaoMybatis<MonitorAlarmEntity,Long> implements MonitorAlarmDao {
+
+
+
+}

refined-manager/src/main/java/com/mortals/xhx/module/monitor/dao/ibatis/MonitorAlarmRecordDaoImpl.java

+package com.mortals.xhx.module.monitor.dao.ibatis;
+
+
+import org.springframework.stereotype.Repository;
+import com.mortals.xhx.module.monitor.dao.MonitorAlarmRecordDao;
+import com.mortals.xhx.module.monitor.model.MonitorAlarmRecordEntity;
+import java.util.Date;
+import com.mortals.framework.dao.ibatis.BaseCRUDDaoMybatis;
+import java.util.List;
+/**
+* 监测预警记录详细记录DaoImpl DAO接口
+*
+* @author zxfei
+* @date 2023-04-15
+*/
+@Repository("monitorAlarmRecordDao")
+public class MonitorAlarmRecordDaoImpl extends BaseCRUDDaoMybatis<MonitorAlarmRecordEntity,Long> implements MonitorAlarmRecordDao {
+
+
+
+}

refined-manager/src/main/java/com/mortals/xhx/module/monitor/model/MonitorAlarmEntity.java

+package com.mortals.xhx.module.monitor.model;
+
+import java.util.Date;
+import java.util.List;
+import java.util.ArrayList;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import com.mortals.framework.annotation.Excel;
+import com.mortals.framework.model.BaseEntityLong;
+import com.mortals.xhx.module.monitor.model.vo.MonitorAlarmVo;
+/**
+* 监测预警记录实体对象
+*
+* @author zxfei
+* @date 2023-04-15
+*/
+
+public class MonitorAlarmEntity extends MonitorAlarmVo {
+    private static final long serialVersionUID = 1L;
+
+    /**
+    * 站点Id
+    */
+    private Long siteId;
+    /**
+    * 站点名称
+    */
+    private String siteName;
+    /**
+    * 人员id
+    */
+    @Excel(name = "人员id")
+    private Long personId;
+    /**
+    * 姓名
+    */
+    @Excel(name = "姓名")
+    private String name;
+    /**
+    * 联系方式
+    */
+    @Excel(name = "联系方式")
+    private String contact;
+    /**
+    * 身份证号码
+    */
+    @Excel(name = "身份证号码")
+    private String idNumber;
+    /**
+    * 识别频次
+    */
+    private Integer identifyNum;
+    /**
+    * 最后识别时间
+    */
+    @Excel(name = "最后识别时间", width = 30, dateFormat = "yyyy-MM-dd")
+    private Date lastIdentifyTime;
+    /**
+    * 年
+    */
+    private Integer year;
+    /**
+    * 月
+    */
+    private Integer month;
+    /**
+    * 日
+    */
+    private Integer day;
+
+
+
+    public MonitorAlarmEntity(){}
+    /**
+    * 获取 站点Id
+    * @return Long
+    */
+    public Long getSiteId(){
+        return siteId;
+    }
+    /**
+    * 设置 站点Id
+    * @param siteId
+    */
+    public void setSiteId(Long siteId){
+        this.siteId = siteId;
+    }
+    /**
+    * 获取 站点名称
+    * @return String
+    */
+    public String getSiteName(){
+        return siteName;
+    }
+    /**
+    * 设置 站点名称
+    * @param siteName
+    */
+    public void setSiteName(String siteName){
+        this.siteName = siteName;
+    }
+    /**
+    * 获取 人员id
+    * @return Long
+    */
+    public Long getPersonId(){
+        return personId;
+    }
+    /**
+    * 设置 人员id
+    * @param personId
+    */
+    public void setPersonId(Long personId){
+        this.personId = personId;
+    }
+    /**
+    * 获取 姓名
+    * @return String
+    */
+    public String getName(){
+        return name;
+    }
+    /**
+    * 设置 姓名
+    * @param name
+    */
+    public void setName(String name){
+        this.name = name;
+    }
+    /**
+    * 获取 联系方式
+    * @return String
+    */
+    public String getContact(){
+        return contact;
+    }
+    /**
+    * 设置 联系方式
+    * @param contact
+    */
+    public void setContact(String contact){
+        this.contact = contact;
+    }
+    /**
+    * 获取 身份证号码
+    * @return String
+    */
+    public String getIdNumber(){
+        return idNumber;
+    }
+    /**
+    * 设置 身份证号码
+    * @param idNumber
+    */
+    public void setIdNumber(String idNumber){
+        this.idNumber = idNumber;
+    }
+    /**
+    * 获取 识别频次
+    * @return Integer
+    */
+    public Integer getIdentifyNum(){
+        return identifyNum;
+    }
+    /**
+    * 设置 识别频次
+    * @param identifyNum
+    */
+    public void setIdentifyNum(Integer identifyNum){
+        this.identifyNum = identifyNum;
+    }
+    /**
+    * 获取 最后识别时间
+    * @return Date
+    */
+    public Date getLastIdentifyTime(){
+        return lastIdentifyTime;
+    }
+    /**
+    * 设置 最后识别时间
+    * @param lastIdentifyTime
+    */
+    public void setLastIdentifyTime(Date lastIdentifyTime){
+        this.lastIdentifyTime = lastIdentifyTime;
+    }
+    /**
+    * 获取 年
+    * @return Integer
+    */
+    public Integer getYear(){
+        return year;
+    }
+    /**
+    * 设置 年
+    * @param year
+    */
+    public void setYear(Integer year){
+        this.year = year;
+    }
+    /**
+    * 获取 月
+    * @return Integer
+    */
+    public Integer getMonth(){
+        return month;
+    }
+    /**
+    * 设置 月
+    * @param month
+    */
+    public void setMonth(Integer month){
+        this.month = month;
+    }
+    /**
+    * 获取 日
+    * @return Integer
+    */
+    public Integer getDay(){
+        return day;
+    }
+    /**
+    * 设置 日
+    * @param day
+    */
+    public void setDay(Integer day){
+        this.day = day;
+    }
+
+
+
+
+    @Override
+    public int hashCode() {
+         return this.getId().hashCode();
+    }
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == null) return false;
+        if (obj instanceof MonitorAlarmEntity) {
+            MonitorAlarmEntity tmp = (MonitorAlarmEntity) obj;
+            if (this.getId() == tmp.getId()) {
+                 return true;
+            }
+        }
+        return false;
+    }
+
+    public String toString(){
+        StringBuilder sb = new StringBuilder("");
+        sb.append(",siteId:").append(getSiteId());
+        sb.append(",siteName:").append(getSiteName());
+        sb.append(",personId:").append(getPersonId());
+        sb.append(",name:").append(getName());
+        sb.append(",contact:").append(getContact());
+        sb.append(",idNumber:").append(getIdNumber());
+        sb.append(",identifyNum:").append(getIdentifyNum());
+        sb.append(",lastIdentifyTime:").append(getLastIdentifyTime());
+        sb.append(",year:").append(getYear());
+        sb.append(",month:").append(getMonth());
+        sb.append(",day:").append(getDay());
+        return sb.toString();
+    }
+
+    public void initAttrValue(){
+
+            this.siteId = null;
+
+            this.siteName = "";
+
+            this.personId = null;
+
+            this.name = "";
+
+            this.contact = "";
+
+            this.idNumber = "";
+
+            this.identifyNum = 0;
+
+            this.lastIdentifyTime = null;
+
+            this.year = null;
+
+            this.month = null;
+
+            this.day = null;
+    }
+}
\ No newline at end of file

refined-manager/src/main/java/com/mortals/xhx/module/monitor/model/MonitorAlarmQuery.java

+package com.mortals.xhx.module.monitor.model;
+
+import java.util.Date;
+import java.util.List;
+import com.mortals.xhx.module.monitor.model.MonitorAlarmEntity;
+/**
+* 监测预警记录查询对象
+*
+* @author zxfei
+* @date 2023-04-15
+*/
+public class MonitorAlarmQuery extends MonitorAlarmEntity {
+    /** 开始 主键ID，主键，自增长 */
+    private Long idStart;
+
+    /** 结束 主键ID，主键，自增长 */
+    private Long idEnd;
+
+    /** 增加 主键ID，主键，自增长 */
+    private Long idIncrement;
+
+    /** 主键ID，主键，自增长列表 */
+    private List <Long> idList;
+
+    /** 主键ID，主键，自增长排除列表 */
+    private List <Long> idNotList;
+
+    /** 开始 站点Id */
+    private Long siteIdStart;
+
+    /** 结束 站点Id */
+    private Long siteIdEnd;
+
+    /** 增加 站点Id */
+    private Long siteIdIncrement;
+
+    /** 站点Id列表 */
+    private List <Long> siteIdList;
+
+    /** 站点Id排除列表 */
+    private List <Long> siteIdNotList;
+
+    /** 站点名称 */
+    private List<String> siteNameList;
+
+    /** 站点名称排除列表 */
+    private List <String> siteNameNotList;
+    /** 开始 人员id */
+    private Long personIdStart;
+
+    /** 结束 人员id */
+    private Long personIdEnd;
+
+    /** 增加 人员id */
+    private Long personIdIncrement;
+
+    /** 人员id列表 */
+    private List <Long> personIdList;
+
+    /** 人员id排除列表 */
+    private List <Long> personIdNotList;
+
+    /** 姓名 */
+    private List<String> nameList;
+
+    /** 姓名排除列表 */
+    private List <String> nameNotList;
+    /** 联系方式 */
+    private List<String> contactList;
+
+    /** 联系方式排除列表 */
+    private List <String> contactNotList;
+    /** 身份证号码 */
+    private List<String> idNumberList;
+
+    /** 身份证号码排除列表 */
+    private List <String> idNumberNotList;
+    /** 开始 识别频次 */
+    private Integer identifyNumStart;
+
+    /** 结束 识别频次 */
+    private Integer identifyNumEnd;
+
+    /** 增加 识别频次 */
+    private Integer identifyNumIncrement;
+
+    /** 识别频次列表 */
+    private List <Integer> identifyNumList;
+
+    /** 识别频次排除列表 */
+    private List <Integer> identifyNumNotList;
+
+    /** 开始 最后识别时间 */
+    private String lastIdentifyTimeStart;
+
+    /** 结束 最后识别时间 */
+    private String lastIdentifyTimeEnd;
+
+    /** 开始 年 */
+    private Integer yearStart;
+
+    /** 结束 年 */
+    private Integer yearEnd;
+
+    /** 增加 年 */
+    private Integer yearIncrement;
+
+    /** 年列表 */
+    private List <Integer> yearList;
+
+    /** 年排除列表 */
+    private List <Integer> yearNotList;
+
+    /** 开始 月 */
+    private Integer monthStart;
+
+    /** 结束 月 */
+    private Integer monthEnd;
+
+    /** 增加 月 */
+    private Integer monthIncrement;
+
+    /** 月列表 */
+    private List <Integer> monthList;
+
+    /** 月排除列表 */
+    private List <Integer> monthNotList;
+
+    /** 开始 日 */
+    private Integer dayStart;
+
+    /** 结束 日 */
+    private Integer dayEnd;
+
+    /** 增加 日 */
+    private Integer dayIncrement;
+
+    /** 日列表 */
+    private List <Integer> dayList;
+
+    /** 日排除列表 */
+    private List <Integer> dayNotList;
+
+    /** 开始 创建时间 */
+    private String createTimeStart;
+
+    /** 结束 创建时间 */
+    private String createTimeEnd;
+
+    /** 开始 创建人id */
+    private Long createUserIdStart;
+
+    /** 结束 创建人id */
+    private Long createUserIdEnd;
+
+    /** 增加 创建人id */
+    private Long createUserIdIncrement;
+
+    /** 创建人id列表 */
+    private List <Long> createUserIdList;
+
+    /** 创建人id排除列表 */
+    private List <Long> createUserIdNotList;
+
+    /** 开始 更新时间 */
+    private String updateTimeStart;
+
+    /** 结束 更新时间 */
+    private String updateTimeEnd;
+
+    /** 开始 更新人id */
+    private Long updateUserIdStart;
+
+    /** 结束 更新人id */
+    private Long updateUserIdEnd;
+
+    /** 增加 更新人id */
+    private Long updateUserIdIncrement;
+
+    /** 更新人id列表 */
+    private List <Long> updateUserIdList;
+
+    /** 更新人id排除列表 */
+    private List <Long> updateUserIdNotList;
+
+    /** OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4) */
+    private List<MonitorAlarmQuery> orConditionList;
+
+    /** AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4) */
+    private List<MonitorAlarmQuery> andConditionList;
+
+    public MonitorAlarmQuery(){}
+
+    /**
+    * 获取 开始 主键ID，主键，自增长
+    * @return idStart
+    */
+    public Long getIdStart(){
+        return this.idStart;
+    }
+
+    /**
+    * 设置 开始 主键ID，主键，自增长
+    * @param idStart
+    */
+    public void setIdStart(Long idStart){
+        this.idStart = idStart;
+    }
+
+    /**
+    * 获取 结束 主键ID，主键，自增长
+    * @return $idEnd
+    */
+    public Long getIdEnd(){
+        return this.idEnd;
+    }
+
+    /**
+    * 设置 结束 主键ID，主键，自增长
+    * @param idEnd
+    */
+    public void setIdEnd(Long idEnd){
+        this.idEnd = idEnd;
+    }
+
+    /**
+    * 获取 增加 主键ID，主键，自增长
+    * @return idIncrement
+    */
+    public Long getIdIncrement(){
+        return this.idIncrement;
+    }
+
+    /**
+    * 设置 增加 主键ID，主键，自增长
+    * @param idIncrement
+    */
+    public void setIdIncrement(Long idIncrement){
+        this.idIncrement = idIncrement;
+    }
+
+    /**
+    * 获取 主键ID，主键，自增长
+    * @return idList
+    */
+    public List<Long> getIdList(){
+        return this.idList;
+    }
+
+    /**
+    * 设置 主键ID，主键，自增长
+    * @param idList
+    */
+    public void setIdList(List<Long> idList){
+        this.idList = idList;
+    }
+
+    /**
+    * 获取 主键ID，主键，自增长
+    * @return idNotList
+    */
+    public List<Long> getIdNotList(){
+        return this.idNotList;
+    }
+
+    /**
+    * 设置 主键ID，主键，自增长
+    * @param idNotList
+    */
+    public void setIdNotList(List<Long> idNotList){
+        this.idNotList = idNotList;
+    }
+
+
+    /**
+    * 获取 开始 站点Id
+    * @return siteIdStart
+    */
+    public Long getSiteIdStart(){
+        return this.siteIdStart;
+    }
+
+    /**
+    * 设置 开始 站点Id
+    * @param siteIdStart
+    */
+    public void setSiteIdStart(Long siteIdStart){
+        this.siteIdStart = siteIdStart;
+    }
+
+    /**
+    * 获取 结束 站点Id
+    * @return $siteIdEnd
+    */
+    public Long getSiteIdEnd(){
+        return this.siteIdEnd;
+    }
+
+    /**
+    * 设置 结束 站点Id
+    * @param siteIdEnd
+    */
+    public void setSiteIdEnd(Long siteIdEnd){
+        this.siteIdEnd = siteIdEnd;
+    }
+
+    /**
+    * 获取 增加 站点Id
+    * @return siteIdIncrement
+    */
+    public Long getSiteIdIncrement(){
+        return this.siteIdIncrement;
+    }
+
+    /**
+    * 设置 增加 站点Id
+    * @param siteIdIncrement
+    */
+    public void setSiteIdIncrement(Long siteIdIncrement){
+        this.siteIdIncrement = siteIdIncrement;
+    }
+
+    /**
+    * 获取 站点Id
+    * @return siteIdList
+    */
+    public List<Long> getSiteIdList(){
+        return this.siteIdList;
+    }
+
+    /**
+    * 设置 站点Id
+    * @param siteIdList
+    */
+    public void setSiteIdList(List<Long> siteIdList){
+        this.siteIdList = siteIdList;
+    }
+
+    /**
+    * 获取 站点Id
+    * @return siteIdNotList
+    */
+    public List<Long> getSiteIdNotList(){
+        return this.siteIdNotList;
+    }
+
+    /**
+    * 设置 站点Id
+    * @param siteIdNotList
+    */
+    public void setSiteIdNotList(List<Long> siteIdNotList){
+        this.siteIdNotList = siteIdNotList;
+    }
+
+
+    /**
+    * 获取 站点名称
+    * @return siteNameList
+    */
+    public List<String> getSiteNameList(){
+        return this.siteNameList;
+    }
+
+    /**
+    * 设置 站点名称
+    * @param siteNameList
+    */
+    public void setSiteNameList(List<String> siteNameList){
+        this.siteNameList = siteNameList;
+    }
+
+    /**
+    * 获取 站点名称
+    * @return siteNameNotList
+    */
+    public List<String> getSiteNameNotList(){
+        return this.siteNameNotList;
+    }
+
+    /**
+    * 设置 站点名称
+    * @param siteNameNotList
+    */
+    public void setSiteNameNotList(List<String> siteNameNotList){
+        this.siteNameNotList = siteNameNotList;
+    }
+
+    /**
+    * 获取 开始 人员id
+    * @return personIdStart
+    */
+    public Long getPersonIdStart(){
+        return this.personIdStart;
+    }
+
+    /**
+    * 设置 开始 人员id
+    * @param personIdStart
+    */
+    public void setPersonIdStart(Long personIdStart){
+        this.personIdStart = personIdStart;
+    }
+
+    /**
+    * 获取 结束 人员id
+    * @return $personIdEnd
+    */
+    public Long getPersonIdEnd(){
+        return this.personIdEnd;
+    }
+
+    /**
+    * 设置 结束 人员id
+    * @param personIdEnd
+    */
+    public void setPersonIdEnd(Long personIdEnd){
+        this.personIdEnd = personIdEnd;
+    }
+
+    /**
+    * 获取 增加 人员id
+    * @return personIdIncrement
+    */
+    public Long getPersonIdIncrement(){
+        return this.personIdIncrement;
+    }
+
+    /**
+    * 设置 增加 人员id
+    * @param personIdIncrement
+    */
+    public void setPersonIdIncrement(Long personIdIncrement){
+        this.personIdIncrement = personIdIncrement;
+    }
+
+    /**
+    * 获取 人员id
+    * @return personIdList
+    */
+    public List<Long> getPersonIdList(){
+        return this.personIdList;
+    }
+
+    /**
+    * 设置 人员id
+    * @param personIdList
+    */
+    public void setPersonIdList(List<Long> personIdList){
+        this.personIdList = personIdList;
+    }
+
+    /**
+    * 获取 人员id
+    * @return personIdNotList
+    */
+    public List<Long> getPersonIdNotList(){
+        return this.personIdNotList;
+    }
+
+    /**
+    * 设置 人员id
+    * @param personIdNotList
+    */
+    public void setPersonIdNotList(List<Long> personIdNotList){
+        this.personIdNotList = personIdNotList;
+    }
+
+
+    /**
+    * 获取 姓名
+    * @return nameList
+    */
+    public List<String> getNameList(){
+        return this.nameList;
+    }
+
+    /**
+    * 设置 姓名
+    * @param nameList
+    */
+    public void setNameList(List<String> nameList){
+        this.nameList = nameList;
+    }
+
+    /**
+    * 获取 姓名
+    * @return nameNotList
+    */
+    public List<String> getNameNotList(){
+        return this.nameNotList;
+    }
+
+    /**
+    * 设置 姓名
+    * @param nameNotList
+    */
+    public void setNameNotList(List<String> nameNotList){
+        this.nameNotList = nameNotList;
+    }
+
+    /**
+    * 获取 联系方式
+    * @return contactList
+    */
+    public List<String> getContactList(){
+        return this.contactList;
+    }
+
+    /**
+    * 设置 联系方式
+    * @param contactList
+    */
+    public void setContactList(List<String> contactList){
+        this.contactList = contactList;
+    }
+
+    /**
+    * 获取 联系方式
+    * @return contactNotList
+    */
+    public List<String> getContactNotList(){
+        return this.contactNotList;
+    }
+
+    /**
+    * 设置 联系方式
+    * @param contactNotList
+    */
+    public void setContactNotList(List<String> contactNotList){
+        this.contactNotList = contactNotList;
+    }
+
+    /**
+    * 获取 身份证号码
+    * @return idNumberList
+    */
+    public List<String> getIdNumberList(){
+        return this.idNumberList;
+    }
+
+    /**
+    * 设置 身份证号码
+    * @param idNumberList
+    */
+    public void setIdNumberList(List<String> idNumberList){
+        this.idNumberList = idNumberList;
+    }
+
+    /**
+    * 获取 身份证号码
+    * @return idNumberNotList
+    */
+    public List<String> getIdNumberNotList(){
+        return this.idNumberNotList;
+    }
+
+    /**
+    * 设置 身份证号码
+    * @param idNumberNotList
+    */
+    public void setIdNumberNotList(List<String> idNumberNotList){
+        this.idNumberNotList = idNumberNotList;
+    }
+
+    /**
+    * 获取 开始 识别频次
+    * @return identifyNumStart
+    */
+    public Integer getIdentifyNumStart(){
+        return this.identifyNumStart;
+    }
+
+    /**
+    * 设置 开始 识别频次
+    * @param identifyNumStart
+    */
+    public void setIdentifyNumStart(Integer identifyNumStart){
+        this.identifyNumStart = identifyNumStart;
+    }
+
+    /**
+    * 获取 结束 识别频次
+    * @return $identifyNumEnd
+    */
+    public Integer getIdentifyNumEnd(){
+        return this.identifyNumEnd;
+    }
+
+    /**
+    * 设置 结束 识别频次
+    * @param identifyNumEnd
+    */
+    public void setIdentifyNumEnd(Integer identifyNumEnd){
+        this.identifyNumEnd = identifyNumEnd;
+    }
+
+    /**
+    * 获取 增加 识别频次
+    * @return identifyNumIncrement
+    */
+    public Integer getIdentifyNumIncrement(){
+        return this.identifyNumIncrement;
+    }
+
+    /**
+    * 设置 增加 识别频次
+    * @param identifyNumIncrement
+    */
+    public void setIdentifyNumIncrement(Integer identifyNumIncrement){
+        this.identifyNumIncrement = identifyNumIncrement;
+    }
+
+    /**
+    * 获取 识别频次
+    * @return identifyNumList
+    */
+    public List<Integer> getIdentifyNumList(){
+        return this.identifyNumList;
+    }
+
+    /**
+    * 设置 识别频次
+    * @param identifyNumList
+    */
+    public void setIdentifyNumList(List<Integer> identifyNumList){
+        this.identifyNumList = identifyNumList;
+    }
+
+    /**
+    * 获取 识别频次
+    * @return identifyNumNotList
+    */
+    public List<Integer> getIdentifyNumNotList(){
+        return this.identifyNumNotList;
+    }
+
+    /**
+    * 设置 识别频次
+    * @param identifyNumNotList
+    */
+    public void setIdentifyNumNotList(List<Integer> identifyNumNotList){
+        this.identifyNumNotList = identifyNumNotList;
+    }
+
+
+    /**
+    * 获取 开始 最后识别时间
+    * @return lastIdentifyTimeStart
+    */
+    public String getLastIdentifyTimeStart(){
+        return this.lastIdentifyTimeStart;
+    }
+
+    /**
+    * 设置 开始 最后识别时间
+    * @param lastIdentifyTimeStart
+    */
+    public void setLastIdentifyTimeStart(String lastIdentifyTimeStart){
+        this.lastIdentifyTimeStart = lastIdentifyTimeStart;
+    }
+
+    /**
+    * 获取 结束 最后识别时间
+    * @return lastIdentifyTimeEnd
+    */
+    public String getLastIdentifyTimeEnd(){
+        return this.lastIdentifyTimeEnd;
+    }
+
+    /**
+    * 设置 结束 最后识别时间
+    * @param lastIdentifyTimeEnd
+    */
+    public void setLastIdentifyTimeEnd(String lastIdentifyTimeEnd){
+        this.lastIdentifyTimeEnd = lastIdentifyTimeEnd;
+    }
+
+    /**
+    * 获取 开始 年
+    * @return yearStart
+    */
+    public Integer getYearStart(){
+        return this.yearStart;
+    }
+
+    /**
+    * 设置 开始 年
+    * @param yearStart
+    */
+    public void setYearStart(Integer yearStart){
+        this.yearStart = yearStart;
+    }
+
+    /**
+    * 获取 结束 年
+    * @return $yearEnd
+    */
+    public Integer getYearEnd(){
+        return this.yearEnd;
+    }
+
+    /**
+    * 设置 结束 年
+    * @param yearEnd
+    */
+    public void setYearEnd(Integer yearEnd){
+        this.yearEnd = yearEnd;
+    }
+
+    /**
+    * 获取 增加 年
+    * @return yearIncrement
+    */
+    public Integer getYearIncrement(){
+        return this.yearIncrement;
+    }
+
+    /**
+    * 设置 增加 年
+    * @param yearIncrement
+    */
+    public void setYearIncrement(Integer yearIncrement){
+        this.yearIncrement = yearIncrement;
+    }
+
+    /**
+    * 获取 年
+    * @return yearList
+    */
+    public List<Integer> getYearList(){
+        return this.yearList;
+    }
+
+    /**
+    * 设置 年
+    * @param yearList
+    */
+    public void setYearList(List<Integer> yearList){
+        this.yearList = yearList;
+    }
+
+    /**
+    * 获取 年
+    * @return yearNotList
+    */
+    public List<Integer> getYearNotList(){
+        return this.yearNotList;
+    }
+
+    /**
+    * 设置 年
+    * @param yearNotList
+    */
+    public void setYearNotList(List<Integer> yearNotList){
+        this.yearNotList = yearNotList;
+    }
+
+
+    /**
+    * 获取 开始 月
+    * @return monthStart
+    */
+    public Integer getMonthStart(){
+        return this.monthStart;
+    }
+
+    /**
+    * 设置 开始 月
+    * @param monthStart
+    */
+    public void setMonthStart(Integer monthStart){
+        this.monthStart = monthStart;
+    }
+
+    /**
+    * 获取 结束 月
+    * @return $monthEnd
+    */
+    public Integer getMonthEnd(){
+        return this.monthEnd;
+    }
+
+    /**
+    * 设置 结束 月
+    * @param monthEnd
+    */
+    public void setMonthEnd(Integer monthEnd){
+        this.monthEnd = monthEnd;
+    }
+
+    /**
+    * 获取 增加 月
+    * @return monthIncrement
+    */
+    public Integer getMonthIncrement(){
+        return this.monthIncrement;
+    }
+
+    /**
+    * 设置 增加 月
+    * @param monthIncrement
+    */
+    public void setMonthIncrement(Integer monthIncrement){
+        this.monthIncrement = monthIncrement;
+    }
+
+    /**
+    * 获取 月
+    * @return monthList
+    */
+    public List<Integer> getMonthList(){
+        return this.monthList;
+    }
+
+    /**
+    * 设置 月
+    * @param monthList
+    */
+    public void setMonthList(List<Integer> monthList){
+        this.monthList = monthList;
+    }
+
+    /**
+    * 获取 月
+    * @return monthNotList
+    */
+    public List<Integer> getMonthNotList(){
+        return this.monthNotList;
+    }
+
+    /**
+    * 设置 月
+    * @param monthNotList
+    */
+    public void setMonthNotList(List<Integer> monthNotList){
+        this.monthNotList = monthNotList;
+    }
+
+
+    /**
+    * 获取 开始 日
+    * @return dayStart
+    */
+    public Integer getDayStart(){
+        return this.dayStart;
+    }
+
+    /**
+    * 设置 开始 日
+    * @param dayStart
+    */
+    public void setDayStart(Integer dayStart){
+        this.dayStart = dayStart;
+    }
+
+    /**
+    * 获取 结束 日
+    * @return $dayEnd
+    */
+    public Integer getDayEnd(){
+        return this.dayEnd;
+    }
+
+    /**
+    * 设置 结束 日
+    * @param dayEnd
+    */
+    public void setDayEnd(Integer dayEnd){
+        this.dayEnd = dayEnd;
+    }
+
+    /**
+    * 获取 增加 日
+    * @return dayIncrement
+    */
+    public Integer getDayIncrement(){
+        return this.dayIncrement;
+    }
+
+    /**
+    * 设置 增加 日
+    * @param dayIncrement
+    */
+    public void setDayIncrement(Integer dayIncrement){
+        this.dayIncrement = dayIncrement;
+    }
+
+    /**
+    * 获取 日
+    * @return dayList
+    */
+    public List<Integer> getDayList(){
+        return this.dayList;
+    }
+
+    /**
+    * 设置 日
+    * @param dayList
+    */
+    public void setDayList(List<Integer> dayList){
+        this.dayList = dayList;
+    }
+
+    /**
+    * 获取 日
+    * @return dayNotList
+    */
+    public List<Integer> getDayNotList(){
+        return this.dayNotList;
+    }
+
+    /**
+    * 设置 日
+    * @param dayNotList
+    */
+    public void setDayNotList(List<Integer> dayNotList){
+        this.dayNotList = dayNotList;
+    }
+
+
+    /**
+    * 获取 开始 创建时间
+    * @return createTimeStart
+    */
+    public String getCreateTimeStart(){
+        return this.createTimeStart;
+    }
+
+    /**
+    * 设置 开始 创建时间
+    * @param createTimeStart
+    */
+    public void setCreateTimeStart(String createTimeStart){
+        this.createTimeStart = createTimeStart;
+    }
+
+    /**
+    * 获取 结束 创建时间
+    * @return createTimeEnd
+    */
+    public String getCreateTimeEnd(){
+        return this.createTimeEnd;
+    }
+
+    /**
+    * 设置 结束 创建时间
+    * @param createTimeEnd
+    */
+    public void setCreateTimeEnd(String createTimeEnd){
+        this.createTimeEnd = createTimeEnd;
+    }
+
+    /**
+    * 获取 开始 创建人id
+    * @return createUserIdStart
+    */
+    public Long getCreateUserIdStart(){
+        return this.createUserIdStart;
+    }
+
+    /**
+    * 设置 开始 创建人id
+    * @param createUserIdStart
+    */
+    public void setCreateUserIdStart(Long createUserIdStart){
+        this.createUserIdStart = createUserIdStart;
+    }
+
+    /**
+    * 获取 结束 创建人id
+    * @return $createUserIdEnd
+    */
+    public Long getCreateUserIdEnd(){
+        return this.createUserIdEnd;
+    }
+
+    /**
+    * 设置 结束 创建人id
+    * @param createUserIdEnd
+    */
+    public void setCreateUserIdEnd(Long createUserIdEnd){
+        this.createUserIdEnd = createUserIdEnd;
+    }
+
+    /**
+    * 获取 增加 创建人id
+    * @return createUserIdIncrement
+    */
+    public Long getCreateUserIdIncrement(){
+        return this.createUserIdIncrement;
+    }
+
+    /**
+    * 设置 增加 创建人id
+    * @param createUserIdIncrement
+    */
+    public void setCreateUserIdIncrement(Long createUserIdIncrement){
+        this.createUserIdIncrement = createUserIdIncrement;
+    }
+
+    /**
+    * 获取 创建人id
+    * @return createUserIdList
+    */
+    public List<Long> getCreateUserIdList(){
+        return this.createUserIdList;
+    }
+
+    /**
+    * 设置 创建人id
+    * @param createUserIdList
+    */
+    public void setCreateUserIdList(List<Long> createUserIdList){
+        this.createUserIdList = createUserIdList;
+    }
+
+    /**
+    * 获取 创建人id
+    * @return createUserIdNotList
+    */
+    public List<Long> getCreateUserIdNotList(){
+        return this.createUserIdNotList;
+    }
+
+    /**
+    * 设置 创建人id
+    * @param createUserIdNotList
+    */
+    public void setCreateUserIdNotList(List<Long> createUserIdNotList){
+        this.createUserIdNotList = createUserIdNotList;
+    }
+
+
+    /**
+    * 获取 开始 更新时间
+    * @return updateTimeStart
+    */
+    public String getUpdateTimeStart(){
+        return this.updateTimeStart;
+    }
+
+    /**
+    * 设置 开始 更新时间
+    * @param updateTimeStart
+    */
+    public void setUpdateTimeStart(String updateTimeStart){
+        this.updateTimeStart = updateTimeStart;
+    }
+
+    /**
+    * 获取 结束 更新时间
+    * @return updateTimeEnd
+    */
+    public String getUpdateTimeEnd(){
+        return this.updateTimeEnd;
+    }
+
+    /**
+    * 设置 结束 更新时间
+    * @param updateTimeEnd
+    */
+    public void setUpdateTimeEnd(String updateTimeEnd){
+        this.updateTimeEnd = updateTimeEnd;
+    }
+
+    /**
+    * 获取 开始 更新人id
+    * @return updateUserIdStart
+    */
+    public Long getUpdateUserIdStart(){
+        return this.updateUserIdStart;
+    }
+
+    /**
+    * 设置 开始 更新人id
+    * @param updateUserIdStart
+    */
+    public void setUpdateUserIdStart(Long updateUserIdStart){
+        this.updateUserIdStart = updateUserIdStart;
+    }
+
+    /**
+    * 获取 结束 更新人id
+    * @return $updateUserIdEnd
+    */
+    public Long getUpdateUserIdEnd(){
+        return this.updateUserIdEnd;
+    }
+
+    /**
+    * 设置 结束 更新人id
+    * @param updateUserIdEnd
+    */
+    public void setUpdateUserIdEnd(Long updateUserIdEnd){
+        this.updateUserIdEnd = updateUserIdEnd;
+    }
+
+    /**
+    * 获取 增加 更新人id
+    * @return updateUserIdIncrement
+    */
+    public Long getUpdateUserIdIncrement(){
+        return this.updateUserIdIncrement;
+    }
+
+    /**
+    * 设置 增加 更新人id
+    * @param updateUserIdIncrement
+    */
+    public void setUpdateUserIdIncrement(Long updateUserIdIncrement){
+        this.updateUserIdIncrement = updateUserIdIncrement;
+    }
+
+    /**
+    * 获取 更新人id
+    * @return updateUserIdList
+    */
+    public List<Long> getUpdateUserIdList(){
+        return this.updateUserIdList;
+    }
+
+    /**
+    * 设置 更新人id
+    * @param updateUserIdList
+    */
+    public void setUpdateUserIdList(List<Long> updateUserIdList){
+        this.updateUserIdList = updateUserIdList;
+    }
+
+    /**
+    * 获取 更新人id
+    * @return updateUserIdNotList
+    */
+    public List<Long> getUpdateUserIdNotList(){
+        return this.updateUserIdNotList;
+    }
+
+    /**
+    * 设置 更新人id
+    * @param updateUserIdNotList
+    */
+    public void setUpdateUserIdNotList(List<Long> updateUserIdNotList){
+        this.updateUserIdNotList = updateUserIdNotList;
+    }
+
+
+    /**
+    * 设置  主键ID，主键，自增长
+    * @param id
+    */
+    public MonitorAlarmQuery id(Long id){
+	    setId(id);
+		return this;
+    }
+	
+	 /**
+    * 设置 开始 主键ID，主键，自增长
+    * @param idStart
+    */
+    public MonitorAlarmQuery idStart(Long idStart){
+		this.idStart = idStart;
+		return this;
+    }
+
+    /**
+    * 设置 结束 主键ID，主键，自增长
+    * @param idEnd
+    */
+    public MonitorAlarmQuery idEnd(Long idEnd){
+		this.idEnd = idEnd;
+		return this;
+    }
+
+    /**
+    * 设置 增加 主键ID，主键，自增长
+    * @param idIncrement
+    */
+    public MonitorAlarmQuery idIncrement(Long idIncrement){
+		this.idIncrement = idIncrement;
+		return this;
+    }
+
+    /**
+    * 设置 主键ID，主键，自增长
+    * @param idList
+    */
+    public MonitorAlarmQuery idList(List<Long> idList){
+        this.idList = idList;
+		return this;
+        }
+
+        /**
+        * 设置 主键ID，主键，自增长
+        * @param idNotList
+        */
+        public MonitorAlarmQuery idNotList(List<Long> idNotList){
+        this.idNotList = idNotList;
+        return this;
+        }
+
+    /**
+    * 设置  站点Id
+    * @param siteId
+    */
+    public MonitorAlarmQuery siteId(Long siteId){
+	    setSiteId(siteId);
+		return this;
+    }
+	
+	 /**
+    * 设置 开始 站点Id
+    * @param siteIdStart
+    */
+    public MonitorAlarmQuery siteIdStart(Long siteIdStart){
+		this.siteIdStart = siteIdStart;
+		return this;
+    }
+
+    /**
+    * 设置 结束 站点Id
+    * @param siteIdEnd
+    */
+    public MonitorAlarmQuery siteIdEnd(Long siteIdEnd){
+		this.siteIdEnd = siteIdEnd;
+		return this;
+    }
+
+    /**
+    * 设置 增加 站点Id
+    * @param siteIdIncrement
+    */
+    public MonitorAlarmQuery siteIdIncrement(Long siteIdIncrement){
+		this.siteIdIncrement = siteIdIncrement;
+		return this;
+    }
+
+    /**
+    * 设置 站点Id
+    * @param siteIdList
+    */
+    public MonitorAlarmQuery siteIdList(List<Long> siteIdList){
+        this.siteIdList = siteIdList;
+		return this;
+        }
+
+        /**
+        * 设置 站点Id
+        * @param siteIdNotList
+        */
+        public MonitorAlarmQuery siteIdNotList(List<Long> siteIdNotList){
+        this.siteIdNotList = siteIdNotList;
+        return this;
+        }
+
+
+	/**
+    * 设置 站点名称
+    * @param siteName
+    */
+    public MonitorAlarmQuery siteName(String siteName){
+        setSiteName(siteName);
+		return this;
+    }
+
+    /**
+    * 设置 站点名称
+    * @param siteNameList
+    */
+    public MonitorAlarmQuery siteNameList(List<String> siteNameList){
+        this.siteNameList = siteNameList;
+		return this;
+    }
+
+    /**
+    * 设置  人员id
+    * @param personId
+    */
+    public MonitorAlarmQuery personId(Long personId){
+	    setPersonId(personId);
+		return this;
+    }
+	
+	 /**
+    * 设置 开始 人员id
+    * @param personIdStart
+    */
+    public MonitorAlarmQuery personIdStart(Long personIdStart){
+		this.personIdStart = personIdStart;
+		return this;
+    }
+
+    /**
+    * 设置 结束 人员id
+    * @param personIdEnd
+    */
+    public MonitorAlarmQuery personIdEnd(Long personIdEnd){
+		this.personIdEnd = personIdEnd;
+		return this;
+    }
+
+    /**
+    * 设置 增加 人员id
+    * @param personIdIncrement
+    */
+    public MonitorAlarmQuery personIdIncrement(Long personIdIncrement){
+		this.personIdIncrement = personIdIncrement;
+		return this;
+    }
+
+    /**
+    * 设置 人员id
+    * @param personIdList
+    */
+    public MonitorAlarmQuery personIdList(List<Long> personIdList){
+        this.personIdList = personIdList;
+		return this;
+        }
+
+        /**
+        * 设置 人员id
+        * @param personIdNotList
+        */
+        public MonitorAlarmQuery personIdNotList(List<Long> personIdNotList){
+        this.personIdNotList = personIdNotList;
+        return this;
+        }
+
+
+	/**
+    * 设置 姓名
+    * @param name
+    */
+    public MonitorAlarmQuery name(String name){
+        setName(name);
+		return this;
+    }
+
+    /**
+    * 设置 姓名
+    * @param nameList
+    */
+    public MonitorAlarmQuery nameList(List<String> nameList){
+        this.nameList = nameList;
+		return this;
+    }
+
+
+	/**
+    * 设置 联系方式
+    * @param contact
+    */
+    public MonitorAlarmQuery contact(String contact){
+        setContact(contact);
+		return this;
+    }
+
+    /**
+    * 设置 联系方式
+    * @param contactList
+    */
+    public MonitorAlarmQuery contactList(List<String> contactList){
+        this.contactList = contactList;
+		return this;
+    }
+
+
+	/**
+    * 设置 身份证号码
+    * @param idNumber
+    */
+    public MonitorAlarmQuery idNumber(String idNumber){
+        setIdNumber(idNumber);
+		return this;
+    }
+
+    /**
+    * 设置 身份证号码
+    * @param idNumberList
+    */
+    public MonitorAlarmQuery idNumberList(List<String> idNumberList){
+        this.idNumberList = idNumberList;
+		return this;
+    }
+
+    /**
+    * 设置  识别频次
+    * @param identifyNum
+    */
+    public MonitorAlarmQuery identifyNum(Integer identifyNum){
+	    setIdentifyNum(identifyNum);
+		return this;
+    }
+	
+	 /**
+    * 设置 开始 识别频次
+    * @param identifyNumStart
+    */
+    public MonitorAlarmQuery identifyNumStart(Integer identifyNumStart){
+		this.identifyNumStart = identifyNumStart;
+		return this;
+    }
+
+    /**
+    * 设置 结束 识别频次
+    * @param identifyNumEnd
+    */
+    public MonitorAlarmQuery identifyNumEnd(Integer identifyNumEnd){
+		this.identifyNumEnd = identifyNumEnd;
+		return this;
+    }
+
+    /**
+    * 设置 增加 识别频次
+    * @param identifyNumIncrement
+    */
+    public MonitorAlarmQuery identifyNumIncrement(Integer identifyNumIncrement){
+		this.identifyNumIncrement = identifyNumIncrement;
+		return this;
+    }
+
+    /**
+    * 设置 识别频次
+    * @param identifyNumList
+    */
+    public MonitorAlarmQuery identifyNumList(List<Integer> identifyNumList){
+        this.identifyNumList = identifyNumList;
+		return this;
+        }
+
+        /**
+        * 设置 识别频次
+        * @param identifyNumNotList
+        */
+        public MonitorAlarmQuery identifyNumNotList(List<Integer> identifyNumNotList){
+        this.identifyNumNotList = identifyNumNotList;
+        return this;
+        }
+
+
+    /**
+    * 设置  年
+    * @param year
+    */
+    public MonitorAlarmQuery year(Integer year){
+	    setYear(year);
+		return this;
+    }
+	
+	 /**
+    * 设置 开始 年
+    * @param yearStart
+    */
+    public MonitorAlarmQuery yearStart(Integer yearStart){
+		this.yearStart = yearStart;
+		return this;
+    }
+
+    /**
+    * 设置 结束 年
+    * @param yearEnd
+    */
+    public MonitorAlarmQuery yearEnd(Integer yearEnd){
+		this.yearEnd = yearEnd;
+		return this;
+    }
+
+    /**
+    * 设置 增加 年
+    * @param yearIncrement
+    */
+    public MonitorAlarmQuery yearIncrement(Integer yearIncrement){
+		this.yearIncrement = yearIncrement;
+		return this;
+    }
+
+    /**
+    * 设置 年
+    * @param yearList
+    */
+    public MonitorAlarmQuery yearList(List<Integer> yearList){
+        this.yearList = yearList;
+		return this;
+        }
+
+        /**
+        * 设置 年
+        * @param yearNotList
+        */
+        public MonitorAlarmQuery yearNotList(List<Integer> yearNotList){
+        this.yearNotList = yearNotList;
+        return this;
+        }
+
+    /**
+    * 设置  月
+    * @param month
+    */
+    public MonitorAlarmQuery month(Integer month){
+	    setMonth(month);
+		return this;
+    }
+	
+	 /**
+    * 设置 开始 月
+    * @param monthStart
+    */
+    public MonitorAlarmQuery monthStart(Integer monthStart){
+		this.monthStart = monthStart;
+		return this;
+    }
+
+    /**
+    * 设置 结束 月
+    * @param monthEnd
+    */
+    public MonitorAlarmQuery monthEnd(Integer monthEnd){
+		this.monthEnd = monthEnd;
+		return this;
+    }
+
+    /**
+    * 设置 增加 月
+    * @param monthIncrement
+    */
+    public MonitorAlarmQuery monthIncrement(Integer monthIncrement){
+		this.monthIncrement = monthIncrement;
+		return this;
+    }
+
+    /**
+    * 设置 月
+    * @param monthList
+    */
+    public MonitorAlarmQuery monthList(List<Integer> monthList){
+        this.monthList = monthList;
+		return this;
+        }
+
+        /**
+        * 设置 月
+        * @param monthNotList
+        */
+        public MonitorAlarmQuery monthNotList(List<Integer> monthNotList){
+        this.monthNotList = monthNotList;
+        return this;
+        }
+
+    /**
+    * 设置  日
+    * @param day
+    */
+    public MonitorAlarmQuery day(Integer day){
+	    setDay(day);
+		return this;
+    }
+	
+	 /**
+    * 设置 开始 日
+    * @param dayStart
+    */
+    public MonitorAlarmQuery dayStart(Integer dayStart){
+		this.dayStart = dayStart;
+		return this;
+    }
+
+    /**
+    * 设置 结束 日
+    * @param dayEnd
+    */
+    public MonitorAlarmQuery dayEnd(Integer dayEnd){
+		this.dayEnd = dayEnd;
+		return this;
+    }
+
+    /**
+    * 设置 增加 日
+    * @param dayIncrement
+    */
+    public MonitorAlarmQuery dayIncrement(Integer dayIncrement){
+		this.dayIncrement = dayIncrement;
+		return this;
+    }
+
+    /**
+    * 设置 日
+    * @param dayList
+    */
+    public MonitorAlarmQuery dayList(List<Integer> dayList){
+        this.dayList = dayList;
+		return this;
+        }
+
+        /**
+        * 设置 日
+        * @param dayNotList
+        */
+        public MonitorAlarmQuery dayNotList(List<Integer> dayNotList){
+        this.dayNotList = dayNotList;
+        return this;
+        }
+
+
+    /**
+    * 设置  创建人id
+    * @param createUserId
+    */
+    public MonitorAlarmQuery createUserId(Long createUserId){
+	    setCreateUserId(createUserId);
+		return this;
+    }
+	
+	 /**
+    * 设置 开始 创建人id
+    * @param createUserIdStart
+    */
+    public MonitorAlarmQuery createUserIdStart(Long createUserIdStart){
+		this.createUserIdStart = createUserIdStart;
+		return this;
+    }
+
+    /**
+    * 设置 结束 创建人id
+    * @param createUserIdEnd
+    */
+    public MonitorAlarmQuery createUserIdEnd(Long createUserIdEnd){
+		this.createUserIdEnd = createUserIdEnd;
+		return this;
+    }
+
+    /**
+    * 设置 增加 创建人id
+    * @param createUserIdIncrement
+    */
+    public MonitorAlarmQuery createUserIdIncrement(Long createUserIdIncrement){
+		this.createUserIdIncrement = createUserIdIncrement;
+		return this;
+    }
+
+    /**
+    * 设置 创建人id
+    * @param createUserIdList
+    */
+    public MonitorAlarmQuery createUserIdList(List<Long> createUserIdList){
+        this.createUserIdList = createUserIdList;
+		return this;
+        }
+
+        /**
+        * 设置 创建人id
+        * @param createUserIdNotList
+        */
+        public MonitorAlarmQuery createUserIdNotList(List<Long> createUserIdNotList){
+        this.createUserIdNotList = createUserIdNotList;
+        return this;
+        }
+
+
+    /**
+    * 设置  更新人id
+    * @param updateUserId
+    */
+    public MonitorAlarmQuery updateUserId(Long updateUserId){
+	    setUpdateUserId(updateUserId);
+		return this;
+    }
+	
+	 /**
+    * 设置 开始 更新人id
+    * @param updateUserIdStart
+    */
+    public MonitorAlarmQuery updateUserIdStart(Long updateUserIdStart){
+		this.updateUserIdStart = updateUserIdStart;
+		return this;
+    }
+
+    /**
+    * 设置 结束 更新人id
+    * @param updateUserIdEnd
+    */
+    public MonitorAlarmQuery updateUserIdEnd(Long updateUserIdEnd){
+		this.updateUserIdEnd = updateUserIdEnd;
+		return this;
+    }
+
+    /**
+    * 设置 增加 更新人id
+    * @param updateUserIdIncrement
+    */
+    public MonitorAlarmQuery updateUserIdIncrement(Long updateUserIdIncrement){
+		this.updateUserIdIncrement = updateUserIdIncrement;
+		return this;
+    }
+
+    /**
+    * 设置 更新人id
+    * @param updateUserIdList
+    */
+    public MonitorAlarmQuery updateUserIdList(List<Long> updateUserIdList){
+        this.updateUserIdList = updateUserIdList;
+		return this;
+        }
+
+        /**
+        * 设置 更新人id
+        * @param updateUserIdNotList
+        */
+        public MonitorAlarmQuery updateUserIdNotList(List<Long> updateUserIdNotList){
+        this.updateUserIdNotList = updateUserIdNotList;
+        return this;
+        }
+
+    /**
+    * 获取 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
+    * @return orConditionList
+    */
+    public List<MonitorAlarmQuery> getOrConditionList(){
+    return this.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<MonitorAlarmQuery> orConditionList){
+        this.orConditionList = orConditionList;
+    }
+
+    /**
+    * 获取 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
+    * @return andConditionList
+    */
+    public List<MonitorAlarmQuery> getAndConditionList(){
+        return this.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<MonitorAlarmQuery> andConditionList){
+        this.andConditionList = andConditionList;
+    }
+
+}
\ No newline at end of file

refined-manager/src/main/java/com/mortals/xhx/module/monitor/model/MonitorAlarmRecordEntity.java

+package com.mortals.xhx.module.monitor.model;
+
+import java.util.Date;
+import java.util.List;
+import java.util.ArrayList;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import com.mortals.framework.annotation.Excel;
+import com.mortals.framework.model.BaseEntityLong;
+import com.mortals.xhx.module.monitor.model.vo.MonitorAlarmRecordVo;
+/**
+* 监测预警记录详细记录实体对象
+*
+* @author zxfei
+* @date 2023-04-15
+*/
+
+public class MonitorAlarmRecordEntity extends MonitorAlarmRecordVo {
+    private static final long serialVersionUID = 1L;
+
+    /**
+    * 告警Id
+    */
+    private Long alarmId;
+    /**
+    * 预约业务
+    */
+    @Excel(name = "预约业务")
+    private String reservationService;
+    /**
+    * 预约编号
+    */
+    @Excel(name = "预约编号")
+    private String reservationNumber;
+    /**
+    * 监测时间
+    */
+    @Excel(name = "监测时间", width = 30, dateFormat = "yyyy-MM-dd")
+    private Date monitorTime;
+    /**
+    * 监测设备
+    */
+    @Excel(name = "监测设备")
+    private Long monitorDeviceId;
+    /**
+    * 监测设备名称
+    */
+    @Excel(name = "监测设备名称")
+    private String monitorDevice;
+    /**
+    * 签到方式(0.自动签到，1.手动签到)
+    */
+    @Excel(name = "签到方式", readConverterExp = "0=自动签到,1=手动签到")
+    private Integer checkInMethod;
+    /**
+    * 监测凭证
+    */
+    @Excel(name = "监测凭证")
+    private String monitorCertificate;
+    /**
+    * 相对图片pic
+    */
+    private String picUri;
+    /**
+    * 图片资源唯一标识
+    */
+    private String serverIndexCode;
+
+
+
+    public MonitorAlarmRecordEntity(){}
+    /**
+    * 获取 告警Id
+    * @return Long
+    */
+    public Long getAlarmId(){
+        return alarmId;
+    }
+    /**
+    * 设置 告警Id
+    * @param alarmId
+    */
+    public void setAlarmId(Long alarmId){
+        this.alarmId = alarmId;
+    }
+    /**
+    * 获取 预约业务
+    * @return String
+    */
+    public String getReservationService(){
+        return reservationService;
+    }
+    /**
+    * 设置 预约业务
+    * @param reservationService
+    */
+    public void setReservationService(String reservationService){
+        this.reservationService = reservationService;
+    }
+    /**
+    * 获取 预约编号
+    * @return String
+    */
+    public String getReservationNumber(){
+        return reservationNumber;
+    }
+    /**
+    * 设置 预约编号
+    * @param reservationNumber
+    */
+    public void setReservationNumber(String reservationNumber){
+        this.reservationNumber = reservationNumber;
+    }
+    /**
+    * 获取 监测时间
+    * @return Date
+    */
+    public Date getMonitorTime(){
+        return monitorTime;
+    }
+    /**
+    * 设置 监测时间
+    * @param monitorTime
+    */
+    public void setMonitorTime(Date monitorTime){
+        this.monitorTime = monitorTime;
+    }
+    /**
+    * 获取 监测设备
+    * @return Long
+    */
+    public Long getMonitorDeviceId(){
+        return monitorDeviceId;
+    }
+    /**
+    * 设置 监测设备
+    * @param monitorDeviceId
+    */
+    public void setMonitorDeviceId(Long monitorDeviceId){
+        this.monitorDeviceId = monitorDeviceId;
+    }
+    /**
+    * 获取 监测设备名称
+    * @return String
+    */
+    public String getMonitorDevice(){
+        return monitorDevice;
+    }
+    /**
+    * 设置 监测设备名称
+    * @param monitorDevice
+    */
+    public void setMonitorDevice(String monitorDevice){
+        this.monitorDevice = monitorDevice;
+    }
+    /**
+    * 获取 签到方式(0.自动签到，1.手动签到)
+    * @return Integer
+    */
+    public Integer getCheckInMethod(){
+        return checkInMethod;
+    }
+    /**
+    * 设置 签到方式(0.自动签到，1.手动签到)
+    * @param checkInMethod
+    */
+    public void setCheckInMethod(Integer checkInMethod){
+        this.checkInMethod = checkInMethod;
+    }
+    /**
+    * 获取 监测凭证
+    * @return String
+    */
+    public String getMonitorCertificate(){
+        return monitorCertificate;
+    }
+    /**
+    * 设置 监测凭证
+    * @param monitorCertificate
+    */
+    public void setMonitorCertificate(String monitorCertificate){
+        this.monitorCertificate = monitorCertificate;
+    }
+    /**
+    * 获取 相对图片pic
+    * @return String
+    */
+    public String getPicUri(){
+        return picUri;
+    }
+    /**
+    * 设置 相对图片pic
+    * @param picUri
+    */
+    public void setPicUri(String picUri){
+        this.picUri = picUri;
+    }
+    /**
+    * 获取 图片资源唯一标识
+    * @return String
+    */
+    public String getServerIndexCode(){
+        return serverIndexCode;
+    }
+    /**
+    * 设置 图片资源唯一标识
+    * @param serverIndexCode
+    */
+    public void setServerIndexCode(String serverIndexCode){
+        this.serverIndexCode = serverIndexCode;
+    }
+
+
+
+
+    @Override
+    public int hashCode() {
+         return this.getId().hashCode();
+    }
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == null) return false;
+        if (obj instanceof MonitorAlarmRecordEntity) {
+            MonitorAlarmRecordEntity tmp = (MonitorAlarmRecordEntity) obj;
+            if (this.getId() == tmp.getId()) {
+                 return true;
+            }
+        }
+        return false;
+    }
+
+    public String toString(){
+        StringBuilder sb = new StringBuilder("");
+        sb.append(",alarmId:").append(getAlarmId());
+        sb.append(",reservationService:").append(getReservationService());
+        sb.append(",reservationNumber:").append(getReservationNumber());
+        sb.append(",monitorTime:").append(getMonitorTime());
+        sb.append(",monitorDeviceId:").append(getMonitorDeviceId());
+        sb.append(",monitorDevice:").append(getMonitorDevice());
+        sb.append(",checkInMethod:").append(getCheckInMethod());
+        sb.append(",monitorCertificate:").append(getMonitorCertificate());
+        sb.append(",picUri:").append(getPicUri());
+        sb.append(",serverIndexCode:").append(getServerIndexCode());
+        return sb.toString();
+    }
+
+    public void initAttrValue(){
+
+            this.alarmId = null;
+
+            this.reservationService = "";
+
+            this.reservationNumber = "";
+
+            this.monitorTime = null;
+
+            this.monitorDeviceId = null;
+
+            this.monitorDevice = "";
+
+            this.checkInMethod = 0;
+
+            this.monitorCertificate = "";
+
+            this.picUri = "";
+
+            this.serverIndexCode = "";
+    }
+}
\ No newline at end of file

refined-manager/src/main/java/com/mortals/xhx/module/monitor/model/MonitorAlarmRecordQuery.java

+package com.mortals.xhx.module.monitor.model;
+
+import java.util.Date;
+import java.util.List;
+import com.mortals.xhx.module.monitor.model.MonitorAlarmRecordEntity;
+/**
+* 监测预警记录详细记录查询对象
+*
+* @author zxfei
+* @date 2023-04-15
+*/
+public class MonitorAlarmRecordQuery extends MonitorAlarmRecordEntity {
+    /** 开始 主键ID，主键，自增长 */
+    private Long idStart;
+
+    /** 结束 主键ID，主键，自增长 */
+    private Long idEnd;
+
+    /** 增加 主键ID，主键，自增长 */
+    private Long idIncrement;
+
+    /** 主键ID，主键，自增长列表 */
+    private List <Long> idList;
+
+    /** 主键ID，主键，自增长排除列表 */
+    private List <Long> idNotList;
+
+    /** 开始 告警Id */
+    private Long alarmIdStart;
+
+    /** 结束 告警Id */
+    private Long alarmIdEnd;
+
+    /** 增加 告警Id */
+    private Long alarmIdIncrement;
+
+    /** 告警Id列表 */
+    private List <Long> alarmIdList;
+
+    /** 告警Id排除列表 */
+    private List <Long> alarmIdNotList;
+
+    /** 预约业务 */
+    private List<String> reservationServiceList;
+
+    /** 预约业务排除列表 */
+    private List <String> reservationServiceNotList;
+    /** 预约编号 */
+    private List<String> reservationNumberList;
+
+    /** 预约编号排除列表 */
+    private List <String> reservationNumberNotList;
+    /** 开始 监测时间 */
+    private String monitorTimeStart;
+
+    /** 结束 监测时间 */
+    private String monitorTimeEnd;
+
+    /** 开始 监测设备 */
+    private Long monitorDeviceIdStart;
+
+    /** 结束 监测设备 */
+    private Long monitorDeviceIdEnd;
+
+    /** 增加 监测设备 */
+    private Long monitorDeviceIdIncrement;
+
+    /** 监测设备列表 */
+    private List <Long> monitorDeviceIdList;
+
+    /** 监测设备排除列表 */
+    private List <Long> monitorDeviceIdNotList;
+
+    /** 监测设备名称 */
+    private List<String> monitorDeviceList;
+
+    /** 监测设备名称排除列表 */
+    private List <String> monitorDeviceNotList;
+    /** 开始 签到方式(0.自动签到，1.手动签到) */
+    private Integer checkInMethodStart;
+
+    /** 结束 签到方式(0.自动签到，1.手动签到) */
+    private Integer checkInMethodEnd;
+
+    /** 增加 签到方式(0.自动签到，1.手动签到) */
+    private Integer checkInMethodIncrement;
+
+    /** 签到方式(0.自动签到，1.手动签到)列表 */
+    private List <Integer> checkInMethodList;
+
+    /** 签到方式(0.自动签到，1.手动签到)排除列表 */
+    private List <Integer> checkInMethodNotList;
+
+    /** 监测凭证 */
+    private List<String> monitorCertificateList;
+
+    /** 监测凭证排除列表 */
+    private List <String> monitorCertificateNotList;
+    /** 相对图片pic */
+    private List<String> picUriList;
+
+    /** 相对图片pic排除列表 */
+    private List <String> picUriNotList;
+    /** 图片资源唯一标识 */
+    private List<String> serverIndexCodeList;
+
+    /** 图片资源唯一标识排除列表 */
+    private List <String> serverIndexCodeNotList;
+    /** 开始 创建时间 */
+    private String createTimeStart;
+
+    /** 结束 创建时间 */
+    private String createTimeEnd;
+
+    /** 开始 创建人id */
+    private Long createUserIdStart;
+
+    /** 结束 创建人id */
+    private Long createUserIdEnd;
+
+    /** 增加 创建人id */
+    private Long createUserIdIncrement;
+
+    /** 创建人id列表 */
+    private List <Long> createUserIdList;
+
+    /** 创建人id排除列表 */
+    private List <Long> createUserIdNotList;
+
+    /** 开始 更新时间 */
+    private String updateTimeStart;
+
+    /** 结束 更新时间 */
+    private String updateTimeEnd;
+
+    /** 开始 更新人id */
+    private Long updateUserIdStart;
+
+    /** 结束 更新人id */
+    private Long updateUserIdEnd;
+
+    /** 增加 更新人id */
+    private Long updateUserIdIncrement;
+
+    /** 更新人id列表 */
+    private List <Long> updateUserIdList;
+
+    /** 更新人id排除列表 */
+    private List <Long> updateUserIdNotList;
+
+    /** OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4) */
+    private List<MonitorAlarmRecordQuery> orConditionList;
+
+    /** AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4) */
+    private List<MonitorAlarmRecordQuery> andConditionList;
+
+    public MonitorAlarmRecordQuery(){}
+
+    /**
+    * 获取 开始 主键ID，主键，自增长
+    * @return idStart
+    */
+    public Long getIdStart(){
+        return this.idStart;
+    }
+
+    /**
+    * 设置 开始 主键ID，主键，自增长
+    * @param idStart
+    */
+    public void setIdStart(Long idStart){
+        this.idStart = idStart;
+    }
+
+    /**
+    * 获取 结束 主键ID，主键，自增长
+    * @return $idEnd
+    */
+    public Long getIdEnd(){
+        return this.idEnd;
+    }
+
+    /**
+    * 设置 结束 主键ID，主键，自增长
+    * @param idEnd
+    */
+    public void setIdEnd(Long idEnd){
+        this.idEnd = idEnd;
+    }
+
+    /**
+    * 获取 增加 主键ID，主键，自增长
+    * @return idIncrement
+    */
+    public Long getIdIncrement(){
+        return this.idIncrement;
+    }
+
+    /**
+    * 设置 增加 主键ID，主键，自增长
+    * @param idIncrement
+    */
+    public void setIdIncrement(Long idIncrement){
+        this.idIncrement = idIncrement;
+    }
+
+    /**
+    * 获取 主键ID，主键，自增长
+    * @return idList
+    */
+    public List<Long> getIdList(){
+        return this.idList;
+    }
+
+    /**
+    * 设置 主键ID，主键，自增长
+    * @param idList
+    */
+    public void setIdList(List<Long> idList){
+        this.idList = idList;
+    }
+
+    /**
+    * 获取 主键ID，主键，自增长
+    * @return idNotList
+    */
+    public List<Long> getIdNotList(){
+        return this.idNotList;
+    }
+
+    /**
+    * 设置 主键ID，主键，自增长
+    * @param idNotList
+    */
+    public void setIdNotList(List<Long> idNotList){
+        this.idNotList = idNotList;
+    }
+
+
+    /**
+    * 获取 开始 告警Id
+    * @return alarmIdStart
+    */
+    public Long getAlarmIdStart(){
+        return this.alarmIdStart;
+    }
+
+    /**
+    * 设置 开始 告警Id
+    * @param alarmIdStart
+    */
+    public void setAlarmIdStart(Long alarmIdStart){
+        this.alarmIdStart = alarmIdStart;
+    }
+
+    /**
+    * 获取 结束 告警Id
+    * @return $alarmIdEnd
+    */
+    public Long getAlarmIdEnd(){
+        return this.alarmIdEnd;
+    }
+
+    /**
+    * 设置 结束 告警Id
+    * @param alarmIdEnd
+    */
+    public void setAlarmIdEnd(Long alarmIdEnd){
+        this.alarmIdEnd = alarmIdEnd;
+    }
+
+    /**
+    * 获取 增加 告警Id
+    * @return alarmIdIncrement
+    */
+    public Long getAlarmIdIncrement(){
+        return this.alarmIdIncrement;
+    }
+
+    /**
+    * 设置 增加 告警Id
+    * @param alarmIdIncrement
+    */
+    public void setAlarmIdIncrement(Long alarmIdIncrement){
+        this.alarmIdIncrement = alarmIdIncrement;
+    }
+
+    /**
+    * 获取 告警Id
+    * @return alarmIdList
+    */
+    public List<Long> getAlarmIdList(){
+        return this.alarmIdList;
+    }
+
+    /**
+    * 设置 告警Id
+    * @param alarmIdList
+    */
+    public void setAlarmIdList(List<Long> alarmIdList){
+        this.alarmIdList = alarmIdList;
+    }
+
+    /**
+    * 获取 告警Id
+    * @return alarmIdNotList
+    */
+    public List<Long> getAlarmIdNotList(){
+        return this.alarmIdNotList;
+    }
+
+    /**
+    * 设置 告警Id
+    * @param alarmIdNotList
+    */
+    public void setAlarmIdNotList(List<Long> alarmIdNotList){
+        this.alarmIdNotList = alarmIdNotList;
+    }
+
+
+    /**
+    * 获取 预约业务
+    * @return reservationServiceList
+    */
+    public List<String> getReservationServiceList(){
+        return this.reservationServiceList;
+    }
+
+    /**
+    * 设置 预约业务
+    * @param reservationServiceList
+    */
+    public void setReservationServiceList(List<String> reservationServiceList){
+        this.reservationServiceList = reservationServiceList;
+    }
+
+    /**
+    * 获取 预约业务
+    * @return reservationServiceNotList
+    */
+    public List<String> getReservationServiceNotList(){
+        return this.reservationServiceNotList;
+    }
+
+    /**
+    * 设置 预约业务
+    * @param reservationServiceNotList
+    */
+    public void setReservationServiceNotList(List<String> reservationServiceNotList){
+        this.reservationServiceNotList = reservationServiceNotList;
+    }
+
+    /**
+    * 获取 预约编号
+    * @return reservationNumberList
+    */
+    public List<String> getReservationNumberList(){
+        return this.reservationNumberList;
+    }
+
+    /**
+    * 设置 预约编号
+    * @param reservationNumberList
+    */
+    public void setReservationNumberList(List<String> reservationNumberList){
+        this.reservationNumberList = reservationNumberList;
+    }
+
+    /**
+    * 获取 预约编号
+    * @return reservationNumberNotList
+    */
+    public List<String> getReservationNumberNotList(){
+        return this.reservationNumberNotList;
+    }
+
+    /**
+    * 设置 预约编号
+    * @param reservationNumberNotList
+    */
+    public void setReservationNumberNotList(List<String> reservationNumberNotList){
+        this.reservationNumberNotList = reservationNumberNotList;
+    }
+
+    /**
+    * 获取 开始 监测时间
+    * @return monitorTimeStart
+    */
+    public String getMonitorTimeStart(){
+        return this.monitorTimeStart;
+    }
+
+    /**
+    * 设置 开始 监测时间
+    * @param monitorTimeStart
+    */
+    public void setMonitorTimeStart(String monitorTimeStart){
+        this.monitorTimeStart = monitorTimeStart;
+    }
+
+    /**
+    * 获取 结束 监测时间
+    * @return monitorTimeEnd
+    */
+    public String getMonitorTimeEnd(){
+        return this.monitorTimeEnd;
+    }
+
+    /**
+    * 设置 结束 监测时间
+    * @param monitorTimeEnd
+    */
+    public void setMonitorTimeEnd(String monitorTimeEnd){
+        this.monitorTimeEnd = monitorTimeEnd;
+    }
+
+    /**
+    * 获取 开始 监测设备
+    * @return monitorDeviceIdStart
+    */
+    public Long getMonitorDeviceIdStart(){
+        return this.monitorDeviceIdStart;
+    }
+
+    /**
+    * 设置 开始 监测设备
+    * @param monitorDeviceIdStart
+    */
+    public void setMonitorDeviceIdStart(Long monitorDeviceIdStart){
+        this.monitorDeviceIdStart = monitorDeviceIdStart;
+    }
+
+    /**
+    * 获取 结束 监测设备
+    * @return $monitorDeviceIdEnd
+    */
+    public Long getMonitorDeviceIdEnd(){
+        return this.monitorDeviceIdEnd;
+    }
+
+    /**
+    * 设置 结束 监测设备
+    * @param monitorDeviceIdEnd
+    */
+    public void setMonitorDeviceIdEnd(Long monitorDeviceIdEnd){
+        this.monitorDeviceIdEnd = monitorDeviceIdEnd;
+    }
+
+    /**
+    * 获取 增加 监测设备
+    * @return monitorDeviceIdIncrement
+    */
+    public Long getMonitorDeviceIdIncrement(){
+        return this.monitorDeviceIdIncrement;
+    }
+
+    /**
+    * 设置 增加 监测设备
+    * @param monitorDeviceIdIncrement
+    */
+    public void setMonitorDeviceIdIncrement(Long monitorDeviceIdIncrement){
+        this.monitorDeviceIdIncrement = monitorDeviceIdIncrement;
+    }
+
+    /**
+    * 获取 监测设备
+    * @return monitorDeviceIdList
+    */
+    public List<Long> getMonitorDeviceIdList(){
+        return this.monitorDeviceIdList;
+    }
+
+    /**
+    * 设置 监测设备
+    * @param monitorDeviceIdList
+    */
+    public void setMonitorDeviceIdList(List<Long> monitorDeviceIdList){
+        this.monitorDeviceIdList = monitorDeviceIdList;
+    }
+
+    /**
+    * 获取 监测设备
+    * @return monitorDeviceIdNotList
+    */
+    public List<Long> getMonitorDeviceIdNotList(){
+        return this.monitorDeviceIdNotList;
+    }
+
+    /**
+    * 设置 监测设备
+    * @param monitorDeviceIdNotList
+    */
+    public void setMonitorDeviceIdNotList(List<Long> monitorDeviceIdNotList){
+        this.monitorDeviceIdNotList = monitorDeviceIdNotList;
+    }
+
+
+    /**
+    * 获取 监测设备名称
+    * @return monitorDeviceList
+    */
+    public List<String> getMonitorDeviceList(){
+        return this.monitorDeviceList;
+    }
+
+    /**
+    * 设置 监测设备名称
+    * @param monitorDeviceList
+    */
+    public void setMonitorDeviceList(List<String> monitorDeviceList){
+        this.monitorDeviceList = monitorDeviceList;
+    }
+
+    /**
+    * 获取 监测设备名称
+    * @return monitorDeviceNotList
+    */
+    public List<String> getMonitorDeviceNotList(){
+        return this.monitorDeviceNotList;
+    }
+
+    /**
+    * 设置 监测设备名称
+    * @param monitorDeviceNotList
+    */
+    public void setMonitorDeviceNotList(List<String> monitorDeviceNotList){
+        this.monitorDeviceNotList = monitorDeviceNotList;
+    }
+
+    /**
+    * 获取 开始 签到方式(0.自动签到，1.手动签到)
+    * @return checkInMethodStart
+    */
+    public Integer getCheckInMethodStart(){
+        return this.checkInMethodStart;
+    }
+
+    /**
+    * 设置 开始 签到方式(0.自动签到，1.手动签到)
+    * @param checkInMethodStart
+    */
+    public void setCheckInMethodStart(Integer checkInMethodStart){
+        this.checkInMethodStart = checkInMethodStart;
+    }
+
+    /**
+    * 获取 结束 签到方式(0.自动签到，1.手动签到)
+    * @return $checkInMethodEnd
+    */
+    public Integer getCheckInMethodEnd(){
+        return this.checkInMethodEnd;
+    }
+
+    /**
+    * 设置 结束 签到方式(0.自动签到，1.手动签到)
+    * @param checkInMethodEnd
+    */
+    public void setCheckInMethodEnd(Integer checkInMethodEnd){
+        this.checkInMethodEnd = checkInMethodEnd;
+    }
+
+    /**
+    * 获取 增加 签到方式(0.自动签到，1.手动签到)
+    * @return checkInMethodIncrement
+    */
+    public Integer getCheckInMethodIncrement(){
+        return this.checkInMethodIncrement;
+    }
+
+    /**
+    * 设置 增加 签到方式(0.自动签到，1.手动签到)
+    * @param checkInMethodIncrement
+    */
+    public void setCheckInMethodIncrement(Integer checkInMethodIncrement){
+        this.checkInMethodIncrement = checkInMethodIncrement;
+    }
+
+    /**
+    * 获取 签到方式(0.自动签到，1.手动签到)
+    * @return checkInMethodList
+    */
+    public List<Integer> getCheckInMethodList(){
+        return this.checkInMethodList;
+    }
+
+    /**
+    * 设置 签到方式(0.自动签到，1.手动签到)
+    * @param checkInMethodList
+    */
+    public void setCheckInMethodList(List<Integer> checkInMethodList){
+        this.checkInMethodList = checkInMethodList;
+    }
+
+    /**
+    * 获取 签到方式(0.自动签到，1.手动签到)
+    * @return checkInMethodNotList
+    */
+    public List<Integer> getCheckInMethodNotList(){
+        return this.checkInMethodNotList;
+    }
+
+    /**
+    * 设置 签到方式(0.自动签到，1.手动签到)
+    * @param checkInMethodNotList
+    */
+    public void setCheckInMethodNotList(List<Integer> checkInMethodNotList){
+        this.checkInMethodNotList = checkInMethodNotList;
+    }
+
+
+    /**
+    * 获取 监测凭证
+    * @return monitorCertificateList
+    */
+    public List<String> getMonitorCertificateList(){
+        return this.monitorCertificateList;
+    }
+
+    /**
+    * 设置 监测凭证
+    * @param monitorCertificateList
+    */
+    public void setMonitorCertificateList(List<String> monitorCertificateList){
+        this.monitorCertificateList = monitorCertificateList;
+    }
+
+    /**
+    * 获取 监测凭证
+    * @return monitorCertificateNotList
+    */
+    public List<String> getMonitorCertificateNotList(){
+        return this.monitorCertificateNotList;
+    }
+
+    /**
+    * 设置 监测凭证
+    * @param monitorCertificateNotList
+    */
+    public void setMonitorCertificateNotList(List<String> monitorCertificateNotList){
+        this.monitorCertificateNotList = monitorCertificateNotList;
+    }
+
+    /**
+    * 获取 相对图片pic
+    * @return picUriList
+    */
+    public List<String> getPicUriList(){
+        return this.picUriList;
+    }
+
+    /**
+    * 设置 相对图片pic
+    * @param picUriList
+    */
+    public void setPicUriList(List<String> picUriList){
+        this.picUriList = picUriList;
+    }
+
+    /**
+    * 获取 相对图片pic
+    * @return picUriNotList
+    */
+    public List<String> getPicUriNotList(){
+        return this.picUriNotList;
+    }
+
+    /**
+    * 设置 相对图片pic
+    * @param picUriNotList
+    */
+    public void setPicUriNotList(List<String> picUriNotList){
+        this.picUriNotList = picUriNotList;
+    }
+
+    /**
+    * 获取 图片资源唯一标识
+    * @return serverIndexCodeList
+    */
+    public List<String> getServerIndexCodeList(){
+        return this.serverIndexCodeList;
+    }
+
+    /**
+    * 设置 图片资源唯一标识
+    * @param serverIndexCodeList
+    */
+    public void setServerIndexCodeList(List<String> serverIndexCodeList){
+        this.serverIndexCodeList = serverIndexCodeList;
+    }
+
+    /**
+    * 获取 图片资源唯一标识
+    * @return serverIndexCodeNotList
+    */
+    public List<String> getServerIndexCodeNotList(){
+        return this.serverIndexCodeNotList;
+    }
+
+    /**
+    * 设置 图片资源唯一标识
+    * @param serverIndexCodeNotList
+    */
+    public void setServerIndexCodeNotList(List<String> serverIndexCodeNotList){
+        this.serverIndexCodeNotList = serverIndexCodeNotList;
+    }
+
+    /**
+    * 获取 开始 创建时间
+    * @return createTimeStart
+    */
+    public String getCreateTimeStart(){
+        return this.createTimeStart;
+    }
+
+    /**
+    * 设置 开始 创建时间
+    * @param createTimeStart
+    */
+    public void setCreateTimeStart(String createTimeStart){
+        this.createTimeStart = createTimeStart;
+    }
+
+    /**
+    * 获取 结束 创建时间
+    * @return createTimeEnd
+    */
+    public String getCreateTimeEnd(){
+        return this.createTimeEnd;
+    }
+
+    /**
+    * 设置 结束 创建时间
+    * @param createTimeEnd
+    */
+    public void setCreateTimeEnd(String createTimeEnd){
+        this.createTimeEnd = createTimeEnd;
+    }
+
+    /**
+    * 获取 开始 创建人id
+    * @return createUserIdStart
+    */
+    public Long getCreateUserIdStart(){
+        return this.createUserIdStart;
+    }
+
+    /**
+    * 设置 开始 创建人id
+    * @param createUserIdStart
+    */
+    public void setCreateUserIdStart(Long createUserIdStart){
+        this.createUserIdStart = createUserIdStart;
+    }
+
+    /**
+    * 获取 结束 创建人id
+    * @return $createUserIdEnd
+    */
+    public Long getCreateUserIdEnd(){
+        return this.createUserIdEnd;
+    }
+
+    /**
+    * 设置 结束 创建人id
+    * @param createUserIdEnd
+    */
+    public void setCreateUserIdEnd(Long createUserIdEnd){
+        this.createUserIdEnd = createUserIdEnd;
+    }
+
+    /**
+    * 获取 增加 创建人id
+    * @return createUserIdIncrement
+    */
+    public Long getCreateUserIdIncrement(){
+        return this.createUserIdIncrement;
+    }
+
+    /**
+    * 设置 增加 创建人id
+    * @param createUserIdIncrement
+    */
+    public void setCreateUserIdIncrement(Long createUserIdIncrement){
+        this.createUserIdIncrement = createUserIdIncrement;
+    }
+
+    /**
+    * 获取 创建人id
+    * @return createUserIdList
+    */
+    public List<Long> getCreateUserIdList(){
+        return this.createUserIdList;
+    }
+
+    /**
+    * 设置 创建人id
+    * @param createUserIdList
+    */
+    public void setCreateUserIdList(List<Long> createUserIdList){
+        this.createUserIdList = createUserIdList;
+    }
+
+    /**
+    * 获取 创建人id
+    * @return createUserIdNotList
+    */
+    public List<Long> getCreateUserIdNotList(){
+        return this.createUserIdNotList;
+    }
+
+    /**
+    * 设置 创建人id
+    * @param createUserIdNotList
+    */
+    public void setCreateUserIdNotList(List<Long> createUserIdNotList){
+        this.createUserIdNotList = createUserIdNotList;
+    }
+
+
+    /**
+    * 获取 开始 更新时间
+    * @return updateTimeStart
+    */
+    public String getUpdateTimeStart(){
+        return this.updateTimeStart;
+    }
+
+    /**
+    * 设置 开始 更新时间
+    * @param updateTimeStart
+    */
+    public void setUpdateTimeStart(String updateTimeStart){
+        this.updateTimeStart = updateTimeStart;
+    }
+
+    /**
+    * 获取 结束 更新时间
+    * @return updateTimeEnd
+    */
+    public String getUpdateTimeEnd(){
+        return this.updateTimeEnd;
+    }
+
+    /**
+    * 设置 结束 更新时间
+    * @param updateTimeEnd
+    */
+    public void setUpdateTimeEnd(String updateTimeEnd){
+        this.updateTimeEnd = updateTimeEnd;
+    }
+
+    /**
+    * 获取 开始 更新人id
+    * @return updateUserIdStart
+    */
+    public Long getUpdateUserIdStart(){
+        return this.updateUserIdStart;
+    }
+
+    /**
+    * 设置 开始 更新人id
+    * @param updateUserIdStart
+    */
+    public void setUpdateUserIdStart(Long updateUserIdStart){
+        this.updateUserIdStart = updateUserIdStart;
+    }
+
+    /**
+    * 获取 结束 更新人id
+    * @return $updateUserIdEnd
+    */
+    public Long getUpdateUserIdEnd(){
+        return this.updateUserIdEnd;
+    }
+
+    /**
+    * 设置 结束 更新人id
+    * @param updateUserIdEnd
+    */
+    public void setUpdateUserIdEnd(Long updateUserIdEnd){
+        this.updateUserIdEnd = updateUserIdEnd;
+    }
+
+    /**
+    * 获取 增加 更新人id
+    * @return updateUserIdIncrement
+    */
+    public Long getUpdateUserIdIncrement(){
+        return this.updateUserIdIncrement;
+    }
+
+    /**
+    * 设置 增加 更新人id
+    * @param updateUserIdIncrement
+    */
+    public void setUpdateUserIdIncrement(Long updateUserIdIncrement){
+        this.updateUserIdIncrement = updateUserIdIncrement;
+    }
+
+    /**
+    * 获取 更新人id
+    * @return updateUserIdList
+    */
+    public List<Long> getUpdateUserIdList(){
+        return this.updateUserIdList;
+    }
+
+    /**
+    * 设置 更新人id
+    * @param updateUserIdList
+    */
+    public void setUpdateUserIdList(List<Long> updateUserIdList){
+        this.updateUserIdList = updateUserIdList;
+    }
+
+    /**
+    * 获取 更新人id
+    * @return updateUserIdNotList
+    */
+    public List<Long> getUpdateUserIdNotList(){
+        return this.updateUserIdNotList;
+    }
+
+    /**
+    * 设置 更新人id
+    * @param updateUserIdNotList
+    */
+    public void setUpdateUserIdNotList(List<Long> updateUserIdNotList){
+        this.updateUserIdNotList = updateUserIdNotList;
+    }
+
+
+    /**
+    * 设置  主键ID，主键，自增长
+    * @param id
+    */
+    public MonitorAlarmRecordQuery id(Long id){
+	    setId(id);
+		return this;
+    }
+	
+	 /**
+    * 设置 开始 主键ID，主键，自增长
+    * @param idStart
+    */
+    public MonitorAlarmRecordQuery idStart(Long idStart){
+		this.idStart = idStart;
+		return this;
+    }
+
+    /**
+    * 设置 结束 主键ID，主键，自增长
+    * @param idEnd
+    */
+    public MonitorAlarmRecordQuery idEnd(Long idEnd){
+		this.idEnd = idEnd;
+		return this;
+    }
+
+    /**
+    * 设置 增加 主键ID，主键，自增长
+    * @param idIncrement
+    */
+    public MonitorAlarmRecordQuery idIncrement(Long idIncrement){
+		this.idIncrement = idIncrement;
+		return this;
+    }
+
+    /**
+    * 设置 主键ID，主键，自增长
+    * @param idList
+    */
+    public MonitorAlarmRecordQuery idList(List<Long> idList){
+        this.idList = idList;
+		return this;
+        }
+
+        /**
+        * 设置 主键ID，主键，自增长
+        * @param idNotList
+        */
+        public MonitorAlarmRecordQuery idNotList(List<Long> idNotList){
+        this.idNotList = idNotList;
+        return this;
+        }
+
+    /**
+    * 设置  告警Id
+    * @param alarmId
+    */
+    public MonitorAlarmRecordQuery alarmId(Long alarmId){
+	    setAlarmId(alarmId);
+		return this;
+    }
+	
+	 /**
+    * 设置 开始 告警Id
+    * @param alarmIdStart
+    */
+    public MonitorAlarmRecordQuery alarmIdStart(Long alarmIdStart){
+		this.alarmIdStart = alarmIdStart;
+		return this;
+    }
+
+    /**
+    * 设置 结束 告警Id
+    * @param alarmIdEnd
+    */
+    public MonitorAlarmRecordQuery alarmIdEnd(Long alarmIdEnd){
+		this.alarmIdEnd = alarmIdEnd;
+		return this;
+    }
+
+    /**
+    * 设置 增加 告警Id
+    * @param alarmIdIncrement
+    */
+    public MonitorAlarmRecordQuery alarmIdIncrement(Long alarmIdIncrement){
+		this.alarmIdIncrement = alarmIdIncrement;
+		return this;
+    }
+
+    /**
+    * 设置 告警Id
+    * @param alarmIdList
+    */
+    public MonitorAlarmRecordQuery alarmIdList(List<Long> alarmIdList){
+        this.alarmIdList = alarmIdList;
+		return this;
+        }
+
+        /**
+        * 设置 告警Id
+        * @param alarmIdNotList
+        */
+        public MonitorAlarmRecordQuery alarmIdNotList(List<Long> alarmIdNotList){
+        this.alarmIdNotList = alarmIdNotList;
+        return this;
+        }
+
+
+	/**
+    * 设置 预约业务
+    * @param reservationService
+    */
+    public MonitorAlarmRecordQuery reservationService(String reservationService){
+        setReservationService(reservationService);
+		return this;
+    }
+
+    /**
+    * 设置 预约业务
+    * @param reservationServiceList
+    */
+    public MonitorAlarmRecordQuery reservationServiceList(List<String> reservationServiceList){
+        this.reservationServiceList = reservationServiceList;
+		return this;
+    }
+
+
+	/**
+    * 设置 预约编号
+    * @param reservationNumber
+    */
+    public MonitorAlarmRecordQuery reservationNumber(String reservationNumber){
+        setReservationNumber(reservationNumber);
+		return this;
+    }
+
+    /**
+    * 设置 预约编号
+    * @param reservationNumberList
+    */
+    public MonitorAlarmRecordQuery reservationNumberList(List<String> reservationNumberList){
+        this.reservationNumberList = reservationNumberList;
+		return this;
+    }
+
+
+    /**
+    * 设置  监测设备
+    * @param monitorDeviceId
+    */
+    public MonitorAlarmRecordQuery monitorDeviceId(Long monitorDeviceId){
+	    setMonitorDeviceId(monitorDeviceId);
+		return this;
+    }
+	
+	 /**
+    * 设置 开始 监测设备
+    * @param monitorDeviceIdStart
+    */
+    public MonitorAlarmRecordQuery monitorDeviceIdStart(Long monitorDeviceIdStart){
+		this.monitorDeviceIdStart = monitorDeviceIdStart;
+		return this;
+    }
+
+    /**
+    * 设置 结束 监测设备
+    * @param monitorDeviceIdEnd
+    */
+    public MonitorAlarmRecordQuery monitorDeviceIdEnd(Long monitorDeviceIdEnd){
+		this.monitorDeviceIdEnd = monitorDeviceIdEnd;
+		return this;
+    }
+
+    /**
+    * 设置 增加 监测设备
+    * @param monitorDeviceIdIncrement
+    */
+    public MonitorAlarmRecordQuery monitorDeviceIdIncrement(Long monitorDeviceIdIncrement){
+		this.monitorDeviceIdIncrement = monitorDeviceIdIncrement;
+		return this;
+    }
+
+    /**
+    * 设置 监测设备
+    * @param monitorDeviceIdList
+    */
+    public MonitorAlarmRecordQuery monitorDeviceIdList(List<Long> monitorDeviceIdList){
+        this.monitorDeviceIdList = monitorDeviceIdList;
+		return this;
+        }
+
+        /**
+        * 设置 监测设备
+        * @param monitorDeviceIdNotList
+        */
+        public MonitorAlarmRecordQuery monitorDeviceIdNotList(List<Long> monitorDeviceIdNotList){
+        this.monitorDeviceIdNotList = monitorDeviceIdNotList;
+        return this;
+        }
+
+
+	/**
+    * 设置 监测设备名称
+    * @param monitorDevice
+    */
+    public MonitorAlarmRecordQuery monitorDevice(String monitorDevice){
+        setMonitorDevice(monitorDevice);
+		return this;
+    }
+
+    /**
+    * 设置 监测设备名称
+    * @param monitorDeviceList
+    */
+    public MonitorAlarmRecordQuery monitorDeviceList(List<String> monitorDeviceList){
+        this.monitorDeviceList = monitorDeviceList;
+		return this;
+    }
+
+    /**
+    * 设置  签到方式(0.自动签到，1.手动签到)
+    * @param checkInMethod
+    */
+    public MonitorAlarmRecordQuery checkInMethod(Integer checkInMethod){
+	    setCheckInMethod(checkInMethod);
+		return this;
+    }
+	
+	 /**
+    * 设置 开始 签到方式(0.自动签到，1.手动签到)
+    * @param checkInMethodStart
+    */
+    public MonitorAlarmRecordQuery checkInMethodStart(Integer checkInMethodStart){
+		this.checkInMethodStart = checkInMethodStart;
+		return this;
+    }
+
+    /**
+    * 设置 结束 签到方式(0.自动签到，1.手动签到)
+    * @param checkInMethodEnd
+    */
+    public MonitorAlarmRecordQuery checkInMethodEnd(Integer checkInMethodEnd){
+		this.checkInMethodEnd = checkInMethodEnd;
+		return this;
+    }
+
+    /**
+    * 设置 增加 签到方式(0.自动签到，1.手动签到)
+    * @param checkInMethodIncrement
+    */
+    public MonitorAlarmRecordQuery checkInMethodIncrement(Integer checkInMethodIncrement){
+		this.checkInMethodIncrement = checkInMethodIncrement;
+		return this;
+    }
+
+    /**
+    * 设置 签到方式(0.自动签到，1.手动签到)
+    * @param checkInMethodList
+    */
+    public MonitorAlarmRecordQuery checkInMethodList(List<Integer> checkInMethodList){
+        this.checkInMethodList = checkInMethodList;
+		return this;
+        }
+
+        /**
+        * 设置 签到方式(0.自动签到，1.手动签到)
+        * @param checkInMethodNotList
+        */
+        public MonitorAlarmRecordQuery checkInMethodNotList(List<Integer> checkInMethodNotList){
+        this.checkInMethodNotList = checkInMethodNotList;
+        return this;
+        }
+
+
+	/**
+    * 设置 监测凭证
+    * @param monitorCertificate
+    */
+    public MonitorAlarmRecordQuery monitorCertificate(String monitorCertificate){
+        setMonitorCertificate(monitorCertificate);
+		return this;
+    }
+
+    /**
+    * 设置 监测凭证
+    * @param monitorCertificateList
+    */
+    public MonitorAlarmRecordQuery monitorCertificateList(List<String> monitorCertificateList){
+        this.monitorCertificateList = monitorCertificateList;
+		return this;
+    }
+
+
+	/**
+    * 设置 相对图片pic
+    * @param picUri
+    */
+    public MonitorAlarmRecordQuery picUri(String picUri){
+        setPicUri(picUri);
+		return this;
+    }
+
+    /**
+    * 设置 相对图片pic
+    * @param picUriList
+    */
+    public MonitorAlarmRecordQuery picUriList(List<String> picUriList){
+        this.picUriList = picUriList;
+		return this;
+    }
+
+
+	/**
+    * 设置 图片资源唯一标识
+    * @param serverIndexCode
+    */
+    public MonitorAlarmRecordQuery serverIndexCode(String serverIndexCode){
+        setServerIndexCode(serverIndexCode);
+		return this;
+    }
+
+    /**
+    * 设置 图片资源唯一标识
+    * @param serverIndexCodeList
+    */
+    public MonitorAlarmRecordQuery serverIndexCodeList(List<String> serverIndexCodeList){
+        this.serverIndexCodeList = serverIndexCodeList;
+		return this;
+    }
+
+
+    /**
+    * 设置  创建人id
+    * @param createUserId
+    */
+    public MonitorAlarmRecordQuery createUserId(Long createUserId){
+	    setCreateUserId(createUserId);
+		return this;
+    }
+	
+	 /**
+    * 设置 开始 创建人id
+    * @param createUserIdStart
+    */
+    public MonitorAlarmRecordQuery createUserIdStart(Long createUserIdStart){
+		this.createUserIdStart = createUserIdStart;
+		return this;
+    }
+
+    /**
+    * 设置 结束 创建人id
+    * @param createUserIdEnd
+    */
+    public MonitorAlarmRecordQuery createUserIdEnd(Long createUserIdEnd){
+		this.createUserIdEnd = createUserIdEnd;
+		return this;
+    }
+
+    /**
+    * 设置 增加 创建人id
+    * @param createUserIdIncrement
+    */
+    public MonitorAlarmRecordQuery createUserIdIncrement(Long createUserIdIncrement){
+		this.createUserIdIncrement = createUserIdIncrement;
+		return this;
+    }
+
+    /**
+    * 设置 创建人id
+    * @param createUserIdList
+    */
+    public MonitorAlarmRecordQuery createUserIdList(List<Long> createUserIdList){
+        this.createUserIdList = createUserIdList;
+		return this;
+        }
+
+        /**
+        * 设置 创建人id
+        * @param createUserIdNotList
+        */
+        public MonitorAlarmRecordQuery createUserIdNotList(List<Long> createUserIdNotList){
+        this.createUserIdNotList = createUserIdNotList;
+        return this;
+        }
+
+
+    /**
+    * 设置  更新人id
+    * @param updateUserId
+    */
+    public MonitorAlarmRecordQuery updateUserId(Long updateUserId){
+	    setUpdateUserId(updateUserId);
+		return this;
+    }
+	
+	 /**
+    * 设置 开始 更新人id
+    * @param updateUserIdStart
+    */
+    public MonitorAlarmRecordQuery updateUserIdStart(Long updateUserIdStart){
+		this.updateUserIdStart = updateUserIdStart;
+		return this;
+    }
+
+    /**
+    * 设置 结束 更新人id
+    * @param updateUserIdEnd
+    */
+    public MonitorAlarmRecordQuery updateUserIdEnd(Long updateUserIdEnd){
+		this.updateUserIdEnd = updateUserIdEnd;
+		return this;
+    }
+
+    /**
+    * 设置 增加 更新人id
+    * @param updateUserIdIncrement
+    */
+    public MonitorAlarmRecordQuery updateUserIdIncrement(Long updateUserIdIncrement){
+		this.updateUserIdIncrement = updateUserIdIncrement;
+		return this;
+    }
+
+    /**
+    * 设置 更新人id
+    * @param updateUserIdList
+    */
+    public MonitorAlarmRecordQuery updateUserIdList(List<Long> updateUserIdList){
+        this.updateUserIdList = updateUserIdList;
+		return this;
+        }
+
+        /**
+        * 设置 更新人id
+        * @param updateUserIdNotList
+        */
+        public MonitorAlarmRecordQuery updateUserIdNotList(List<Long> updateUserIdNotList){
+        this.updateUserIdNotList = updateUserIdNotList;
+        return this;
+        }
+
+    /**
+    * 获取 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
+    * @return orConditionList
+    */
+    public List<MonitorAlarmRecordQuery> getOrConditionList(){
+    return this.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<MonitorAlarmRecordQuery> orConditionList){
+        this.orConditionList = orConditionList;
+    }
+
+    /**
+    * 获取 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
+    * @return andConditionList
+    */
+    public List<MonitorAlarmRecordQuery> getAndConditionList(){
+        return this.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<MonitorAlarmRecordQuery> andConditionList){
+        this.andConditionList = andConditionList;
+    }
+
+}
\ No newline at end of file

refined-manager/src/main/java/com/mortals/xhx/module/monitor/model/vo/MonitorAlarmRecordVo.java

+package com.mortals.xhx.module.monitor.model.vo;
+import com.mortals.framework.model.BaseEntityLong;
+import com.mortals.xhx.module.monitor.model.MonitorAlarmRecordEntity;
+import java.util.ArrayList;
+import java.util.List;
+import lombok.Data;
+/**
+* 监测预警记录详细记录视图对象
+*
+* @author zxfei
+* @date 2023-04-15
+*/
+@Data
+public class MonitorAlarmRecordVo extends BaseEntityLong {
+
+}
\ No newline at end of file

refined-manager/src/main/java/com/mortals/xhx/module/monitor/model/vo/MonitorAlarmVo.java

+package com.mortals.xhx.module.monitor.model.vo;
+import com.mortals.framework.model.BaseEntityLong;
+import com.mortals.xhx.module.monitor.model.MonitorAlarmEntity;
+import java.util.ArrayList;
+import java.util.List;
+import lombok.Data;
+/**
+* 监测预警记录视图对象
+*
+* @author zxfei
+* @date 2023-04-15
+*/
+@Data
+public class MonitorAlarmVo extends BaseEntityLong {
+
+}
\ No newline at end of file

refined-manager/src/main/java/com/mortals/xhx/module/monitor/service/MonitorAlarmRecordService.java

+package com.mortals.xhx.module.monitor.service;
+import com.mortals.framework.service.ICRUDService;
+import com.mortals.xhx.module.monitor.model.MonitorAlarmRecordEntity;
+/**
+* MonitorAlarmRecordService
+*
+* 监测预警记录详细记录 service接口
+*
+* @author zxfei
+* @date 2023-04-15
+*/
+public interface MonitorAlarmRecordService extends ICRUDService<MonitorAlarmRecordEntity,Long>{
+
+}
\ No newline at end of file

refined-manager/src/main/java/com/mortals/xhx/module/monitor/service/MonitorAlarmService.java

+package com.mortals.xhx.module.monitor.service;
+import com.mortals.framework.service.ICRUDService;
+import com.mortals.xhx.module.monitor.model.MonitorAlarmEntity;
+/**
+* MonitorAlarmService
+*
+* 监测预警记录 service接口
+*
+* @author zxfei
+* @date 2023-04-15
+*/
+public interface MonitorAlarmService extends ICRUDService<MonitorAlarmEntity,Long>{
+
+}
\ No newline at end of file

refined-manager/src/main/java/com/mortals/xhx/module/monitor/service/impl/MonitorAlarmRecordServiceImpl.java

+package com.mortals.xhx.module.monitor.service.impl;
+import org.springframework.stereotype.Service;
+import com.mortals.framework.service.impl.AbstractCRUDServiceImpl;
+import com.mortals.framework.exception.AppException;
+import com.mortals.framework.model.Context;
+import com.mortals.xhx.module.monitor.dao.MonitorAlarmRecordDao;
+import com.mortals.xhx.module.monitor.model.MonitorAlarmRecordEntity;
+import com.mortals.xhx.module.monitor.service.MonitorAlarmRecordService;
+/**
+* MonitorAlarmRecordService
+* 监测预警记录详细记录 service实现
+*
+* @author zxfei
+* @date 2023-04-15
+*/
+@Service("monitorAlarmRecordService")
+public class MonitorAlarmRecordServiceImpl extends AbstractCRUDServiceImpl<MonitorAlarmRecordDao, MonitorAlarmRecordEntity, Long> implements MonitorAlarmRecordService {
+    
+}
\ No newline at end of file

refined-manager/src/main/java/com/mortals/xhx/module/monitor/service/impl/MonitorAlarmServiceImpl.java

+package com.mortals.xhx.module.monitor.service.impl;
+import org.springframework.stereotype.Service;
+import com.mortals.framework.service.impl.AbstractCRUDServiceImpl;
+import com.mortals.framework.exception.AppException;
+import com.mortals.framework.model.Context;
+import com.mortals.xhx.module.monitor.dao.MonitorAlarmDao;
+import com.mortals.xhx.module.monitor.model.MonitorAlarmEntity;
+import com.mortals.xhx.module.monitor.service.MonitorAlarmService;
+/**
+* MonitorAlarmService
+* 监测预警记录 service实现
+*
+* @author zxfei
+* @date 2023-04-15
+*/
+@Service("monitorAlarmService")
+public class MonitorAlarmServiceImpl extends AbstractCRUDServiceImpl<MonitorAlarmDao, MonitorAlarmEntity, Long> implements MonitorAlarmService {
+    
+}
\ No newline at end of file

refined-manager/src/main/java/com/mortals/xhx/module/monitor/web/MonitorAlarmController.java

+package com.mortals.xhx.module.monitor.web;
+import com.mortals.framework.web.BaseCRUDJsonBodyMappingController;
+import com.mortals.xhx.base.system.param.service.ParamService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.*;
+import com.mortals.framework.model.Context;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import com.mortals.framework.web.BaseCRUDJsonBodyMappingController;
+import com.mortals.xhx.module.monitor.model.MonitorAlarmEntity;
+import com.mortals.xhx.module.monitor.service.MonitorAlarmService;
+import org.apache.commons.lang3.ArrayUtils;
+import com.mortals.framework.util.StringUtils;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import com.alibaba.fastjson.JSONObject;
+import java.util.Arrays;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.web.multipart.MultipartFile;
+import static com.mortals.framework.ap.SysConstains.*;
+/**
+*
+* 监测预警记录
+*
+* @author zxfei
+* @date 2023-04-15
+*/
+@RestController
+@RequestMapping("monitor/alarm")
+public class MonitorAlarmController extends BaseCRUDJsonBodyMappingController<MonitorAlarmService,MonitorAlarmEntity,Long> {
+
+    @Autowired
+    private ParamService paramService;
+
+    public MonitorAlarmController(){
+        super.setModuleDesc( "监测预警记录");
+    }
+
+    @Override
+    protected void init(Map<String, Object> model, Context context) {
+        super.init(model, context);
+    }
+
+
+}
\ No newline at end of file

refined-manager/src/main/java/com/mortals/xhx/module/monitor/web/MonitorAlarmRecordController.java

+package com.mortals.xhx.module.monitor.web;
+import com.mortals.framework.web.BaseCRUDJsonBodyMappingController;
+import com.mortals.xhx.base.system.param.service.ParamService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.*;
+import com.mortals.framework.model.Context;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import com.mortals.framework.web.BaseCRUDJsonBodyMappingController;
+import com.mortals.xhx.module.monitor.model.MonitorAlarmRecordEntity;
+import com.mortals.xhx.module.monitor.service.MonitorAlarmRecordService;
+import org.apache.commons.lang3.ArrayUtils;
+import com.mortals.framework.util.StringUtils;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import com.alibaba.fastjson.JSONObject;
+import java.util.Arrays;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.web.multipart.MultipartFile;
+import static com.mortals.framework.ap.SysConstains.*;
+/**
+*
+* 监测预警记录详细记录
+*
+* @author zxfei
+* @date 2023-04-15
+*/
+@RestController
+@RequestMapping("monitor/alarm/record")
+public class MonitorAlarmRecordController extends BaseCRUDJsonBodyMappingController<MonitorAlarmRecordService,MonitorAlarmRecordEntity,Long> {
+
+    @Autowired
+    private ParamService paramService;
+
+    public MonitorAlarmRecordController(){
+        super.setModuleDesc( "监测预警记录详细记录");
+    }
+
+    @Override
+    protected void init(Map<String, Object> model, Context context) {
+        this.addDict(model, "checkInMethod", paramService.getParamBySecondOrganize("MonitorAlarmRecord","checkInMethod"));
+        super.init(model, context);
+    }
+
+
+}
\ No newline at end of file

refined-manager/src/main/java/com/mortals/xhx/module/notice/dao/NoticeDao.java

+package com.mortals.xhx.module.notice.dao;
+
+import com.mortals.framework.dao.ICRUDDao;
+import com.mortals.xhx.module.notice.model.NoticeEntity;
+import java.util.List;
+/**
+* 用户消息Dao
+* 用户消息 DAO接口
+*
+* @author zxfei
+* @date 2023-04-15
+*/
+
+public interface  NoticeDao extends ICRUDDao<NoticeEntity,Long>{
+
+
+}

refined-manager/src/main/java/com/mortals/xhx/module/notice/dao/ibatis/NoticeDaoImpl.java

+package com.mortals.xhx.module.notice.dao.ibatis;
+
+
+import org.springframework.stereotype.Repository;
+import com.mortals.xhx.module.notice.dao.NoticeDao;
+import com.mortals.xhx.module.notice.model.NoticeEntity;
+import java.util.Date;
+import com.mortals.framework.dao.ibatis.BaseCRUDDaoMybatis;
+import java.util.List;
+/**
+* 用户消息DaoImpl DAO接口
+*
+* @author zxfei
+* @date 2023-04-15
+*/
+@Repository("noticeDao")
+public class NoticeDaoImpl extends BaseCRUDDaoMybatis<NoticeEntity,Long> implements NoticeDao {
+
+
+
+}

refined-manager/src/main/java/com/mortals/xhx/module/notice/model/NoticeEntity.java

+package com.mortals.xhx.module.notice.model;
+
+import java.util.Date;
+import java.util.List;
+import java.util.ArrayList;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import com.mortals.framework.annotation.Excel;
+import com.mortals.framework.model.BaseEntityLong;
+import com.mortals.xhx.module.notice.model.vo.NoticeVo;
+/**
+* 用户消息实体对象
+*
+* @author zxfei
+* @date 2023-04-15
+*/
+
+public class NoticeEntity extends NoticeVo {
+    private static final long serialVersionUID = 1L;
+
+    /**
+    * 接收消息的用户的唯一标识符
+    */
+    private Long userId;
+    /**
+    * 消息的标题
+    */
+    @Excel(name = "消息的标题")
+    private String title;
+    /**
+    * 消息的内容
+    */
+    @Excel(name = "消息的内容")
+    private String content;
+    /**
+    * 是否已读 (0.否,1.是)
+    */
+    @Excel(name = "是否已读 ", readConverterExp = "0=否,1.是")
+    private Date read;
+    /**
+    * 消息的优先级，越高表示越紧急，不为空
+    */
+    @Excel(name = "消息的优先级，越高表示越紧急，不为空")
+    private Integer priority;
+    /**
+    * 消息的过期时间，超过此时间则自动标记为已读
+    */
+    private Date expireTime;
+    /**
+    * 消息的来源类型，例如“系统”、“好友”等，可以为空
+    */
+    @Excel(name = "消息的来源类型，例如“系统”、“好友”等，可以为空")
+    private String sourceType;
+
+
+
+    public NoticeEntity(){}
+    /**
+    * 获取 接收消息的用户的唯一标识符
+    * @return Long
+    */
+    public Long getUserId(){
+        return userId;
+    }
+    /**
+    * 设置 接收消息的用户的唯一标识符
+    * @param userId
+    */
+    public void setUserId(Long userId){
+        this.userId = userId;
+    }
+    /**
+    * 获取 消息的标题
+    * @return String
+    */
+    public String getTitle(){
+        return title;
+    }
+    /**
+    * 设置 消息的标题
+    * @param title
+    */
+    public void setTitle(String title){
+        this.title = title;
+    }
+    /**
+    * 获取 消息的内容
+    * @return String
+    */
+    public String getContent(){
+        return content;
+    }
+    /**
+    * 设置 消息的内容
+    * @param content
+    */
+    public void setContent(String content){
+        this.content = content;
+    }
+    /**
+    * 获取 是否已读 (0.否,1.是)
+    * @return Date
+    */
+    public Date getRead(){
+        return read;
+    }
+    /**
+    * 设置 是否已读 (0.否,1.是)
+    * @param read
+    */
+    public void setRead(Date read){
+        this.read = read;
+    }
+    /**
+    * 获取 消息的优先级，越高表示越紧急，不为空
+    * @return Integer
+    */
+    public Integer getPriority(){
+        return priority;
+    }
+    /**
+    * 设置 消息的优先级，越高表示越紧急，不为空
+    * @param priority
+    */
+    public void setPriority(Integer priority){
+        this.priority = priority;
+    }
+    /**
+    * 获取 消息的过期时间，超过此时间则自动标记为已读
+    * @return Date
+    */
+    public Date getExpireTime(){
+        return expireTime;
+    }
+    /**
+    * 设置 消息的过期时间，超过此时间则自动标记为已读
+    * @param expireTime
+    */
+    public void setExpireTime(Date expireTime){
+        this.expireTime = expireTime;
+    }
+    /**
+    * 获取 消息的来源类型，例如“系统”、“好友”等，可以为空
+    * @return String
+    */
+    public String getSourceType(){
+        return sourceType;
+    }
+    /**
+    * 设置 消息的来源类型，例如“系统”、“好友”等，可以为空
+    * @param sourceType
+    */
+    public void setSourceType(String sourceType){
+        this.sourceType = sourceType;
+    }
+
+
+
+
+    @Override
+    public int hashCode() {
+         return this.getId().hashCode();
+    }
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == null) return false;
+        if (obj instanceof NoticeEntity) {
+            NoticeEntity tmp = (NoticeEntity) obj;
+            if (this.getId() == tmp.getId()) {
+                 return true;
+            }
+        }
+        return false;
+    }
+
+    public String toString(){
+        StringBuilder sb = new StringBuilder("");
+        sb.append(",userId:").append(getUserId());
+        sb.append(",title:").append(getTitle());
+        sb.append(",content:").append(getContent());
+        sb.append(",read:").append(getRead());
+        sb.append(",priority:").append(getPriority());
+        sb.append(",expireTime:").append(getExpireTime());
+        sb.append(",sourceType:").append(getSourceType());
+        return sb.toString();
+    }
+
+    public void initAttrValue(){
+
+            this.userId = null;
+
+            this.title = "";
+
+            this.content = "";
+
+            this.read = null;
+
+            this.priority = 0;
+
+            this.expireTime = null;
+
+            this.sourceType = "";
+    }
+}
\ No newline at end of file

refined-manager/src/main/java/com/mortals/xhx/module/notice/model/NoticeQuery.java

+package com.mortals.xhx.module.notice.model;
+
+import java.util.Date;
+import java.util.List;
+import com.mortals.xhx.module.notice.model.NoticeEntity;
+/**
+* 用户消息查询对象
+*
+* @author zxfei
+* @date 2023-04-15
+*/
+public class NoticeQuery extends NoticeEntity {
+    /** 开始 主键ID */
+    private Long idStart;
+
+    /** 结束 主键ID */
+    private Long idEnd;
+
+    /** 增加 主键ID */
+    private Long idIncrement;
+
+    /** 主键ID列表 */
+    private List <Long> idList;
+
+    /** 主键ID排除列表 */
+    private List <Long> idNotList;
+
+    /** 开始 接收消息的用户的唯一标识符 */
+    private Long userIdStart;
+
+    /** 结束 接收消息的用户的唯一标识符 */
+    private Long userIdEnd;
+
+    /** 增加 接收消息的用户的唯一标识符 */
+    private Long userIdIncrement;
+
+    /** 接收消息的用户的唯一标识符列表 */
+    private List <Long> userIdList;
+
+    /** 接收消息的用户的唯一标识符排除列表 */
+    private List <Long> userIdNotList;
+
+    /** 消息的标题 */
+    private List<String> titleList;
+
+    /** 消息的标题排除列表 */
+    private List <String> titleNotList;
+    /** 消息的内容 */
+    private List<String> contentList;
+
+    /** 消息的内容排除列表 */
+    private List <String> contentNotList;
+    /** 开始 是否已读 (0.否,1.是) */
+    private String readStart;
+
+    /** 结束 是否已读 (0.否,1.是) */
+    private String readEnd;
+
+    /** 开始 消息的优先级，越高表示越紧急，不为空 */
+    private Integer priorityStart;
+
+    /** 结束 消息的优先级，越高表示越紧急，不为空 */
+    private Integer priorityEnd;
+
+    /** 增加 消息的优先级，越高表示越紧急，不为空 */
+    private Integer priorityIncrement;
+
+    /** 消息的优先级，越高表示越紧急，不为空列表 */
+    private List <Integer> priorityList;
+
+    /** 消息的优先级，越高表示越紧急，不为空排除列表 */
+    private List <Integer> priorityNotList;
+
+    /** 开始 消息的过期时间，超过此时间则自动标记为已读 */
+    private String expireTimeStart;
+
+    /** 结束 消息的过期时间，超过此时间则自动标记为已读 */
+    private String expireTimeEnd;
+
+    /** 消息的来源类型，例如“系统”、“好友”等，可以为空 */
+    private List<String> sourceTypeList;
+
+    /** 消息的来源类型，例如“系统”、“好友”等，可以为空排除列表 */
+    private List <String> sourceTypeNotList;
+    /** 开始 创建时间 */
+    private String createTimeStart;
+
+    /** 结束 创建时间 */
+    private String createTimeEnd;
+
+    /** 开始 创建人ID */
+    private Long createUserIdStart;
+
+    /** 结束 创建人ID */
+    private Long createUserIdEnd;
+
+    /** 增加 创建人ID */
+    private Long createUserIdIncrement;
+
+    /** 创建人ID列表 */
+    private List <Long> createUserIdList;
+
+    /** 创建人ID排除列表 */
+    private List <Long> createUserIdNotList;
+
+    /** 开始 更新时间 */
+    private String updateTimeStart;
+
+    /** 结束 更新时间 */
+    private String updateTimeEnd;
+
+    /** 开始 更新人ID */
+    private Long updateUserIdStart;
+
+    /** 结束 更新人ID */
+    private Long updateUserIdEnd;
+
+    /** 增加 更新人ID */
+    private Long updateUserIdIncrement;
+
+    /** 更新人ID列表 */
+    private List <Long> updateUserIdList;
+
+    /** 更新人ID排除列表 */
+    private List <Long> updateUserIdNotList;
+
+    /** OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4) */
+    private List<NoticeQuery> orConditionList;
+
+    /** AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4) */
+    private List<NoticeQuery> andConditionList;
+
+    public NoticeQuery(){}
+
+    /**
+    * 获取 开始 主键ID
+    * @return idStart
+    */
+    public Long getIdStart(){
+        return this.idStart;
+    }
+
+    /**
+    * 设置 开始 主键ID
+    * @param idStart
+    */
+    public void setIdStart(Long idStart){
+        this.idStart = idStart;
+    }
+
+    /**
+    * 获取 结束 主键ID
+    * @return $idEnd
+    */
+    public Long getIdEnd(){
+        return this.idEnd;
+    }
+
+    /**
+    * 设置 结束 主键ID
+    * @param idEnd
+    */
+    public void setIdEnd(Long idEnd){
+        this.idEnd = idEnd;
+    }
+
+    /**
+    * 获取 增加 主键ID
+    * @return idIncrement
+    */
+    public Long getIdIncrement(){
+        return this.idIncrement;
+    }
+
+    /**
+    * 设置 增加 主键ID
+    * @param idIncrement
+    */
+    public void setIdIncrement(Long idIncrement){
+        this.idIncrement = idIncrement;
+    }
+
+    /**
+    * 获取 主键ID
+    * @return idList
+    */
+    public List<Long> getIdList(){
+        return this.idList;
+    }
+
+    /**
+    * 设置 主键ID
+    * @param idList
+    */
+    public void setIdList(List<Long> idList){
+        this.idList = idList;
+    }
+
+    /**
+    * 获取 主键ID
+    * @return idNotList
+    */
+    public List<Long> getIdNotList(){
+        return this.idNotList;
+    }
+
+    /**
+    * 设置 主键ID
+    * @param idNotList
+    */
+    public void setIdNotList(List<Long> idNotList){
+        this.idNotList = idNotList;
+    }
+
+
+    /**
+    * 获取 开始 接收消息的用户的唯一标识符
+    * @return userIdStart
+    */
+    public Long getUserIdStart(){
+        return this.userIdStart;
+    }
+
+    /**
+    * 设置 开始 接收消息的用户的唯一标识符
+    * @param userIdStart
+    */
+    public void setUserIdStart(Long userIdStart){
+        this.userIdStart = userIdStart;
+    }
+
+    /**
+    * 获取 结束 接收消息的用户的唯一标识符
+    * @return $userIdEnd
+    */
+    public Long getUserIdEnd(){
+        return this.userIdEnd;
+    }
+
+    /**
+    * 设置 结束 接收消息的用户的唯一标识符
+    * @param userIdEnd
+    */
+    public void setUserIdEnd(Long userIdEnd){
+        this.userIdEnd = userIdEnd;
+    }
+
+    /**
+    * 获取 增加 接收消息的用户的唯一标识符
+    * @return userIdIncrement
+    */
+    public Long getUserIdIncrement(){
+        return this.userIdIncrement;
+    }
+
+    /**
+    * 设置 增加 接收消息的用户的唯一标识符
+    * @param userIdIncrement
+    */
+    public void setUserIdIncrement(Long userIdIncrement){
+        this.userIdIncrement = userIdIncrement;
+    }
+
+    /**
+    * 获取 接收消息的用户的唯一标识符
+    * @return userIdList
+    */
+    public List<Long> getUserIdList(){
+        return this.userIdList;
+    }
+
+    /**
+    * 设置 接收消息的用户的唯一标识符
+    * @param userIdList
+    */
+    public void setUserIdList(List<Long> userIdList){
+        this.userIdList = userIdList;
+    }
+
+    /**
+    * 获取 接收消息的用户的唯一标识符
+    * @return userIdNotList
+    */
+    public List<Long> getUserIdNotList(){
+        return this.userIdNotList;
+    }
+
+    /**
+    * 设置 接收消息的用户的唯一标识符
+    * @param userIdNotList
+    */
+    public void setUserIdNotList(List<Long> userIdNotList){
+        this.userIdNotList = userIdNotList;
+    }
+
+
+    /**
+    * 获取 消息的标题
+    * @return titleList
+    */
+    public List<String> getTitleList(){
+        return this.titleList;
+    }
+
+    /**
+    * 设置 消息的标题
+    * @param titleList
+    */
+    public void setTitleList(List<String> titleList){
+        this.titleList = titleList;
+    }
+
+    /**
+    * 获取 消息的标题
+    * @return titleNotList
+    */
+    public List<String> getTitleNotList(){
+        return this.titleNotList;
+    }
+
+    /**
+    * 设置 消息的标题
+    * @param titleNotList
+    */
+    public void setTitleNotList(List<String> titleNotList){
+        this.titleNotList = titleNotList;
+    }
+
+    /**
+    * 获取 消息的内容
+    * @return contentList
+    */
+    public List<String> getContentList(){
+        return this.contentList;
+    }
+
+    /**
+    * 设置 消息的内容
+    * @param contentList
+    */
+    public void setContentList(List<String> contentList){
+        this.contentList = contentList;
+    }
+
+    /**
+    * 获取 消息的内容
+    * @return contentNotList
+    */
+    public List<String> getContentNotList(){
+        return this.contentNotList;
+    }
+
+    /**
+    * 设置 消息的内容
+    * @param contentNotList
+    */
+    public void setContentNotList(List<String> contentNotList){
+        this.contentNotList = contentNotList;
+    }
+
+    /**
+    * 获取 开始 是否已读 (0.否,1.是)
+    * @return readStart
+    */
+    public String getReadStart(){
+        return this.readStart;
+    }
+
+    /**
+    * 设置 开始 是否已读 (0.否,1.是)
+    * @param readStart
+    */
+    public void setReadStart(String readStart){
+        this.readStart = readStart;
+    }
+
+    /**
+    * 获取 结束 是否已读 (0.否,1.是)
+    * @return readEnd
+    */
+    public String getReadEnd(){
+        return this.readEnd;
+    }
+
+    /**
+    * 设置 结束 是否已读 (0.否,1.是)
+    * @param readEnd
+    */
+    public void setReadEnd(String readEnd){
+        this.readEnd = readEnd;
+    }
+
+    /**
+    * 获取 开始 消息的优先级，越高表示越紧急，不为空
+    * @return priorityStart
+    */
+    public Integer getPriorityStart(){
+        return this.priorityStart;
+    }
+
+    /**
+    * 设置 开始 消息的优先级，越高表示越紧急，不为空
+    * @param priorityStart
+    */
+    public void setPriorityStart(Integer priorityStart){
+        this.priorityStart = priorityStart;
+    }
+
+    /**
+    * 获取 结束 消息的优先级，越高表示越紧急，不为空
+    * @return $priorityEnd
+    */
+    public Integer getPriorityEnd(){
+        return this.priorityEnd;
+    }
+
+    /**
+    * 设置 结束 消息的优先级，越高表示越紧急，不为空
+    * @param priorityEnd
+    */
+    public void setPriorityEnd(Integer priorityEnd){
+        this.priorityEnd = priorityEnd;
+    }
+
+    /**
+    * 获取 增加 消息的优先级，越高表示越紧急，不为空
+    * @return priorityIncrement
+    */
+    public Integer getPriorityIncrement(){
+        return this.priorityIncrement;
+    }
+
+    /**
+    * 设置 增加 消息的优先级，越高表示越紧急，不为空
+    * @param priorityIncrement
+    */
+    public void setPriorityIncrement(Integer priorityIncrement){
+        this.priorityIncrement = priorityIncrement;
+    }
+
+    /**
+    * 获取 消息的优先级，越高表示越紧急，不为空
+    * @return priorityList
+    */
+    public List<Integer> getPriorityList(){
+        return this.priorityList;
+    }
+
+    /**
+    * 设置 消息的优先级，越高表示越紧急，不为空
+    * @param priorityList
+    */
+    public void setPriorityList(List<Integer> priorityList){
+        this.priorityList = priorityList;
+    }
+
+    /**
+    * 获取 消息的优先级，越高表示越紧急，不为空
+    * @return priorityNotList
+    */
+    public List<Integer> getPriorityNotList(){
+        return this.priorityNotList;
+    }
+
+    /**
+    * 设置 消息的优先级，越高表示越紧急，不为空
+    * @param priorityNotList
+    */
+    public void setPriorityNotList(List<Integer> priorityNotList){
+        this.priorityNotList = priorityNotList;
+    }
+
+
+    /**
+    * 获取 开始 消息的过期时间，超过此时间则自动标记为已读
+    * @return expireTimeStart
+    */
+    public String getExpireTimeStart(){
+        return this.expireTimeStart;
+    }
+
+    /**
+    * 设置 开始 消息的过期时间，超过此时间则自动标记为已读
+    * @param expireTimeStart
+    */
+    public void setExpireTimeStart(String expireTimeStart){
+        this.expireTimeStart = expireTimeStart;
+    }
+
+    /**
+    * 获取 结束 消息的过期时间，超过此时间则自动标记为已读
+    * @return expireTimeEnd
+    */
+    public String getExpireTimeEnd(){
+        return this.expireTimeEnd;
+    }
+
+    /**
+    * 设置 结束 消息的过期时间，超过此时间则自动标记为已读
+    * @param expireTimeEnd
+    */
+    public void setExpireTimeEnd(String expireTimeEnd){
+        this.expireTimeEnd = expireTimeEnd;
+    }
+
+    /**
+    * 获取 消息的来源类型，例如“系统”、“好友”等，可以为空
+    * @return sourceTypeList
+    */
+    public List<String> getSourceTypeList(){
+        return this.sourceTypeList;
+    }
+
+    /**
+    * 设置 消息的来源类型，例如“系统”、“好友”等，可以为空
+    * @param sourceTypeList
+    */
+    public void setSourceTypeList(List<String> sourceTypeList){
+        this.sourceTypeList = sourceTypeList;
+    }
+
+    /**
+    * 获取 消息的来源类型，例如“系统”、“好友”等，可以为空
+    * @return sourceTypeNotList
+    */
+    public List<String> getSourceTypeNotList(){
+        return this.sourceTypeNotList;
+    }
+
+    /**
+    * 设置 消息的来源类型，例如“系统”、“好友”等，可以为空
+    * @param sourceTypeNotList
+    */
+    public void setSourceTypeNotList(List<String> sourceTypeNotList){
+        this.sourceTypeNotList = sourceTypeNotList;
+    }
+
+    /**
+    * 获取 开始 创建时间
+    * @return createTimeStart
+    */
+    public String getCreateTimeStart(){
+        return this.createTimeStart;
+    }
+
+    /**
+    * 设置 开始 创建时间
+    * @param createTimeStart
+    */
+    public void setCreateTimeStart(String createTimeStart){
+        this.createTimeStart = createTimeStart;
+    }
+
+    /**
+    * 获取 结束 创建时间
+    * @return createTimeEnd
+    */
+    public String getCreateTimeEnd(){
+        return this.createTimeEnd;
+    }
+
+    /**
+    * 设置 结束 创建时间
+    * @param createTimeEnd
+    */
+    public void setCreateTimeEnd(String createTimeEnd){
+        this.createTimeEnd = createTimeEnd;
+    }
+
+    /**
+    * 获取 开始 创建人ID
+    * @return createUserIdStart
+    */
+    public Long getCreateUserIdStart(){
+        return this.createUserIdStart;
+    }
+
+    /**
+    * 设置 开始 创建人ID
+    * @param createUserIdStart
+    */
+    public void setCreateUserIdStart(Long createUserIdStart){
+        this.createUserIdStart = createUserIdStart;
+    }
+
+    /**
+    * 获取 结束 创建人ID
+    * @return $createUserIdEnd
+    */
+    public Long getCreateUserIdEnd(){
+        return this.createUserIdEnd;
+    }
+
+    /**
+    * 设置 结束 创建人ID
+    * @param createUserIdEnd
+    */
+    public void setCreateUserIdEnd(Long createUserIdEnd){
+        this.createUserIdEnd = createUserIdEnd;
+    }
+
+    /**
+    * 获取 增加 创建人ID
+    * @return createUserIdIncrement
+    */
+    public Long getCreateUserIdIncrement(){
+        return this.createUserIdIncrement;
+    }
+
+    /**
+    * 设置 增加 创建人ID
+    * @param createUserIdIncrement
+    */
+    public void setCreateUserIdIncrement(Long createUserIdIncrement){
+        this.createUserIdIncrement = createUserIdIncrement;
+    }
+
+    /**
+    * 获取 创建人ID
+    * @return createUserIdList
+    */
+    public List<Long> getCreateUserIdList(){
+        return this.createUserIdList;
+    }
+
+    /**
+    * 设置 创建人ID
+    * @param createUserIdList
+    */
+    public void setCreateUserIdList(List<Long> createUserIdList){
+        this.createUserIdList = createUserIdList;
+    }
+
+    /**
+    * 获取 创建人ID
+    * @return createUserIdNotList
+    */
+    public List<Long> getCreateUserIdNotList(){
+        return this.createUserIdNotList;
+    }
+
+    /**
+    * 设置 创建人ID
+    * @param createUserIdNotList
+    */
+    public void setCreateUserIdNotList(List<Long> createUserIdNotList){
+        this.createUserIdNotList = createUserIdNotList;
+    }
+
+
+    /**
+    * 获取 开始 更新时间
+    * @return updateTimeStart
+    */
+    public String getUpdateTimeStart(){
+        return this.updateTimeStart;
+    }
+
+    /**
+    * 设置 开始 更新时间
+    * @param updateTimeStart
+    */
+    public void setUpdateTimeStart(String updateTimeStart){
+        this.updateTimeStart = updateTimeStart;
+    }
+
+    /**
+    * 获取 结束 更新时间
+    * @return updateTimeEnd
+    */
+    public String getUpdateTimeEnd(){
+        return this.updateTimeEnd;
+    }
+
+    /**
+    * 设置 结束 更新时间
+    * @param updateTimeEnd
+    */
+    public void setUpdateTimeEnd(String updateTimeEnd){
+        this.updateTimeEnd = updateTimeEnd;
+    }
+
+    /**
+    * 获取 开始 更新人ID
+    * @return updateUserIdStart
+    */
+    public Long getUpdateUserIdStart(){
+        return this.updateUserIdStart;
+    }
+
+    /**
+    * 设置 开始 更新人ID
+    * @param updateUserIdStart
+    */
+    public void setUpdateUserIdStart(Long updateUserIdStart){
+        this.updateUserIdStart = updateUserIdStart;
+    }
+
+    /**
+    * 获取 结束 更新人ID
+    * @return $updateUserIdEnd
+    */
+    public Long getUpdateUserIdEnd(){
+        return this.updateUserIdEnd;
+    }
+
+    /**
+    * 设置 结束 更新人ID
+    * @param updateUserIdEnd
+    */
+    public void setUpdateUserIdEnd(Long updateUserIdEnd){
+        this.updateUserIdEnd = updateUserIdEnd;
+    }
+
+    /**
+    * 获取 增加 更新人ID
+    * @return updateUserIdIncrement
+    */
+    public Long getUpdateUserIdIncrement(){
+        return this.updateUserIdIncrement;
+    }
+
+    /**
+    * 设置 增加 更新人ID
+    * @param updateUserIdIncrement
+    */
+    public void setUpdateUserIdIncrement(Long updateUserIdIncrement){
+        this.updateUserIdIncrement = updateUserIdIncrement;
+    }
+
+    /**
+    * 获取 更新人ID
+    * @return updateUserIdList
+    */
+    public List<Long> getUpdateUserIdList(){
+        return this.updateUserIdList;
+    }
+
+    /**
+    * 设置 更新人ID
+    * @param updateUserIdList
+    */
+    public void setUpdateUserIdList(List<Long> updateUserIdList){
+        this.updateUserIdList = updateUserIdList;
+    }
+
+    /**
+    * 获取 更新人ID
+    * @return updateUserIdNotList
+    */
+    public List<Long> getUpdateUserIdNotList(){
+        return this.updateUserIdNotList;
+    }
+
+    /**
+    * 设置 更新人ID
+    * @param updateUserIdNotList
+    */
+    public void setUpdateUserIdNotList(List<Long> updateUserIdNotList){
+        this.updateUserIdNotList = updateUserIdNotList;
+    }
+
+
+    /**
+    * 设置  主键ID
+    * @param id
+    */
+    public NoticeQuery id(Long id){
+	    setId(id);
+		return this;
+    }
+	
+	 /**
+    * 设置 开始 主键ID
+    * @param idStart
+    */
+    public NoticeQuery idStart(Long idStart){
+		this.idStart = idStart;
+		return this;
+    }
+
+    /**
+    * 设置 结束 主键ID
+    * @param idEnd
+    */
+    public NoticeQuery idEnd(Long idEnd){
+		this.idEnd = idEnd;
+		return this;
+    }
+
+    /**
+    * 设置 增加 主键ID
+    * @param idIncrement
+    */
+    public NoticeQuery idIncrement(Long idIncrement){
+		this.idIncrement = idIncrement;
+		return this;
+    }
+
+    /**
+    * 设置 主键ID
+    * @param idList
+    */
+    public NoticeQuery idList(List<Long> idList){
+        this.idList = idList;
+		return this;
+        }
+
+        /**
+        * 设置 主键ID
+        * @param idNotList
+        */
+        public NoticeQuery idNotList(List<Long> idNotList){
+        this.idNotList = idNotList;
+        return this;
+        }
+
+    /**
+    * 设置  接收消息的用户的唯一标识符
+    * @param userId
+    */
+    public NoticeQuery userId(Long userId){
+	    setUserId(userId);
+		return this;
+    }
+	
+	 /**
+    * 设置 开始 接收消息的用户的唯一标识符
+    * @param userIdStart
+    */
+    public NoticeQuery userIdStart(Long userIdStart){
+		this.userIdStart = userIdStart;
+		return this;
+    }
+
+    /**
+    * 设置 结束 接收消息的用户的唯一标识符
+    * @param userIdEnd
+    */
+    public NoticeQuery userIdEnd(Long userIdEnd){
+		this.userIdEnd = userIdEnd;
+		return this;
+    }
+
+    /**
+    * 设置 增加 接收消息的用户的唯一标识符
+    * @param userIdIncrement
+    */
+    public NoticeQuery userIdIncrement(Long userIdIncrement){
+		this.userIdIncrement = userIdIncrement;
+		return this;
+    }
+
+    /**
+    * 设置 接收消息的用户的唯一标识符
+    * @param userIdList
+    */
+    public NoticeQuery userIdList(List<Long> userIdList){
+        this.userIdList = userIdList;
+		return this;
+        }
+
+        /**
+        * 设置 接收消息的用户的唯一标识符
+        * @param userIdNotList
+        */
+        public NoticeQuery userIdNotList(List<Long> userIdNotList){
+        this.userIdNotList = userIdNotList;
+        return this;
+        }
+
+
+	/**
+    * 设置 消息的标题
+    * @param title
+    */
+    public NoticeQuery title(String title){
+        setTitle(title);
+		return this;
+    }
+
+    /**
+    * 设置 消息的标题
+    * @param titleList
+    */
+    public NoticeQuery titleList(List<String> titleList){
+        this.titleList = titleList;
+		return this;
+    }
+
+
+	/**
+    * 设置 消息的内容
+    * @param content
+    */
+    public NoticeQuery content(String content){
+        setContent(content);
+		return this;
+    }
+
+    /**
+    * 设置 消息的内容
+    * @param contentList
+    */
+    public NoticeQuery contentList(List<String> contentList){
+        this.contentList = contentList;
+		return this;
+    }
+
+
+    /**
+    * 设置  消息的优先级，越高表示越紧急，不为空
+    * @param priority
+    */
+    public NoticeQuery priority(Integer priority){
+	    setPriority(priority);
+		return this;
+    }
+	
+	 /**
+    * 设置 开始 消息的优先级，越高表示越紧急，不为空
+    * @param priorityStart
+    */
+    public NoticeQuery priorityStart(Integer priorityStart){
+		this.priorityStart = priorityStart;
+		return this;
+    }
+
+    /**
+    * 设置 结束 消息的优先级，越高表示越紧急，不为空
+    * @param priorityEnd
+    */
+    public NoticeQuery priorityEnd(Integer priorityEnd){
+		this.priorityEnd = priorityEnd;
+		return this;
+    }
+
+    /**
+    * 设置 增加 消息的优先级，越高表示越紧急，不为空
+    * @param priorityIncrement
+    */
+    public NoticeQuery priorityIncrement(Integer priorityIncrement){
+		this.priorityIncrement = priorityIncrement;
+		return this;
+    }
+
+    /**
+    * 设置 消息的优先级，越高表示越紧急，不为空
+    * @param priorityList
+    */
+    public NoticeQuery priorityList(List<Integer> priorityList){
+        this.priorityList = priorityList;
+		return this;
+        }
+
+        /**
+        * 设置 消息的优先级，越高表示越紧急，不为空
+        * @param priorityNotList
+        */
+        public NoticeQuery priorityNotList(List<Integer> priorityNotList){
+        this.priorityNotList = priorityNotList;
+        return this;
+        }
+
+
+
+	/**
+    * 设置 消息的来源类型，例如“系统”、“好友”等，可以为空
+    * @param sourceType
+    */
+    public NoticeQuery sourceType(String sourceType){
+        setSourceType(sourceType);
+		return this;
+    }
+
+    /**
+    * 设置 消息的来源类型，例如“系统”、“好友”等，可以为空
+    * @param sourceTypeList
+    */
+    public NoticeQuery sourceTypeList(List<String> sourceTypeList){
+        this.sourceTypeList = sourceTypeList;
+		return this;
+    }
+
+
+    /**
+    * 设置  创建人ID
+    * @param createUserId
+    */
+    public NoticeQuery createUserId(Long createUserId){
+	    setCreateUserId(createUserId);
+		return this;
+    }
+	
+	 /**
+    * 设置 开始 创建人ID
+    * @param createUserIdStart
+    */
+    public NoticeQuery createUserIdStart(Long createUserIdStart){
+		this.createUserIdStart = createUserIdStart;
+		return this;
+    }
+
+    /**
+    * 设置 结束 创建人ID
+    * @param createUserIdEnd
+    */
+    public NoticeQuery createUserIdEnd(Long createUserIdEnd){
+		this.createUserIdEnd = createUserIdEnd;
+		return this;
+    }
+
+    /**
+    * 设置 增加 创建人ID
+    * @param createUserIdIncrement
+    */
+    public NoticeQuery createUserIdIncrement(Long createUserIdIncrement){
+		this.createUserIdIncrement = createUserIdIncrement;
+		return this;
+    }
+
+    /**
+    * 设置 创建人ID
+    * @param createUserIdList
+    */
+    public NoticeQuery createUserIdList(List<Long> createUserIdList){
+        this.createUserIdList = createUserIdList;
+		return this;
+        }
+
+        /**
+        * 设置 创建人ID
+        * @param createUserIdNotList
+        */
+        public NoticeQuery createUserIdNotList(List<Long> createUserIdNotList){
+        this.createUserIdNotList = createUserIdNotList;
+        return this;
+        }
+
+
+    /**
+    * 设置  更新人ID
+    * @param updateUserId
+    */
+    public NoticeQuery updateUserId(Long updateUserId){
+	    setUpdateUserId(updateUserId);
+		return this;
+    }
+	
+	 /**
+    * 设置 开始 更新人ID
+    * @param updateUserIdStart
+    */
+    public NoticeQuery updateUserIdStart(Long updateUserIdStart){
+		this.updateUserIdStart = updateUserIdStart;
+		return this;
+    }
+
+    /**
+    * 设置 结束 更新人ID
+    * @param updateUserIdEnd
+    */
+    public NoticeQuery updateUserIdEnd(Long updateUserIdEnd){
+		this.updateUserIdEnd = updateUserIdEnd;
+		return this;
+    }
+
+    /**
+    * 设置 增加 更新人ID
+    * @param updateUserIdIncrement
+    */
+    public NoticeQuery updateUserIdIncrement(Long updateUserIdIncrement){
+		this.updateUserIdIncrement = updateUserIdIncrement;
+		return this;
+    }
+
+    /**
+    * 设置 更新人ID
+    * @param updateUserIdList
+    */
+    public NoticeQuery updateUserIdList(List<Long> updateUserIdList){
+        this.updateUserIdList = updateUserIdList;
+		return this;
+        }
+
+        /**
+        * 设置 更新人ID
+        * @param updateUserIdNotList
+        */
+        public NoticeQuery updateUserIdNotList(List<Long> updateUserIdNotList){
+        this.updateUserIdNotList = updateUserIdNotList;
+        return this;
+        }
+
+    /**
+    * 获取 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
+    * @return orConditionList
+    */
+    public List<NoticeQuery> getOrConditionList(){
+    return this.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<NoticeQuery> orConditionList){
+        this.orConditionList = orConditionList;
+    }
+
+    /**
+    * 获取 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
+    * @return andConditionList
+    */
+    public List<NoticeQuery> getAndConditionList(){
+        return this.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<NoticeQuery> andConditionList){
+        this.andConditionList = andConditionList;
+    }
+
+}
\ No newline at end of file

refined-manager/src/main/java/com/mortals/xhx/module/notice/model/vo/NoticeVo.java

+package com.mortals.xhx.module.notice.model.vo;
+import com.mortals.framework.model.BaseEntityLong;
+import com.mortals.xhx.module.notice.model.NoticeEntity;
+import java.util.ArrayList;
+import java.util.List;
+import lombok.Data;
+/**
+* 用户消息视图对象
+*
+* @author zxfei
+* @date 2023-04-15
+*/
+@Data
+public class NoticeVo extends BaseEntityLong {
+
+}
\ No newline at end of file

refined-manager/src/main/java/com/mortals/xhx/module/notice/service/NoticeService.java

+package com.mortals.xhx.module.notice.service;
+import com.mortals.framework.service.ICRUDService;
+import com.mortals.xhx.module.notice.model.NoticeEntity;
+/**
+* NoticeService
+*
+* 用户消息 service接口
+*
+* @author zxfei
+* @date 2023-04-15
+*/
+public interface NoticeService extends ICRUDService<NoticeEntity,Long>{
+
+}
\ No newline at end of file

refined-manager/src/main/java/com/mortals/xhx/module/notice/service/impl/NoticeServiceImpl.java

+package com.mortals.xhx.module.notice.service.impl;
+import org.springframework.stereotype.Service;
+import com.mortals.framework.service.impl.AbstractCRUDServiceImpl;
+import com.mortals.framework.exception.AppException;
+import com.mortals.framework.model.Context;
+import com.mortals.xhx.module.notice.dao.NoticeDao;
+import com.mortals.xhx.module.notice.model.NoticeEntity;
+import com.mortals.xhx.module.notice.service.NoticeService;
+/**
+* NoticeService
+* 用户消息 service实现
+*
+* @author zxfei
+* @date 2023-04-15
+*/
+@Service("noticeService")
+public class NoticeServiceImpl extends AbstractCRUDServiceImpl<NoticeDao, NoticeEntity, Long> implements NoticeService {
+    
+}
\ No newline at end of file

refined-manager/src/main/java/com/mortals/xhx/module/notice/web/NoticeController.java

+package com.mortals.xhx.module.notice.web;
+import com.mortals.framework.web.BaseCRUDJsonBodyMappingController;
+import com.mortals.xhx.base.system.param.service.ParamService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.*;
+import com.mortals.framework.model.Context;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import com.mortals.framework.web.BaseCRUDJsonBodyMappingController;
+import com.mortals.xhx.module.notice.model.NoticeEntity;
+import com.mortals.xhx.module.notice.service.NoticeService;
+import org.apache.commons.lang3.ArrayUtils;
+import com.mortals.framework.util.StringUtils;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import com.alibaba.fastjson.JSONObject;
+import java.util.Arrays;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.web.multipart.MultipartFile;
+import static com.mortals.framework.ap.SysConstains.*;
+/**
+*
+* 用户消息
+*
+* @author zxfei
+* @date 2023-04-15
+*/
+@RestController
+@RequestMapping("notice")
+public class NoticeController extends BaseCRUDJsonBodyMappingController<NoticeService,NoticeEntity,Long> {
+
+    @Autowired
+    private ParamService paramService;
+
+    public NoticeController(){
+        super.setModuleDesc( "用户消息");
+    }
+
+    @Override
+    protected void init(Map<String, Object> model, Context context) {
+        this.addDict(model, "read", paramService.getParamBySecondOrganize("Notice","read"));
+        super.init(model, context);
+    }
+
+
+}
\ No newline at end of file

refined-manager/src/main/resources/sqlmap/module/device/DeviceMapper.xml → refined-manager/src/main/resources/sqlmap/module/monitor/MonitorAlarmMapper.xml

 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
 "mybatis-3-mapper.dtd">
-<mapper namespace="com.mortals.xhx.module.device.dao.ibatis.DeviceDaoImpl">
+<mapper namespace="com.mortals.xhx.module.monitor.dao.ibatis.MonitorAlarmDaoImpl">
 
     <!-- 字段和属性映射 -->
-    <resultMap type="DeviceEntity" id="DeviceEntity-Map">
+    <resultMap type="MonitorAlarmEntity" id="MonitorAlarmEntity-Map">
             <id  property="id" column="id" />
             <result property="siteId" column="siteId" />
             <result property="siteName" column="siteName" />
-            <result property="deviceId" column="deviceId" />
-            <result property="deviceName" column="deviceName" />
-            <result property="deviceCode" column="deviceCode" />
-            <result property="deviceMac" column="deviceMac" />
-            <result property="deviceLocation" column="deviceLocation" />
-            <result property="lon" column="lon" />
-            <result property="lati" column="lati" />
-            <result property="floor" column="floor" />
-            <result property="build" column="build" />
-            <result property="leadingOfficial" column="leadingOfficial" />
-            <result property="leadingOfficialTelephone" column="leadingOfficialTelephone" />
-            <result property="timeOutPeriod" column="timeOutPeriod" />
-            <result property="nearTime" column="nearTime" />
-            <result property="deviceStatus" column="deviceStatus" />
-            <result property="deviceRemark" column="deviceRemark" />
-            <result property="createUserId" column="createUserId" />
+            <result property="personId" column="personId" />
+            <result property="name" column="name" />
+            <result property="contact" column="contact" />
+            <result property="idNumber" column="idNumber" />
+            <result property="identifyNum" column="identifyNum" />
+            <result property="lastIdentifyTime" column="lastIdentifyTime" />
+            <result property="year" column="year" />
+            <result property="month" column="month" />
+            <result property="day" column="day" />
             <result property="createTime" column="createTime" />
-            <result property="updateUserId" column="updateUserId" />
+            <result property="createUserId" column="createUserId" />
             <result property="updateTime" column="updateTime" />
+            <result property="updateUserId" column="updateUserId" />
             
     </resultMap>
 
@@ -43,87 +37,69 @@
                 <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('siteName') or colPickMode == 1 and data.containsKey('siteName')))">
                     a.siteName,
                 </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('deviceId') or colPickMode == 1 and data.containsKey('deviceId')))">
-                    a.deviceId,
-                </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('deviceMac') or colPickMode == 1 and data.containsKey('deviceMac')))">
-                    a.deviceMac,
+                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('personId') or colPickMode == 1 and data.containsKey('personId')))">
+                    a.personId,
                 </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('deviceLocation') or colPickMode == 1 and data.containsKey('deviceLocation')))">
-                    a.deviceLocation,
+                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('name') or colPickMode == 1 and data.containsKey('name')))">
+                    a.name,
                 </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('lon') or colPickMode == 1 and data.containsKey('lon')))">
-                    a.lon,
+                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('contact') or colPickMode == 1 and data.containsKey('contact')))">
+                    a.contact,
                 </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('lati') or colPickMode == 1 and data.containsKey('lati')))">
-                    a.lati,
+                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('idNumber') or colPickMode == 1 and data.containsKey('idNumber')))">
+                    a.idNumber,
                 </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('floor') or colPickMode == 1 and data.containsKey('floor')))">
-                    a.floor,
+                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('identifyNum') or colPickMode == 1 and data.containsKey('identifyNum')))">
+                    a.identifyNum,
                 </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('build') or colPickMode == 1 and data.containsKey('build')))">
-                    a.build,
+                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('lastIdentifyTime') or colPickMode == 1 and data.containsKey('lastIdentifyTime')))">
+                    a.lastIdentifyTime,
                 </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('leadingOfficial') or colPickMode == 1 and data.containsKey('leadingOfficial')))">
-                    a.leadingOfficial,
+                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('year') or colPickMode == 1 and data.containsKey('year')))">
+                    a.year,
                 </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('leadingOfficialTelephone') or colPickMode == 1 and data.containsKey('leadingOfficialTelephone')))">
-                    a.leadingOfficialTelephone,
+                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('month') or colPickMode == 1 and data.containsKey('month')))">
+                    a.month,
                 </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('timeOutPeriod') or colPickMode == 1 and data.containsKey('timeOutPeriod')))">
-                    a.timeOutPeriod,
+                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('day') or colPickMode == 1 and data.containsKey('day')))">
+                    a.day,
                 </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('nearTime') or colPickMode == 1 and data.containsKey('nearTime')))">
-                    a.nearTime,
-                </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('deviceStatus') or colPickMode == 1 and data.containsKey('deviceStatus')))">
-                    a.deviceStatus,
-                </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 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('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 test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateTime') or colPickMode == 1 and data.containsKey('updateTime')))">
+                    a.updateTime,
                 </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_xhx_device
-        (siteId,siteName,deviceId,deviceName,deviceCode,deviceMac,deviceLocation,lon,lati,floor,build,leadingOfficial,leadingOfficialTelephone,timeOutPeriod,nearTime,deviceStatus,deviceRemark,createUserId,createTime,updateUserId,updateTime)
+    <insert id="insert" parameterType="MonitorAlarmEntity"  useGeneratedKeys="true" keyProperty="id">
+        insert into mortals_xhx_monitor_alarm
+        (siteId,siteName,personId,name,contact,idNumber,identifyNum,lastIdentifyTime,year,month,day,createTime,createUserId,updateTime,updateUserId)
         VALUES
-        (#{siteId},#{siteName},#{deviceId},#{deviceName},#{deviceCode},#{deviceMac},#{deviceLocation},#{lon},#{lati},#{floor},#{build},#{leadingOfficial},#{leadingOfficialTelephone},#{timeOutPeriod},#{nearTime},#{deviceStatus},#{deviceRemark},#{createUserId},#{createTime},#{updateUserId},#{updateTime})
+        (#{siteId},#{siteName},#{personId},#{name},#{contact},#{idNumber},#{identifyNum},#{lastIdentifyTime},#{year},#{month},#{day},#{createTime},#{createUserId},#{updateTime},#{updateUserId})
     </insert>
 
     <!-- 批量新增 -->
     <insert id="insertBatch" parameterType="paramDto">
-        insert into mortals_xhx_device
-        (siteId,siteName,deviceId,deviceName,deviceCode,deviceMac,deviceLocation,lon,lati,floor,build,leadingOfficial,leadingOfficialTelephone,timeOutPeriod,nearTime,deviceStatus,deviceRemark,createUserId,createTime,updateUserId,updateTime)
+        insert into mortals_xhx_monitor_alarm
+        (siteId,siteName,personId,name,contact,idNumber,identifyNum,lastIdentifyTime,year,month,day,createTime,createUserId,updateTime,updateUserId)
         VALUES
         <foreach collection="data.dataList" item="item" index="index" separator="," >
-            (#{item.siteId},#{item.siteName},#{item.deviceId},#{item.deviceName},#{item.deviceCode},#{item.deviceMac},#{item.deviceLocation},#{item.lon},#{item.lati},#{item.floor},#{item.build},#{item.leadingOfficial},#{item.leadingOfficialTelephone},#{item.timeOutPeriod},#{item.nearTime},#{item.deviceStatus},#{item.deviceRemark},#{item.createUserId},#{item.createTime},#{item.updateUserId},#{item.updateTime})
+            (#{item.siteId},#{item.siteName},#{item.personId},#{item.name},#{item.contact},#{item.idNumber},#{item.identifyNum},#{item.lastIdentifyTime},#{item.year},#{item.month},#{item.day},#{item.createTime},#{item.createUserId},#{item.updateTime},#{item.updateUserId})
         </foreach>
     </insert>
 
 
     <!-- 根据ParamDto更新 -->
     <update id="update" parameterType="paramDto">
-        update mortals_xhx_device as a
+        update mortals_xhx_monitor_alarm as a
         set
         <trim suffixOverrides="," suffix="">
             <if test="(colPickMode==0 and data.containsKey('siteId')) or (colPickMode==1 and !data.containsKey('siteId'))">
@@ -135,65 +111,50 @@
             <if test="(colPickMode==0 and data.containsKey('siteName')) or (colPickMode==1 and !data.containsKey('siteName'))">
                 a.siteName=#{data.siteName},
             </if>
-            <if test="(colPickMode==0 and data.containsKey('deviceId')) or (colPickMode==1 and !data.containsKey('deviceId'))">
-                a.deviceId=#{data.deviceId},
-            </if>
-            <if test="(colPickMode==0 and data.containsKey('deviceName')) or (colPickMode==1 and !data.containsKey('deviceName'))">
-                a.deviceName=#{data.deviceName},
+            <if test="(colPickMode==0 and data.containsKey('personId')) or (colPickMode==1 and !data.containsKey('personId'))">
+                a.personId=#{data.personId},
             </if>
-            <if test="(colPickMode==0 and data.containsKey('deviceCode')) or (colPickMode==1 and !data.containsKey('deviceCode'))">
-                a.deviceCode=#{data.deviceCode},
+            <if test="(colPickMode==0 and data.containsKey('personIdIncrement')) or (colPickMode==1 and !data.containsKey('personIdIncrement'))">
+                a.personId=ifnull(a.personId,0) + #{data.personIdIncrement},
             </if>
-            <if test="(colPickMode==0 and data.containsKey('deviceMac')) or (colPickMode==1 and !data.containsKey('deviceMac'))">
-                a.deviceMac=#{data.deviceMac},
+            <if test="(colPickMode==0 and data.containsKey('name')) or (colPickMode==1 and !data.containsKey('name'))">
+                a.name=#{data.name},
             </if>
-            <if test="(colPickMode==0 and data.containsKey('deviceLocation')) or (colPickMode==1 and !data.containsKey('deviceLocation'))">
-                a.deviceLocation=#{data.deviceLocation},
+            <if test="(colPickMode==0 and data.containsKey('contact')) or (colPickMode==1 and !data.containsKey('contact'))">
+                a.contact=#{data.contact},
             </if>
-            <if test="(colPickMode==0 and data.containsKey('lon')) or (colPickMode==1 and !data.containsKey('lon'))">
-                a.lon=#{data.lon},
+            <if test="(colPickMode==0 and data.containsKey('idNumber')) or (colPickMode==1 and !data.containsKey('idNumber'))">
+                a.idNumber=#{data.idNumber},
             </if>
-            <if test="(colPickMode==0 and data.containsKey('lati')) or (colPickMode==1 and !data.containsKey('lati'))">
-                a.lati=#{data.lati},
+            <if test="(colPickMode==0 and data.containsKey('identifyNum')) or (colPickMode==1 and !data.containsKey('identifyNum'))">
+                a.identifyNum=#{data.identifyNum},
             </if>
-            <if test="(colPickMode==0 and data.containsKey('floor')) or (colPickMode==1 and !data.containsKey('floor'))">
-                a.floor=#{data.floor},
+            <if test="(colPickMode==0 and data.containsKey('identifyNumIncrement')) or (colPickMode==1 and !data.containsKey('identifyNumIncrement'))">
+                a.identifyNum=ifnull(a.identifyNum,0) + #{data.identifyNumIncrement},
             </if>
-            <if test="(colPickMode==0 and data.containsKey('floorIncrement')) or (colPickMode==1 and !data.containsKey('floorIncrement'))">
-                a.floor=ifnull(a.floor,0) + #{data.floorIncrement},
+            <if test="(colPickMode==0 and data.containsKey('lastIdentifyTime')) or (colPickMode==1 and !data.containsKey('lastIdentifyTime'))">
+                a.lastIdentifyTime=#{data.lastIdentifyTime},
             </if>
-            <if test="(colPickMode==0 and data.containsKey('build')) or (colPickMode==1 and !data.containsKey('build'))">
-                a.build=#{data.build},
+            <if test="(colPickMode==0 and data.containsKey('year')) or (colPickMode==1 and !data.containsKey('year'))">
+                a.year=#{data.year},
             </if>
-            <if test="(colPickMode==0 and data.containsKey('buildIncrement')) or (colPickMode==1 and !data.containsKey('buildIncrement'))">
-                a.build=ifnull(a.build,0) + #{data.buildIncrement},
+            <if test="(colPickMode==0 and data.containsKey('yearIncrement')) or (colPickMode==1 and !data.containsKey('yearIncrement'))">
+                a.year=ifnull(a.year,0) + #{data.yearIncrement},
             </if>
-            <if test="(colPickMode==0 and data.containsKey('leadingOfficial')) or (colPickMode==1 and !data.containsKey('leadingOfficial'))">
-                a.leadingOfficial=#{data.leadingOfficial},
+            <if test="(colPickMode==0 and data.containsKey('month')) or (colPickMode==1 and !data.containsKey('month'))">
+                a.month=#{data.month},
             </if>
-            <if test="(colPickMode==0 and data.containsKey('leadingOfficialTelephone')) or (colPickMode==1 and !data.containsKey('leadingOfficialTelephone'))">
-                a.leadingOfficialTelephone=#{data.leadingOfficialTelephone},
+            <if test="(colPickMode==0 and data.containsKey('monthIncrement')) or (colPickMode==1 and !data.containsKey('monthIncrement'))">
+                a.month=ifnull(a.month,0) + #{data.monthIncrement},
             </if>
-            <if test="(colPickMode==0 and data.containsKey('timeOutPeriod')) or (colPickMode==1 and !data.containsKey('timeOutPeriod'))">
-                a.timeOutPeriod=#{data.timeOutPeriod},
+            <if test="(colPickMode==0 and data.containsKey('day')) or (colPickMode==1 and !data.containsKey('day'))">
+                a.day=#{data.day},
             </if>
-            <if test="(colPickMode==0 and data.containsKey('timeOutPeriodIncrement')) or (colPickMode==1 and !data.containsKey('timeOutPeriodIncrement'))">
-                a.timeOutPeriod=ifnull(a.timeOutPeriod,0) + #{data.timeOutPeriodIncrement},
+            <if test="(colPickMode==0 and data.containsKey('dayIncrement')) or (colPickMode==1 and !data.containsKey('dayIncrement'))">
+                a.day=ifnull(a.day,0) + #{data.dayIncrement},
             </if>
-            <if test="(colPickMode==0 and data.containsKey('nearTime')) or (colPickMode==1 and !data.containsKey('nearTime'))">
-                a.nearTime=#{data.nearTime},
-            </if>
-            <if test="(colPickMode==0 and data.containsKey('nearTimeIncrement')) or (colPickMode==1 and !data.containsKey('nearTimeIncrement'))">
-                a.nearTime=ifnull(a.nearTime,0) + #{data.nearTimeIncrement},
-            </if>
-            <if test="(colPickMode==0 and data.containsKey('deviceStatus')) or (colPickMode==1 and !data.containsKey('deviceStatus'))">
-                a.deviceStatus=#{data.deviceStatus},
-            </if>
-            <if test="(colPickMode==0 and data.containsKey('deviceStatusIncrement')) or (colPickMode==1 and !data.containsKey('deviceStatusIncrement'))">
-                a.deviceStatus=ifnull(a.deviceStatus,0) + #{data.deviceStatusIncrement},
-            </if>
-            <if test="(colPickMode==0 and data.containsKey('deviceRemark')) or (colPickMode==1 and !data.containsKey('deviceRemark'))">
-                a.deviceRemark=#{data.deviceRemark},
+            <if test="(colPickMode==0 and data.containsKey('createTime')) or (colPickMode==1 and !data.containsKey('createTime'))">
+                a.createTime=#{data.createTime},
             </if>
             <if test="(colPickMode==0 and data.containsKey('createUserId')) or (colPickMode==1 and !data.containsKey('createUserId'))">
                 a.createUserId=#{data.createUserId},
@@ -201,8 +162,8 @@
             <if test="(colPickMode==0 and data.containsKey('createUserIdIncrement')) or (colPickMode==1 and !data.containsKey('createUserIdIncrement'))">
                 a.createUserId=ifnull(a.createUserId,0) + #{data.createUserIdIncrement},
             </if>
-            <if test="(colPickMode==0 and data.containsKey('createTime')) or (colPickMode==1 and !data.containsKey('createTime'))">
-                a.createTime=#{data.createTime},
+            <if test="(colPickMode==0 and data.containsKey('updateTime')) or (colPickMode==1 and !data.containsKey('updateTime'))">
+                a.updateTime=#{data.updateTime},
             </if>
             <if test="(colPickMode==0 and data.containsKey('updateUserId')) or (colPickMode==1 and !data.containsKey('updateUserId'))">
                 a.updateUserId=#{data.updateUserId},
@@ -210,9 +171,6 @@
             <if test="(colPickMode==0 and data.containsKey('updateUserIdIncrement')) or (colPickMode==1 and !data.containsKey('updateUserIdIncrement'))">
                 a.updateUserId=ifnull(a.updateUserId,0) + #{data.updateUserIdIncrement},
             </if>
-            <if test="(colPickMode==0 and data.containsKey('updateTime')) or (colPickMode==1 and !data.containsKey('updateTime'))">
-                a.updateTime=#{data.updateTime},
-            </if>
         </trim>
         <trim suffixOverrides="where" suffix="">
             where
@@ -223,7 +181,7 @@
     </update>
     <!-- 批量更新 -->
     <update id="updateBatch" parameterType="paramDto">
-        update mortals_xhx_device as a
+        update mortals_xhx_monitor_alarm as a
         <trim prefix="set" suffixOverrides=",">
                         <trim prefix="siteId=(case" suffix="ELSE siteId end),">
                             <foreach collection="data.dataList" item="item" index="index" separator="" >
@@ -244,133 +202,98 @@
                         </if>
                     </foreach>
                 </trim>
-                <trim prefix="deviceId=(case" suffix="ELSE deviceId end),">
+                        <trim prefix="personId=(case" suffix="ELSE personId end),">
                             <foreach collection="data.dataList" item="item" index="index" separator="" >
-                        <if test="(colPickMode==0 and item.containsKey('deviceId')) or (colPickMode==1 and !item.containsKey('deviceId'))">
-                            when a.id=#{item.id} then #{item.deviceId}
-                        </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="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>
+                                <choose>
+                                    <when test="(colPickMode==0 and item.containsKey('personId')) or (colPickMode==1 and !item.containsKey('personId'))">
+                                        when a.id=#{item.id} then #{item.personId}
+                                    </when>
+                                    <when test="(colPickMode==0 and item.containsKey('personIdIncrement')) or (colPickMode==1 and !item.containsKey('personIdIncrement'))">
+                                        when a.id=#{item.id} then ifnull(a.personId,0) + #{item.personIdIncrement}
+                                    </when>
+                                </choose>
                             </foreach>
                         </trim>
-                <trim prefix="deviceLocation=(case" suffix="ELSE deviceLocation end),">
+                <trim prefix="name=(case" suffix="ELSE name end),">
                     <foreach collection="data.dataList" item="item" index="index" separator="" >
-                        <if test="(colPickMode==0 and item.containsKey('deviceLocation')) or (colPickMode==1 and !item.containsKey('deviceLocation'))">
-                            when a.id=#{item.id} then #{item.deviceLocation}
+                        <if test="(colPickMode==0 and item.containsKey('name')) or (colPickMode==1 and !item.containsKey('name'))">
+                            when a.id=#{item.id} then #{item.name}
                         </if>
                     </foreach>
                 </trim>
-                <trim prefix="lon=(case" suffix="ELSE lon end),">
+                <trim prefix="contact=(case" suffix="ELSE contact end),">
                     <foreach collection="data.dataList" item="item" index="index" separator="" >
-                        <if test="(colPickMode==0 and item.containsKey('lon')) or (colPickMode==1 and !item.containsKey('lon'))">
-                            when a.id=#{item.id} then #{item.lon}
+                        <if test="(colPickMode==0 and item.containsKey('contact')) or (colPickMode==1 and !item.containsKey('contact'))">
+                            when a.id=#{item.id} then #{item.contact}
                         </if>
                     </foreach>
                 </trim>
-                <trim prefix="lati=(case" suffix="ELSE lati end),">
+                <trim prefix="idNumber=(case" suffix="ELSE idNumber end),">
                     <foreach collection="data.dataList" item="item" index="index" separator="" >
-                        <if test="(colPickMode==0 and item.containsKey('lati')) or (colPickMode==1 and !item.containsKey('lati'))">
-                            when a.id=#{item.id} then #{item.lati}
+                        <if test="(colPickMode==0 and item.containsKey('idNumber')) or (colPickMode==1 and !item.containsKey('idNumber'))">
+                            when a.id=#{item.id} then #{item.idNumber}
                         </if>
                     </foreach>
                 </trim>
-                        <trim prefix="floor=(case" suffix="ELSE floor end),">
-                            <foreach collection="data.dataList" item="item" index="index" separator="" >
-                                <choose>
-                                    <when test="(colPickMode==0 and item.containsKey('floor')) or (colPickMode==1 and !item.containsKey('floor'))">
-                                        when a.id=#{item.id} then #{item.floor}
-                                    </when>
-                                    <when test="(colPickMode==0 and item.containsKey('floorIncrement')) or (colPickMode==1 and !item.containsKey('floorIncrement'))">
-                                        when a.id=#{item.id} then ifnull(a.floor,0) + #{item.floorIncrement}
-                                    </when>
-                                </choose>
-                            </foreach>
-                        </trim>
-                        <trim prefix="build=(case" suffix="ELSE build end),">
+                        <trim prefix="identifyNum=(case" suffix="ELSE identifyNum end),">
                             <foreach collection="data.dataList" item="item" index="index" separator="" >
                                 <choose>
-                                    <when test="(colPickMode==0 and item.containsKey('build')) or (colPickMode==1 and !item.containsKey('build'))">
-                                        when a.id=#{item.id} then #{item.build}
+                                    <when test="(colPickMode==0 and item.containsKey('identifyNum')) or (colPickMode==1 and !item.containsKey('identifyNum'))">
+                                        when a.id=#{item.id} then #{item.identifyNum}
                                     </when>
-                                    <when test="(colPickMode==0 and item.containsKey('buildIncrement')) or (colPickMode==1 and !item.containsKey('buildIncrement'))">
-                                        when a.id=#{item.id} then ifnull(a.build,0) + #{item.buildIncrement}
+                                    <when test="(colPickMode==0 and item.containsKey('identifyNumIncrement')) or (colPickMode==1 and !item.containsKey('identifyNumIncrement'))">
+                                        when a.id=#{item.id} then ifnull(a.identifyNum,0) + #{item.identifyNumIncrement}
                                     </when>
                                 </choose>
                             </foreach>
                         </trim>
-                <trim prefix="leadingOfficial=(case" suffix="ELSE leadingOfficial end),">
+                <trim prefix="lastIdentifyTime=(case" suffix="ELSE lastIdentifyTime end),">
                     <foreach collection="data.dataList" item="item" index="index" separator="" >
-                        <if test="(colPickMode==0 and item.containsKey('leadingOfficial')) or (colPickMode==1 and !item.containsKey('leadingOfficial'))">
-                            when a.id=#{item.id} then #{item.leadingOfficial}
+                        <if test="(colPickMode==0 and item.containsKey('lastIdentifyTime')) or (colPickMode==1 and !item.containsKey('lastIdentifyTime'))">
+                            when a.id=#{item.id} then #{item.lastIdentifyTime}
                         </if>
                     </foreach>
                 </trim>
-                <trim prefix="leadingOfficialTelephone=(case" suffix="ELSE leadingOfficialTelephone end),">
-                    <foreach collection="data.dataList" item="item" index="index" separator="" >
-                        <if test="(colPickMode==0 and item.containsKey('leadingOfficialTelephone')) or (colPickMode==1 and !item.containsKey('leadingOfficialTelephone'))">
-                            when a.id=#{item.id} then #{item.leadingOfficialTelephone}
-                        </if>
-                    </foreach>
-                </trim>
-                        <trim prefix="timeOutPeriod=(case" suffix="ELSE timeOutPeriod end),">
+                        <trim prefix="year=(case" suffix="ELSE year end),">
                             <foreach collection="data.dataList" item="item" index="index" separator="" >
                                 <choose>
-                                    <when test="(colPickMode==0 and item.containsKey('timeOutPeriod')) or (colPickMode==1 and !item.containsKey('timeOutPeriod'))">
-                                        when a.id=#{item.id} then #{item.timeOutPeriod}
+                                    <when test="(colPickMode==0 and item.containsKey('year')) or (colPickMode==1 and !item.containsKey('year'))">
+                                        when a.id=#{item.id} then #{item.year}
                                     </when>
-                                    <when test="(colPickMode==0 and item.containsKey('timeOutPeriodIncrement')) or (colPickMode==1 and !item.containsKey('timeOutPeriodIncrement'))">
-                                        when a.id=#{item.id} then ifnull(a.timeOutPeriod,0) + #{item.timeOutPeriodIncrement}
+                                    <when test="(colPickMode==0 and item.containsKey('yearIncrement')) or (colPickMode==1 and !item.containsKey('yearIncrement'))">
+                                        when a.id=#{item.id} then ifnull(a.year,0) + #{item.yearIncrement}
                                     </when>
                                 </choose>
                             </foreach>
                         </trim>
-                        <trim prefix="nearTime=(case" suffix="ELSE nearTime end),">
+                        <trim prefix="month=(case" suffix="ELSE month end),">
                             <foreach collection="data.dataList" item="item" index="index" separator="" >
                                 <choose>
-                                    <when test="(colPickMode==0 and item.containsKey('nearTime')) or (colPickMode==1 and !item.containsKey('nearTime'))">
-                                        when a.id=#{item.id} then #{item.nearTime}
+                                    <when test="(colPickMode==0 and item.containsKey('month')) or (colPickMode==1 and !item.containsKey('month'))">
+                                        when a.id=#{item.id} then #{item.month}
                                     </when>
-                                    <when test="(colPickMode==0 and item.containsKey('nearTimeIncrement')) or (colPickMode==1 and !item.containsKey('nearTimeIncrement'))">
-                                        when a.id=#{item.id} then ifnull(a.nearTime,0) + #{item.nearTimeIncrement}
+                                    <when test="(colPickMode==0 and item.containsKey('monthIncrement')) or (colPickMode==1 and !item.containsKey('monthIncrement'))">
+                                        when a.id=#{item.id} then ifnull(a.month,0) + #{item.monthIncrement}
                                     </when>
                                 </choose>
                             </foreach>
                         </trim>
-                        <trim prefix="deviceStatus=(case" suffix="ELSE deviceStatus end),">
+                        <trim prefix="day=(case" suffix="ELSE day end),">
                             <foreach collection="data.dataList" item="item" index="index" separator="" >
                                 <choose>
-                                    <when test="(colPickMode==0 and item.containsKey('deviceStatus')) or (colPickMode==1 and !item.containsKey('deviceStatus'))">
-                                        when a.id=#{item.id} then #{item.deviceStatus}
+                                    <when test="(colPickMode==0 and item.containsKey('day')) or (colPickMode==1 and !item.containsKey('day'))">
+                                        when a.id=#{item.id} then #{item.day}
                                     </when>
-                                    <when test="(colPickMode==0 and item.containsKey('deviceStatusIncrement')) or (colPickMode==1 and !item.containsKey('deviceStatusIncrement'))">
-                                        when a.id=#{item.id} then ifnull(a.deviceStatus,0) + #{item.deviceStatusIncrement}
+                                    <when test="(colPickMode==0 and item.containsKey('dayIncrement')) or (colPickMode==1 and !item.containsKey('dayIncrement'))">
+                                        when a.id=#{item.id} then ifnull(a.day,0) + #{item.dayIncrement}
                                     </when>
                                 </choose>
                             </foreach>
                         </trim>
-                <trim prefix="deviceRemark=(case" suffix="ELSE deviceRemark end),">
+                <trim prefix="createTime=(case" suffix="ELSE createTime 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 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>
@@ -386,10 +309,10 @@
                                 </choose>
                             </foreach>
                         </trim>
-                <trim prefix="createTime=(case" suffix="ELSE createTime end),">
+                <trim prefix="updateTime=(case" suffix="ELSE updateTime 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 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>
@@ -405,13 +328,6 @@
                                 </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=")">
@@ -419,25 +335,25 @@
         </foreach>
     </update>
     <!-- 根据主健查询 -->
-    <select id="getByKey" parameterType="paramDto" resultMap="DeviceEntity-Map">
+    <select id="getByKey" parameterType="paramDto" resultMap="MonitorAlarmEntity-Map">
         select <include refid="_columns"/>
-        from mortals_xhx_device as a
+        from mortals_xhx_monitor_alarm as a
         where a.id=#{condition.id}
     </select>
     <!-- 根据主健删除 -->
     <delete id="deleteByKey" parameterType="paramDto">
-        delete a.* from mortals_xhx_device as a where a.id=#{condition.id}
+        delete a.* from mortals_xhx_monitor_alarm as a where a.id=#{condition.id}
     </delete>
     <!-- 根据主健删除一批，针对单一主健有效 -->
     <delete id="deleteByKeys">
-        delete from mortals_xhx_device where id in
+        delete from mortals_xhx_monitor_alarm where id in
         <foreach collection="array" item="item" index="index" open="(" separator="," close=")">
             #{item}
         </foreach>
     </delete>
     <!-- 根据主健列表删除一批，针对单一主健有效 -->
     <delete id="deleteByKeyList">
-        delete from mortals_xhx_device where id in
+        delete from mortals_xhx_monitor_alarm where id in
         <foreach collection="list" item="item" index="index" open="(" separator="," close=")">
             #{item}
         </foreach>
@@ -445,14 +361,14 @@
 
     <!-- 根据对象列表删除一批，针对单一主健有效 -->
     <delete id="deleteByEntityList">
-        delete from mortals_xhx_device where id in
+        delete from mortals_xhx_monitor_alarm where id in
         <foreach collection="list" item="item" index="index" open="(" separator="," close=")">
             #{item.id}
         </foreach>
     </delete>
     <!-- 根据paramDto删除一批 -->
     <delete id="deleteByMap" parameterType="paramDto">
-        delete a.* from mortals_xhx_device as a
+        delete a.* from mortals_xhx_monitor_alarm as a
         <trim suffixOverrides="where" suffix="">
             where
             <trim prefixOverrides="and" prefix="">
@@ -461,9 +377,9 @@
         </trim>
     </delete>
     <!-- 获取列表 -->
-    <select id="getList" parameterType="paramDto" resultMap="DeviceEntity-Map">
+    <select id="getList" parameterType="paramDto" resultMap="MonitorAlarmEntity-Map">
         select <include refid="_columns"/>
-        from mortals_xhx_device as a
+        from mortals_xhx_monitor_alarm as a
         <trim suffixOverrides="where" suffix="">
             where
             <trim prefixOverrides="and" prefix="">
@@ -478,7 +394,7 @@
     <!-- 获取 -->
     <select id="getListCount" parameterType="paramDto" resultType="int">
         select count(1)
-        from mortals_xhx_device as a
+        from mortals_xhx_monitor_alarm as a
         <trim suffixOverrides="where" suffix="">
             where
             <trim prefixOverrides="and" prefix="">
@@ -603,350 +519,233 @@
                     #{item}
                 </foreach>
             </if>
-
-            <if test="conditionParamRef.containsKey('deviceId')">
-                <if test="conditionParamRef.deviceId != null and conditionParamRef.deviceId != ''">
-                    ${_conditionType_} a.deviceId like #{${_conditionParam_}.deviceId}
+            <if test="conditionParamRef.containsKey('personId')">
+                <if test="conditionParamRef.personId != null ">
+                    ${_conditionType_} a.personId = #{${_conditionParam_}.personId}
                 </if>
-                <if test="conditionParamRef.deviceId == null">
-                    ${_conditionType_} a.deviceId is null
+                <if test="conditionParamRef.personId == null">
+                    ${_conditionType_} a.personId is null
                 </if>
             </if>
-            <if test="conditionParamRef.containsKey('deviceIdList') and conditionParamRef.deviceIdList.size() > 0">
-                ${_conditionType_} a.deviceId in
-                <foreach collection="conditionParamRef.deviceIdList" open="(" close=")" index="index" item="item" separator=",">
+            <if test="conditionParamRef.containsKey('personIdList') and conditionParamRef.personIdList.size() > 0">
+                ${_conditionType_} a.personId in
+                <foreach collection="conditionParamRef.personIdList" open="(" close=")" index="index" item="item" separator=",">
                     #{item}
                 </foreach>
             </if>
-            <if test="conditionParamRef.containsKey('deviceIdNotList') and conditionParamRef.deviceIdNotList.size() > 0">
-                ${_conditionType_} a.deviceId not in
-                <foreach collection="conditionParamRef.deviceIdNotList" open="(" close=")" index="index" item="item" separator=",">
+            <if test="conditionParamRef.containsKey('personIdNotList') and conditionParamRef.personIdNotList.size() > 0">
+                ${_conditionType_} a.personId not in
+                <foreach collection="conditionParamRef.personIdNotList" open="(" close=")" index="index" item="item" separator=",">
                     #{item}
                 </foreach>
             </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 test="conditionParamRef.containsKey('personIdStart') and conditionParamRef.personIdStart != null">
+                ${_conditionType_} a.personId <![CDATA[ >= ]]> #{${_conditionParam_}.personIdStart}
             </if>
-            </if>
-            <if test="conditionParamRef.containsKey('deviceNameList') and conditionParamRef.deviceNameList.size() > 0">
-                ${_conditionType_} a.deviceName in
-                <foreach collection="conditionParamRef.deviceNameList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
-            </if>
-            <if test="conditionParamRef.containsKey('deviceNameNotList') and conditionParamRef.deviceNameNotList.size() > 0">
-                ${_conditionType_} a.deviceName not in
-                <foreach collection="conditionParamRef.deviceNameNotList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
+            <if test="conditionParamRef.containsKey('personIdEnd') and conditionParamRef.personIdEnd != null">
+                ${_conditionType_} a.personId <![CDATA[ <= ]]> #{${_conditionParam_}.personIdEnd}
             </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') and conditionParamRef.deviceCodeList.size() > 0">
-                ${_conditionType_} a.deviceCode in
-                <foreach collection="conditionParamRef.deviceCodeList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
-            </if>
-            <if test="conditionParamRef.containsKey('deviceCodeNotList') and conditionParamRef.deviceCodeNotList.size() > 0">
-                ${_conditionType_} a.deviceCode not in
-                <foreach collection="conditionParamRef.deviceCodeNotList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
-            </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>
-            <if test="conditionParamRef.containsKey('deviceMacList') and conditionParamRef.deviceMacList.size() > 0">
-                ${_conditionType_} a.deviceMac in
-                <foreach collection="conditionParamRef.deviceMacList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
-            </if>
-            <if test="conditionParamRef.containsKey('deviceMacNotList') and conditionParamRef.deviceMacNotList.size() > 0">
-                ${_conditionType_} a.deviceMac not in
-                <foreach collection="conditionParamRef.deviceMacNotList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
-            </if>
 
-            <if test="conditionParamRef.containsKey('deviceLocation')">
-                <if test="conditionParamRef.deviceLocation != null and conditionParamRef.deviceLocation != ''">
-                    ${_conditionType_} a.deviceLocation like #{${_conditionParam_}.deviceLocation}
+            <if test="conditionParamRef.containsKey('name')">
+                <if test="conditionParamRef.name != null and conditionParamRef.name != ''">
+                    ${_conditionType_} a.name like #{${_conditionParam_}.name}
                 </if>
-                <if test="conditionParamRef.deviceLocation == null">
-                    ${_conditionType_} a.deviceLocation is null
+                <if test="conditionParamRef.name == null">
+                    ${_conditionType_} a.name is null
                 </if>
             </if>
-            <if test="conditionParamRef.containsKey('deviceLocationList') and conditionParamRef.deviceLocationList.size() > 0">
-                ${_conditionType_} a.deviceLocation in
-                <foreach collection="conditionParamRef.deviceLocationList" open="(" close=")" index="index" item="item" separator=",">
+            <if test="conditionParamRef.containsKey('nameList') and conditionParamRef.nameList.size() > 0">
+                ${_conditionType_} a.name in
+                <foreach collection="conditionParamRef.nameList" open="(" close=")" index="index" item="item" separator=",">
                     #{item}
                 </foreach>
             </if>
-            <if test="conditionParamRef.containsKey('deviceLocationNotList') and conditionParamRef.deviceLocationNotList.size() > 0">
-                ${_conditionType_} a.deviceLocation not in
-                <foreach collection="conditionParamRef.deviceLocationNotList" open="(" close=")" index="index" item="item" separator=",">
+            <if test="conditionParamRef.containsKey('nameNotList') and conditionParamRef.nameNotList.size() > 0">
+                ${_conditionType_} a.name not in
+                <foreach collection="conditionParamRef.nameNotList" open="(" close=")" index="index" item="item" separator=",">
                     #{item}
                 </foreach>
             </if>
 
-            <if test="conditionParamRef.containsKey('lon')">
-                <if test="conditionParamRef.lon != null and conditionParamRef.lon != ''">
-                    ${_conditionType_} a.lon like #{${_conditionParam_}.lon}
+            <if test="conditionParamRef.containsKey('contact')">
+                <if test="conditionParamRef.contact != null and conditionParamRef.contact != ''">
+                    ${_conditionType_} a.contact like #{${_conditionParam_}.contact}
                 </if>
-                <if test="conditionParamRef.lon == null">
-                    ${_conditionType_} a.lon is null
+                <if test="conditionParamRef.contact == null">
+                    ${_conditionType_} a.contact is null
                 </if>
             </if>
-            <if test="conditionParamRef.containsKey('lonList') and conditionParamRef.lonList.size() > 0">
-                ${_conditionType_} a.lon in
-                <foreach collection="conditionParamRef.lonList" open="(" close=")" index="index" item="item" separator=",">
+            <if test="conditionParamRef.containsKey('contactList') and conditionParamRef.contactList.size() > 0">
+                ${_conditionType_} a.contact in
+                <foreach collection="conditionParamRef.contactList" open="(" close=")" index="index" item="item" separator=",">
                     #{item}
                 </foreach>
             </if>
-            <if test="conditionParamRef.containsKey('lonNotList') and conditionParamRef.lonNotList.size() > 0">
-                ${_conditionType_} a.lon not in
-                <foreach collection="conditionParamRef.lonNotList" open="(" close=")" index="index" item="item" separator=",">
+            <if test="conditionParamRef.containsKey('contactNotList') and conditionParamRef.contactNotList.size() > 0">
+                ${_conditionType_} a.contact not in
+                <foreach collection="conditionParamRef.contactNotList" open="(" close=")" index="index" item="item" separator=",">
                     #{item}
                 </foreach>
             </if>
 
-            <if test="conditionParamRef.containsKey('lati')">
-                <if test="conditionParamRef.lati != null and conditionParamRef.lati != ''">
-                    ${_conditionType_} a.lati like #{${_conditionParam_}.lati}
+            <if test="conditionParamRef.containsKey('idNumber')">
+                <if test="conditionParamRef.idNumber != null and conditionParamRef.idNumber != ''">
+                    ${_conditionType_} a.idNumber like #{${_conditionParam_}.idNumber}
                 </if>
-                <if test="conditionParamRef.lati == null">
-                    ${_conditionType_} a.lati is null
+                <if test="conditionParamRef.idNumber == null">
+                    ${_conditionType_} a.idNumber is null
                 </if>
             </if>
-            <if test="conditionParamRef.containsKey('latiList') and conditionParamRef.latiList.size() > 0">
-                ${_conditionType_} a.lati in
-                <foreach collection="conditionParamRef.latiList" open="(" close=")" index="index" item="item" separator=",">
+            <if test="conditionParamRef.containsKey('idNumberList') and conditionParamRef.idNumberList.size() > 0">
+                ${_conditionType_} a.idNumber in
+                <foreach collection="conditionParamRef.idNumberList" open="(" close=")" index="index" item="item" separator=",">
                     #{item}
                 </foreach>
             </if>
-            <if test="conditionParamRef.containsKey('latiNotList') and conditionParamRef.latiNotList.size() > 0">
-                ${_conditionType_} a.lati not in
-                <foreach collection="conditionParamRef.latiNotList" open="(" close=")" index="index" item="item" separator=",">
+            <if test="conditionParamRef.containsKey('idNumberNotList') and conditionParamRef.idNumberNotList.size() > 0">
+                ${_conditionType_} a.idNumber not in
+                <foreach collection="conditionParamRef.idNumberNotList" open="(" close=")" index="index" item="item" separator=",">
                     #{item}
                 </foreach>
             </if>
-            <if test="conditionParamRef.containsKey('floor')">
-                <if test="conditionParamRef.floor != null ">
-                    ${_conditionType_} a.floor = #{${_conditionParam_}.floor}
+            <if test="conditionParamRef.containsKey('identifyNum')">
+                <if test="conditionParamRef.identifyNum != null ">
+                    ${_conditionType_} a.identifyNum = #{${_conditionParam_}.identifyNum}
                 </if>
-                <if test="conditionParamRef.floor == null">
-                    ${_conditionType_} a.floor is null
+                <if test="conditionParamRef.identifyNum == null">
+                    ${_conditionType_} a.identifyNum is null
                 </if>
             </if>
-            <if test="conditionParamRef.containsKey('floorList') and conditionParamRef.floorList.size() > 0">
-                ${_conditionType_} a.floor in
-                <foreach collection="conditionParamRef.floorList" open="(" close=")" index="index" item="item" separator=",">
+            <if test="conditionParamRef.containsKey('identifyNumList') and conditionParamRef.identifyNumList.size() > 0">
+                ${_conditionType_} a.identifyNum in
+                <foreach collection="conditionParamRef.identifyNumList" open="(" close=")" index="index" item="item" separator=",">
                     #{item}
                 </foreach>
             </if>
-            <if test="conditionParamRef.containsKey('floorNotList') and conditionParamRef.floorNotList.size() > 0">
-                ${_conditionType_} a.floor not in
-                <foreach collection="conditionParamRef.floorNotList" open="(" close=")" index="index" item="item" separator=",">
+            <if test="conditionParamRef.containsKey('identifyNumNotList') and conditionParamRef.identifyNumNotList.size() > 0">
+                ${_conditionType_} a.identifyNum not in
+                <foreach collection="conditionParamRef.identifyNumNotList" open="(" close=")" index="index" item="item" separator=",">
                     #{item}
                 </foreach>
             </if>
-            <if test="conditionParamRef.containsKey('floorStart') and conditionParamRef.floorStart != null">
-                ${_conditionType_} a.floor <![CDATA[ >= ]]> #{${_conditionParam_}.floorStart}
+            <if test="conditionParamRef.containsKey('identifyNumStart') and conditionParamRef.identifyNumStart != null">
+                ${_conditionType_} a.identifyNum <![CDATA[ >= ]]> #{${_conditionParam_}.identifyNumStart}
             </if>
-            <if test="conditionParamRef.containsKey('floorEnd') and conditionParamRef.floorEnd != null">
-                ${_conditionType_} a.floor <![CDATA[ <= ]]> #{${_conditionParam_}.floorEnd}
+            <if test="conditionParamRef.containsKey('identifyNumEnd') and conditionParamRef.identifyNumEnd != null">
+                ${_conditionType_} a.identifyNum <![CDATA[ <= ]]> #{${_conditionParam_}.identifyNumEnd}
             </if>
 
-            <if test="conditionParamRef.containsKey('build')">
-                <if test="conditionParamRef.build != null ">
-                    ${_conditionType_} a.build = #{${_conditionParam_}.build}
-                </if>
-                <if test="conditionParamRef.build == null">
-                    ${_conditionType_} a.build is null
-                </if>
-            </if>
-            <if test="conditionParamRef.containsKey('buildList') and conditionParamRef.buildList.size() > 0">
-                ${_conditionType_} a.build in
-                <foreach collection="conditionParamRef.buildList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
-            </if>
-            <if test="conditionParamRef.containsKey('buildNotList') and conditionParamRef.buildNotList.size() > 0">
-                ${_conditionType_} a.build not in
-                <foreach collection="conditionParamRef.buildNotList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
-            </if>
-            <if test="conditionParamRef.containsKey('buildStart') and conditionParamRef.buildStart != null">
-                ${_conditionType_} a.build <![CDATA[ >= ]]> #{${_conditionParam_}.buildStart}
-            </if>
-            <if test="conditionParamRef.containsKey('buildEnd') and conditionParamRef.buildEnd != null">
-                ${_conditionType_} a.build <![CDATA[ <= ]]> #{${_conditionParam_}.buildEnd}
-            </if>
-
-
-            <if test="conditionParamRef.containsKey('leadingOfficial')">
-                <if test="conditionParamRef.leadingOfficial != null and conditionParamRef.leadingOfficial != ''">
-                    ${_conditionType_} a.leadingOfficial like #{${_conditionParam_}.leadingOfficial}
-                </if>
-                <if test="conditionParamRef.leadingOfficial == null">
-                    ${_conditionType_} a.leadingOfficial is null
-                </if>
-            </if>
-            <if test="conditionParamRef.containsKey('leadingOfficialList') and conditionParamRef.leadingOfficialList.size() > 0">
-                ${_conditionType_} a.leadingOfficial in
-                <foreach collection="conditionParamRef.leadingOfficialList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
-            </if>
-            <if test="conditionParamRef.containsKey('leadingOfficialNotList') and conditionParamRef.leadingOfficialNotList.size() > 0">
-                ${_conditionType_} a.leadingOfficial not in
-                <foreach collection="conditionParamRef.leadingOfficialNotList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
-            </if>
 
-            <if test="conditionParamRef.containsKey('leadingOfficialTelephone')">
-                <if test="conditionParamRef.leadingOfficialTelephone != null and conditionParamRef.leadingOfficialTelephone != ''">
-                    ${_conditionType_} a.leadingOfficialTelephone like #{${_conditionParam_}.leadingOfficialTelephone}
+            <if test="conditionParamRef.containsKey('lastIdentifyTime')">
+                <if test="conditionParamRef.lastIdentifyTime != null ">
+                    ${_conditionType_} a.lastIdentifyTime = #{${_conditionParam_}.lastIdentifyTime}
                 </if>
-                <if test="conditionParamRef.leadingOfficialTelephone == null">
-                    ${_conditionType_} a.leadingOfficialTelephone is null
+                <if test="conditionParamRef.lastIdentifyTime == null">
+                    ${_conditionType_} a.lastIdentifyTime is null
                 </if>
             </if>
-            <if test="conditionParamRef.containsKey('leadingOfficialTelephoneList') and conditionParamRef.leadingOfficialTelephoneList.size() > 0">
-                ${_conditionType_} a.leadingOfficialTelephone in
-                <foreach collection="conditionParamRef.leadingOfficialTelephoneList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
+            <if test="conditionParamRef.containsKey('lastIdentifyTimeStart') and conditionParamRef.lastIdentifyTimeStart != null and conditionParamRef.lastIdentifyTimeStart!=''">
+                ${_conditionType_} a.lastIdentifyTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.lastIdentifyTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
             </if>
-            <if test="conditionParamRef.containsKey('leadingOfficialTelephoneNotList') and conditionParamRef.leadingOfficialTelephoneNotList.size() > 0">
-                ${_conditionType_} a.leadingOfficialTelephone not in
-                <foreach collection="conditionParamRef.leadingOfficialTelephoneNotList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
+            <if test="conditionParamRef.containsKey('lastIdentifyTimeEnd') and conditionParamRef.lastIdentifyTimeEnd != null and conditionParamRef.lastIdentifyTimeEnd!=''">
+                ${_conditionType_} a.lastIdentifyTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.lastIdentifyTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
             </if>
-            <if test="conditionParamRef.containsKey('timeOutPeriod')">
-                <if test="conditionParamRef.timeOutPeriod != null ">
-                    ${_conditionType_} a.timeOutPeriod = #{${_conditionParam_}.timeOutPeriod}
+            <if test="conditionParamRef.containsKey('year')">
+                <if test="conditionParamRef.year != null ">
+                    ${_conditionType_} a.year = #{${_conditionParam_}.year}
                 </if>
-                <if test="conditionParamRef.timeOutPeriod == null">
-                    ${_conditionType_} a.timeOutPeriod is null
+                <if test="conditionParamRef.year == null">
+                    ${_conditionType_} a.year is null
                 </if>
             </if>
-            <if test="conditionParamRef.containsKey('timeOutPeriodList') and conditionParamRef.timeOutPeriodList.size() > 0">
-                ${_conditionType_} a.timeOutPeriod in
-                <foreach collection="conditionParamRef.timeOutPeriodList" open="(" close=")" index="index" item="item" separator=",">
+            <if test="conditionParamRef.containsKey('yearList') and conditionParamRef.yearList.size() > 0">
+                ${_conditionType_} a.year in
+                <foreach collection="conditionParamRef.yearList" open="(" close=")" index="index" item="item" separator=",">
                     #{item}
                 </foreach>
             </if>
-            <if test="conditionParamRef.containsKey('timeOutPeriodNotList') and conditionParamRef.timeOutPeriodNotList.size() > 0">
-                ${_conditionType_} a.timeOutPeriod not in
-                <foreach collection="conditionParamRef.timeOutPeriodNotList" open="(" close=")" index="index" item="item" separator=",">
+            <if test="conditionParamRef.containsKey('yearNotList') and conditionParamRef.yearNotList.size() > 0">
+                ${_conditionType_} a.year not in
+                <foreach collection="conditionParamRef.yearNotList" open="(" close=")" index="index" item="item" separator=",">
                     #{item}
                 </foreach>
             </if>
-            <if test="conditionParamRef.containsKey('timeOutPeriodStart') and conditionParamRef.timeOutPeriodStart != null">
-                ${_conditionType_} a.timeOutPeriod <![CDATA[ >= ]]> #{${_conditionParam_}.timeOutPeriodStart}
+            <if test="conditionParamRef.containsKey('yearStart') and conditionParamRef.yearStart != null">
+                ${_conditionType_} a.year <![CDATA[ >= ]]> #{${_conditionParam_}.yearStart}
             </if>
-            <if test="conditionParamRef.containsKey('timeOutPeriodEnd') and conditionParamRef.timeOutPeriodEnd != null">
-                ${_conditionType_} a.timeOutPeriod <![CDATA[ <= ]]> #{${_conditionParam_}.timeOutPeriodEnd}
+            <if test="conditionParamRef.containsKey('yearEnd') and conditionParamRef.yearEnd != null">
+                ${_conditionType_} a.year <![CDATA[ <= ]]> #{${_conditionParam_}.yearEnd}
             </if>
 
-            <if test="conditionParamRef.containsKey('nearTime')">
-                <if test="conditionParamRef.nearTime != null ">
-                    ${_conditionType_} a.nearTime = #{${_conditionParam_}.nearTime}
+            <if test="conditionParamRef.containsKey('month')">
+                <if test="conditionParamRef.month != null ">
+                    ${_conditionType_} a.month = #{${_conditionParam_}.month}
                 </if>
-                <if test="conditionParamRef.nearTime == null">
-                    ${_conditionType_} a.nearTime is null
+                <if test="conditionParamRef.month == null">
+                    ${_conditionType_} a.month is null
                 </if>
             </if>
-            <if test="conditionParamRef.containsKey('nearTimeList') and conditionParamRef.nearTimeList.size() > 0">
-                ${_conditionType_} a.nearTime in
-                <foreach collection="conditionParamRef.nearTimeList" open="(" close=")" index="index" item="item" separator=",">
+            <if test="conditionParamRef.containsKey('monthList') and conditionParamRef.monthList.size() > 0">
+                ${_conditionType_} a.month in
+                <foreach collection="conditionParamRef.monthList" open="(" close=")" index="index" item="item" separator=",">
                     #{item}
                 </foreach>
             </if>
-            <if test="conditionParamRef.containsKey('nearTimeNotList') and conditionParamRef.nearTimeNotList.size() > 0">
-                ${_conditionType_} a.nearTime not in
-                <foreach collection="conditionParamRef.nearTimeNotList" open="(" close=")" index="index" item="item" separator=",">
+            <if test="conditionParamRef.containsKey('monthNotList') and conditionParamRef.monthNotList.size() > 0">
+                ${_conditionType_} a.month not in
+                <foreach collection="conditionParamRef.monthNotList" open="(" close=")" index="index" item="item" separator=",">
                     #{item}
                 </foreach>
             </if>
-            <if test="conditionParamRef.containsKey('nearTimeStart') and conditionParamRef.nearTimeStart != null">
-                ${_conditionType_} a.nearTime <![CDATA[ >= ]]> #{${_conditionParam_}.nearTimeStart}
+            <if test="conditionParamRef.containsKey('monthStart') and conditionParamRef.monthStart != null">
+                ${_conditionType_} a.month <![CDATA[ >= ]]> #{${_conditionParam_}.monthStart}
             </if>
-            <if test="conditionParamRef.containsKey('nearTimeEnd') and conditionParamRef.nearTimeEnd != null">
-                ${_conditionType_} a.nearTime <![CDATA[ <= ]]> #{${_conditionParam_}.nearTimeEnd}
+            <if test="conditionParamRef.containsKey('monthEnd') and conditionParamRef.monthEnd != null">
+                ${_conditionType_} a.month <![CDATA[ <= ]]> #{${_conditionParam_}.monthEnd}
             </if>
 
-            <if test="conditionParamRef.containsKey('deviceStatus')">
-                <if test="conditionParamRef.deviceStatus != null ">
-                    ${_conditionType_} a.deviceStatus = #{${_conditionParam_}.deviceStatus}
+            <if test="conditionParamRef.containsKey('day')">
+                <if test="conditionParamRef.day != null ">
+                    ${_conditionType_} a.day = #{${_conditionParam_}.day}
                 </if>
-                <if test="conditionParamRef.deviceStatus == null">
-                    ${_conditionType_} a.deviceStatus is null
+                <if test="conditionParamRef.day == null">
+                    ${_conditionType_} a.day is null
                 </if>
             </if>
-            <if test="conditionParamRef.containsKey('deviceStatusList') and conditionParamRef.deviceStatusList.size() > 0">
-                ${_conditionType_} a.deviceStatus in
-                <foreach collection="conditionParamRef.deviceStatusList" open="(" close=")" index="index" item="item" separator=",">
+            <if test="conditionParamRef.containsKey('dayList') and conditionParamRef.dayList.size() > 0">
+                ${_conditionType_} a.day in
+                <foreach collection="conditionParamRef.dayList" open="(" close=")" index="index" item="item" separator=",">
                     #{item}
                 </foreach>
             </if>
-            <if test="conditionParamRef.containsKey('deviceStatusNotList') and conditionParamRef.deviceStatusNotList.size() > 0">
-                ${_conditionType_} a.deviceStatus not in
-                <foreach collection="conditionParamRef.deviceStatusNotList" open="(" close=")" index="index" item="item" separator=",">
+            <if test="conditionParamRef.containsKey('dayNotList') and conditionParamRef.dayNotList.size() > 0">
+                ${_conditionType_} a.day not in
+                <foreach collection="conditionParamRef.dayNotList" open="(" close=")" index="index" item="item" separator=",">
                     #{item}
                 </foreach>
             </if>
-            <if test="conditionParamRef.containsKey('deviceStatusStart') and conditionParamRef.deviceStatusStart != null">
-                ${_conditionType_} a.deviceStatus <![CDATA[ >= ]]> #{${_conditionParam_}.deviceStatusStart}
+            <if test="conditionParamRef.containsKey('dayStart') and conditionParamRef.dayStart != null">
+                ${_conditionType_} a.day <![CDATA[ >= ]]> #{${_conditionParam_}.dayStart}
             </if>
-            <if test="conditionParamRef.containsKey('deviceStatusEnd') and conditionParamRef.deviceStatusEnd != null">
-                ${_conditionType_} a.deviceStatus <![CDATA[ <= ]]> #{${_conditionParam_}.deviceStatusEnd}
+            <if test="conditionParamRef.containsKey('dayEnd') and conditionParamRef.dayEnd != null">
+                ${_conditionType_} a.day <![CDATA[ <= ]]> #{${_conditionParam_}.dayEnd}
             </if>
 
 
-            <if test="conditionParamRef.containsKey('deviceRemark')">
-                <if test="conditionParamRef.deviceRemark != null and conditionParamRef.deviceRemark != ''">
-                    ${_conditionType_} a.deviceRemark like #{${_conditionParam_}.deviceRemark}
+            <if test="conditionParamRef.containsKey('createTime')">
+                <if test="conditionParamRef.createTime != null ">
+                    ${_conditionType_} a.createTime = #{${_conditionParam_}.createTime}
                 </if>
-                <if test="conditionParamRef.deviceRemark == null">
-                    ${_conditionType_} a.deviceRemark is null
+                <if test="conditionParamRef.createTime == null">
+                    ${_conditionType_} a.createTime is null
                 </if>
             </if>
-            <if test="conditionParamRef.containsKey('deviceRemarkList') and conditionParamRef.deviceRemarkList.size() > 0">
-                ${_conditionType_} a.deviceRemark in
-                <foreach collection="conditionParamRef.deviceRemarkList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
+            <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('deviceRemarkNotList') and conditionParamRef.deviceRemarkNotList.size() > 0">
-                ${_conditionType_} a.deviceRemark not in
-                <foreach collection="conditionParamRef.deviceRemarkNotList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
+            <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('createUserId')">
                 <if test="conditionParamRef.createUserId != null ">
@@ -976,19 +775,19 @@
             </if>
 
 
-            <if test="conditionParamRef.containsKey('createTime')">
-                <if test="conditionParamRef.createTime != null ">
-                    ${_conditionType_} a.createTime = #{${_conditionParam_}.createTime}
+            <if test="conditionParamRef.containsKey('updateTime')">
+                <if test="conditionParamRef.updateTime != null ">
+                    ${_conditionType_} a.updateTime = #{${_conditionParam_}.updateTime}
                 </if>
-                <if test="conditionParamRef.createTime == null">
-                    ${_conditionType_} a.createTime is null
+                <if test="conditionParamRef.updateTime == null">
+                    ${_conditionType_} a.updateTime 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('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('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.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>
             <if test="conditionParamRef.containsKey('updateUserId')">
                 <if test="conditionParamRef.updateUserId != null ">
@@ -1017,21 +816,6 @@
                 ${_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>
-            <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()">
@@ -1060,79 +844,54 @@
                         <if test='orderCol.siteName != null and "DESC".equalsIgnoreCase(orderCol.siteName)'>DESC</if>
                         ,
                     </if>
-                    <if test="orderCol.containsKey('deviceId')">
-                        a.deviceId
-                        <if test='orderCol.deviceId != null and "DESC".equalsIgnoreCase(orderCol.deviceId)'>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('deviceMac')">
-                        a.deviceMac
-                        <if test='orderCol.deviceMac != null and "DESC".equalsIgnoreCase(orderCol.deviceMac)'>DESC</if>
+                    <if test="orderCol.containsKey('personId')">
+                        a.personId
+                        <if test='orderCol.personId != null and "DESC".equalsIgnoreCase(orderCol.personId)'>DESC</if>
                         ,
                     </if>
-                    <if test="orderCol.containsKey('deviceLocation')">
-                        a.deviceLocation
-                        <if test='orderCol.deviceLocation != null and "DESC".equalsIgnoreCase(orderCol.deviceLocation)'>DESC</if>
+                    <if test="orderCol.containsKey('name')">
+                        a.name
+                        <if test='orderCol.name != null and "DESC".equalsIgnoreCase(orderCol.name)'>DESC</if>
                         ,
                     </if>
-                    <if test="orderCol.containsKey('lon')">
-                        a.lon
-                        <if test='orderCol.lon != null and "DESC".equalsIgnoreCase(orderCol.lon)'>DESC</if>
+                    <if test="orderCol.containsKey('contact')">
+                        a.contact
+                        <if test='orderCol.contact != null and "DESC".equalsIgnoreCase(orderCol.contact)'>DESC</if>
                         ,
                     </if>
-                    <if test="orderCol.containsKey('lati')">
-                        a.lati
-                        <if test='orderCol.lati != null and "DESC".equalsIgnoreCase(orderCol.lati)'>DESC</if>
+                    <if test="orderCol.containsKey('idNumber')">
+                        a.idNumber
+                        <if test='orderCol.idNumber != null and "DESC".equalsIgnoreCase(orderCol.idNumber)'>DESC</if>
                         ,
                     </if>
-                    <if test="orderCol.containsKey('floor')">
-                        a.floor
-                        <if test='orderCol.floor != null and "DESC".equalsIgnoreCase(orderCol.floor)'>DESC</if>
+                    <if test="orderCol.containsKey('identifyNum')">
+                        a.identifyNum
+                        <if test='orderCol.identifyNum != null and "DESC".equalsIgnoreCase(orderCol.identifyNum)'>DESC</if>
                         ,
                     </if>
-                    <if test="orderCol.containsKey('build')">
-                        a.build
-                        <if test='orderCol.build != null and "DESC".equalsIgnoreCase(orderCol.build)'>DESC</if>
+                    <if test="orderCol.containsKey('lastIdentifyTime')">
+                        a.lastIdentifyTime
+                        <if test='orderCol.lastIdentifyTime != null and "DESC".equalsIgnoreCase(orderCol.lastIdentifyTime)'>DESC</if>
                         ,
                     </if>
-                    <if test="orderCol.containsKey('leadingOfficial')">
-                        a.leadingOfficial
-                        <if test='orderCol.leadingOfficial != null and "DESC".equalsIgnoreCase(orderCol.leadingOfficial)'>DESC</if>
+                    <if test="orderCol.containsKey('year')">
+                        a.year
+                        <if test='orderCol.year != null and "DESC".equalsIgnoreCase(orderCol.year)'>DESC</if>
                         ,
                     </if>
-                    <if test="orderCol.containsKey('leadingOfficialTelephone')">
-                        a.leadingOfficialTelephone
-                        <if test='orderCol.leadingOfficialTelephone != null and "DESC".equalsIgnoreCase(orderCol.leadingOfficialTelephone)'>DESC</if>
+                    <if test="orderCol.containsKey('month')">
+                        a.month
+                        <if test='orderCol.month != null and "DESC".equalsIgnoreCase(orderCol.month)'>DESC</if>
                         ,
                     </if>
-                    <if test="orderCol.containsKey('timeOutPeriod')">
-                        a.timeOutPeriod
-                        <if test='orderCol.timeOutPeriod != null and "DESC".equalsIgnoreCase(orderCol.timeOutPeriod)'>DESC</if>
+                    <if test="orderCol.containsKey('day')">
+                        a.day
+                        <if test='orderCol.day != null and "DESC".equalsIgnoreCase(orderCol.day)'>DESC</if>
                         ,
                     </if>
-                    <if test="orderCol.containsKey('nearTime')">
-                        a.nearTime
-                        <if test='orderCol.nearTime != null and "DESC".equalsIgnoreCase(orderCol.nearTime)'>DESC</if>
-                        ,
-                    </if>
-                    <if test="orderCol.containsKey('deviceStatus')">
-                        a.deviceStatus
-                        <if test='orderCol.deviceStatus != null and "DESC".equalsIgnoreCase(orderCol.deviceStatus)'>DESC</if>
-                        ,
-                    </if>
-                    <if test="orderCol.containsKey('deviceRemark')">
-                        a.deviceRemark
-                        <if test='orderCol.deviceRemark != null and "DESC".equalsIgnoreCase(orderCol.deviceRemark)'>DESC</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('createUserId')">
@@ -1140,9 +899,9 @@
                         <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 test="orderCol.containsKey('updateTime')">
+                        a.updateTime
+                        <if test='orderCol.updateTime != null and "DESC".equalsIgnoreCase(orderCol.updateTime)'>DESC</if>
                         ,
                     </if>
                     <if test="orderCol.containsKey('updateUserId')">
@@ -1150,11 +909,6 @@
                         <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>

refined-manager/src/main/resources/sqlmap/module/monitor/MonitorAlarmRecordMapper.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
+"mybatis-3-mapper.dtd">
+<mapper namespace="com.mortals.xhx.module.monitor.dao.ibatis.MonitorAlarmRecordDaoImpl">
+
+    <!-- 字段和属性映射 -->
+    <resultMap type="MonitorAlarmRecordEntity" id="MonitorAlarmRecordEntity-Map">
+            <id  property="id" column="id" />
+            <result property="alarmId" column="alarmId" />
+            <result property="reservationService" column="reservationService" />
+            <result property="reservationNumber" column="reservationNumber" />
+            <result property="monitorTime" column="monitorTime" />
+            <result property="monitorDeviceId" column="monitorDeviceId" />
+            <result property="monitorDevice" column="monitorDevice" />
+            <result property="checkInMethod" column="checkInMethod" />
+            <result property="monitorCertificate" column="monitorCertificate" />
+            <result property="picUri" column="picUri" />
+            <result property="serverIndexCode" column="serverIndexCode" />
+            <result property="createTime" column="createTime" />
+            <result property="createUserId" column="createUserId" />
+            <result property="updateTime" column="updateTime" />
+            <result property="updateUserId" column="updateUserId" />
+            
+    </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,
+                </if>
+                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('alarmId') or colPickMode == 1 and data.containsKey('alarmId')))">
+                    a.alarmId,
+                </if>
+                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('reservationService') or colPickMode == 1 and data.containsKey('reservationService')))">
+                    a.reservationService,
+                </if>
+                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('reservationNumber') or colPickMode == 1 and data.containsKey('reservationNumber')))">
+                    a.reservationNumber,
+                </if>
+                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('monitorTime') or colPickMode == 1 and data.containsKey('monitorTime')))">
+                    a.monitorTime,
+                </if>
+                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('monitorDeviceId') or colPickMode == 1 and data.containsKey('monitorDeviceId')))">
+                    a.monitorDeviceId,
+                </if>
+                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('monitorDevice') or colPickMode == 1 and data.containsKey('monitorDevice')))">
+                    a.monitorDevice,
+                </if>
+                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('checkInMethod') or colPickMode == 1 and data.containsKey('checkInMethod')))">
+                    a.checkInMethod,
+                </if>
+                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('monitorCertificate') or colPickMode == 1 and data.containsKey('monitorCertificate')))">
+                    a.monitorCertificate,
+                </if>
+                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('picUri') or colPickMode == 1 and data.containsKey('picUri')))">
+                    a.picUri,
+                </if>
+                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('serverIndexCode') or colPickMode == 1 and data.containsKey('serverIndexCode')))">
+                    a.serverIndexCode,
+                </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('createUserId') or colPickMode == 1 and data.containsKey('createUserId')))">
+                    a.createUserId,
+                </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>
+                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateUserId') or colPickMode == 1 and data.containsKey('updateUserId')))">
+                    a.updateUserId,
+                </if>
+        </trim>
+    </sql>
+    <!-- 新增 区分主键自增加还是业务插入 -->
+    <insert id="insert" parameterType="MonitorAlarmRecordEntity"  useGeneratedKeys="true" keyProperty="id">
+        insert into mortals_xhx_monitor_alarm_record
+        (alarmId,reservationService,reservationNumber,monitorTime,monitorDeviceId,monitorDevice,checkInMethod,monitorCertificate,picUri,serverIndexCode,createTime,createUserId,updateTime,updateUserId)
+        VALUES
+        (#{alarmId},#{reservationService},#{reservationNumber},#{monitorTime},#{monitorDeviceId},#{monitorDevice},#{checkInMethod},#{monitorCertificate},#{picUri},#{serverIndexCode},#{createTime},#{createUserId},#{updateTime},#{updateUserId})
+    </insert>
+
+    <!-- 批量新增 -->
+    <insert id="insertBatch" parameterType="paramDto">
+        insert into mortals_xhx_monitor_alarm_record
+        (alarmId,reservationService,reservationNumber,monitorTime,monitorDeviceId,monitorDevice,checkInMethod,monitorCertificate,picUri,serverIndexCode,createTime,createUserId,updateTime,updateUserId)
+        VALUES
+        <foreach collection="data.dataList" item="item" index="index" separator="," >
+            (#{item.alarmId},#{item.reservationService},#{item.reservationNumber},#{item.monitorTime},#{item.monitorDeviceId},#{item.monitorDevice},#{item.checkInMethod},#{item.monitorCertificate},#{item.picUri},#{item.serverIndexCode},#{item.createTime},#{item.createUserId},#{item.updateTime},#{item.updateUserId})
+        </foreach>
+    </insert>
+
+
+    <!-- 根据ParamDto更新 -->
+    <update id="update" parameterType="paramDto">
+        update mortals_xhx_monitor_alarm_record as a
+        set
+        <trim suffixOverrides="," suffix="">
+            <if test="(colPickMode==0 and data.containsKey('alarmId')) or (colPickMode==1 and !data.containsKey('alarmId'))">
+                a.alarmId=#{data.alarmId},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('alarmIdIncrement')) or (colPickMode==1 and !data.containsKey('alarmIdIncrement'))">
+                a.alarmId=ifnull(a.alarmId,0) + #{data.alarmIdIncrement},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('reservationService')) or (colPickMode==1 and !data.containsKey('reservationService'))">
+                a.reservationService=#{data.reservationService},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('reservationNumber')) or (colPickMode==1 and !data.containsKey('reservationNumber'))">
+                a.reservationNumber=#{data.reservationNumber},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('monitorTime')) or (colPickMode==1 and !data.containsKey('monitorTime'))">
+                a.monitorTime=#{data.monitorTime},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('monitorDeviceId')) or (colPickMode==1 and !data.containsKey('monitorDeviceId'))">
+                a.monitorDeviceId=#{data.monitorDeviceId},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('monitorDeviceIdIncrement')) or (colPickMode==1 and !data.containsKey('monitorDeviceIdIncrement'))">
+                a.monitorDeviceId=ifnull(a.monitorDeviceId,0) + #{data.monitorDeviceIdIncrement},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('monitorDevice')) or (colPickMode==1 and !data.containsKey('monitorDevice'))">
+                a.monitorDevice=#{data.monitorDevice},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('checkInMethod')) or (colPickMode==1 and !data.containsKey('checkInMethod'))">
+                a.checkInMethod=#{data.checkInMethod},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('checkInMethodIncrement')) or (colPickMode==1 and !data.containsKey('checkInMethodIncrement'))">
+                a.checkInMethod=ifnull(a.checkInMethod,0) + #{data.checkInMethodIncrement},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('monitorCertificate')) or (colPickMode==1 and !data.containsKey('monitorCertificate'))">
+                a.monitorCertificate=#{data.monitorCertificate},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('picUri')) or (colPickMode==1 and !data.containsKey('picUri'))">
+                a.picUri=#{data.picUri},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('serverIndexCode')) or (colPickMode==1 and !data.containsKey('serverIndexCode'))">
+                a.serverIndexCode=#{data.serverIndexCode},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('createTime')) or (colPickMode==1 and !data.containsKey('createTime'))">
+                a.createTime=#{data.createTime},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('createUserId')) or (colPickMode==1 and !data.containsKey('createUserId'))">
+                a.createUserId=#{data.createUserId},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('createUserIdIncrement')) or (colPickMode==1 and !data.containsKey('createUserIdIncrement'))">
+                a.createUserId=ifnull(a.createUserId,0) + #{data.createUserIdIncrement},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('updateTime')) or (colPickMode==1 and !data.containsKey('updateTime'))">
+                a.updateTime=#{data.updateTime},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('updateUserId')) or (colPickMode==1 and !data.containsKey('updateUserId'))">
+                a.updateUserId=#{data.updateUserId},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('updateUserIdIncrement')) or (colPickMode==1 and !data.containsKey('updateUserIdIncrement'))">
+                a.updateUserId=ifnull(a.updateUserId,0) + #{data.updateUserIdIncrement},
+            </if>
+        </trim>
+        <trim suffixOverrides="where" suffix="">
+            where
+            <trim prefixOverrides="and" prefix="">
+                <include refid="_condition_"/>
+            </trim>
+        </trim>
+    </update>
+    <!-- 批量更新 -->
+    <update id="updateBatch" parameterType="paramDto">
+        update mortals_xhx_monitor_alarm_record as a
+        <trim prefix="set" suffixOverrides=",">
+                        <trim prefix="alarmId=(case" suffix="ELSE alarmId end),">
+                            <foreach collection="data.dataList" item="item" index="index" separator="" >
+                                <choose>
+                                    <when test="(colPickMode==0 and item.containsKey('alarmId')) or (colPickMode==1 and !item.containsKey('alarmId'))">
+                                        when a.id=#{item.id} then #{item.alarmId}
+                                    </when>
+                                    <when test="(colPickMode==0 and item.containsKey('alarmIdIncrement')) or (colPickMode==1 and !item.containsKey('alarmIdIncrement'))">
+                                        when a.id=#{item.id} then ifnull(a.alarmId,0) + #{item.alarmIdIncrement}
+                                    </when>
+                                </choose>
+                            </foreach>
+                        </trim>
+                <trim prefix="reservationService=(case" suffix="ELSE reservationService end),">
+                    <foreach collection="data.dataList" item="item" index="index" separator="" >
+                        <if test="(colPickMode==0 and item.containsKey('reservationService')) or (colPickMode==1 and !item.containsKey('reservationService'))">
+                            when a.id=#{item.id} then #{item.reservationService}
+                        </if>
+                    </foreach>
+                </trim>
+                <trim prefix="reservationNumber=(case" suffix="ELSE reservationNumber end),">
+                    <foreach collection="data.dataList" item="item" index="index" separator="" >
+                        <if test="(colPickMode==0 and item.containsKey('reservationNumber')) or (colPickMode==1 and !item.containsKey('reservationNumber'))">
+                            when a.id=#{item.id} then #{item.reservationNumber}
+                        </if>
+                    </foreach>
+                </trim>
+                <trim prefix="monitorTime=(case" suffix="ELSE monitorTime end),">
+                    <foreach collection="data.dataList" item="item" index="index" separator="" >
+                        <if test="(colPickMode==0 and item.containsKey('monitorTime')) or (colPickMode==1 and !item.containsKey('monitorTime'))">
+                            when a.id=#{item.id} then #{item.monitorTime}
+                        </if>
+                    </foreach>
+                </trim>
+                        <trim prefix="monitorDeviceId=(case" suffix="ELSE monitorDeviceId end),">
+                            <foreach collection="data.dataList" item="item" index="index" separator="" >
+                                <choose>
+                                    <when test="(colPickMode==0 and item.containsKey('monitorDeviceId')) or (colPickMode==1 and !item.containsKey('monitorDeviceId'))">
+                                        when a.id=#{item.id} then #{item.monitorDeviceId}
+                                    </when>
+                                    <when test="(colPickMode==0 and item.containsKey('monitorDeviceIdIncrement')) or (colPickMode==1 and !item.containsKey('monitorDeviceIdIncrement'))">
+                                        when a.id=#{item.id} then ifnull(a.monitorDeviceId,0) + #{item.monitorDeviceIdIncrement}
+                                    </when>
+                                </choose>
+                            </foreach>
+                        </trim>
+                <trim prefix="monitorDevice=(case" suffix="ELSE monitorDevice end),">
+                    <foreach collection="data.dataList" item="item" index="index" separator="" >
+                        <if test="(colPickMode==0 and item.containsKey('monitorDevice')) or (colPickMode==1 and !item.containsKey('monitorDevice'))">
+                            when a.id=#{item.id} then #{item.monitorDevice}
+                        </if>
+                    </foreach>
+                </trim>
+                        <trim prefix="checkInMethod=(case" suffix="ELSE checkInMethod end),">
+                            <foreach collection="data.dataList" item="item" index="index" separator="" >
+                                <choose>
+                                    <when test="(colPickMode==0 and item.containsKey('checkInMethod')) or (colPickMode==1 and !item.containsKey('checkInMethod'))">
+                                        when a.id=#{item.id} then #{item.checkInMethod}
+                                    </when>
+                                    <when test="(colPickMode==0 and item.containsKey('checkInMethodIncrement')) or (colPickMode==1 and !item.containsKey('checkInMethodIncrement'))">
+                                        when a.id=#{item.id} then ifnull(a.checkInMethod,0) + #{item.checkInMethodIncrement}
+                                    </when>
+                                </choose>
+                            </foreach>
+                        </trim>
+                <trim prefix="monitorCertificate=(case" suffix="ELSE monitorCertificate end),">
+                    <foreach collection="data.dataList" item="item" index="index" separator="" >
+                        <if test="(colPickMode==0 and item.containsKey('monitorCertificate')) or (colPickMode==1 and !item.containsKey('monitorCertificate'))">
+                            when a.id=#{item.id} then #{item.monitorCertificate}
+                        </if>
+                    </foreach>
+                </trim>
+                <trim prefix="picUri=(case" suffix="ELSE picUri end),">
+                    <foreach collection="data.dataList" item="item" index="index" separator="" >
+                        <if test="(colPickMode==0 and item.containsKey('picUri')) or (colPickMode==1 and !item.containsKey('picUri'))">
+                            when a.id=#{item.id} then #{item.picUri}
+                        </if>
+                    </foreach>
+                </trim>
+                <trim prefix="serverIndexCode=(case" suffix="ELSE serverIndexCode end),">
+                    <foreach collection="data.dataList" item="item" index="index" separator="" >
+                        <if test="(colPickMode==0 and item.containsKey('serverIndexCode')) or (colPickMode==1 and !item.containsKey('serverIndexCode'))">
+                            when a.id=#{item.id} then #{item.serverIndexCode}
+                        </if>
+                    </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="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="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="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>
+        where id in
+        <foreach collection="data.dataList" item="item" index="index" open="(" separator="," close=")">
+            #{item.id}
+        </foreach>
+    </update>
+    <!-- 根据主健查询 -->
+    <select id="getByKey" parameterType="paramDto" resultMap="MonitorAlarmRecordEntity-Map">
+        select <include refid="_columns"/>
+        from mortals_xhx_monitor_alarm_record as a
+        where a.id=#{condition.id}
+    </select>
+    <!-- 根据主健删除 -->
+    <delete id="deleteByKey" parameterType="paramDto">
+        delete a.* from mortals_xhx_monitor_alarm_record as a where a.id=#{condition.id}
+    </delete>
+    <!-- 根据主健删除一批，针对单一主健有效 -->
+    <delete id="deleteByKeys">
+        delete from mortals_xhx_monitor_alarm_record where id in
+        <foreach collection="array" item="item" index="index" open="(" separator="," close=")">
+            #{item}
+        </foreach>
+    </delete>
+    <!-- 根据主健列表删除一批，针对单一主健有效 -->
+    <delete id="deleteByKeyList">
+        delete from mortals_xhx_monitor_alarm_record where id in
+        <foreach collection="list" item="item" index="index" open="(" separator="," close=")">
+            #{item}
+        </foreach>
+    </delete>
+
+    <!-- 根据对象列表删除一批，针对单一主健有效 -->
+    <delete id="deleteByEntityList">
+        delete from mortals_xhx_monitor_alarm_record where id in
+        <foreach collection="list" item="item" index="index" open="(" separator="," close=")">
+            #{item.id}
+        </foreach>
+    </delete>
+    <!-- 根据paramDto删除一批 -->
+    <delete id="deleteByMap" parameterType="paramDto">
+        delete a.* from mortals_xhx_monitor_alarm_record as a
+        <trim suffixOverrides="where" suffix="">
+            where
+            <trim prefixOverrides="and" prefix="">
+                <include refid="_condition_"/>
+            </trim>
+        </trim>
+    </delete>
+    <!-- 获取列表 -->
+    <select id="getList" parameterType="paramDto" resultMap="MonitorAlarmRecordEntity-Map">
+        select <include refid="_columns"/>
+        from mortals_xhx_monitor_alarm_record as a
+        <trim suffixOverrides="where" suffix="">
+            where
+            <trim prefixOverrides="and" prefix="">
+                <include refid="_condition_"/>
+            </trim>
+        </trim>
+        <include refid="_orderCols_"/>
+    </select>
+
+
+
+    <!-- 获取 -->
+    <select id="getListCount" parameterType="paramDto" resultType="int">
+        select count(1)
+        from mortals_xhx_monitor_alarm_record as a
+        <trim suffixOverrides="where" suffix="">
+            where
+            <trim prefixOverrides="and" prefix="">
+                <include refid="_condition_"/>
+            </trim>
+        </trim>
+    </select>
+    <!-- 条件映射 -->
+    <sql id="_condition_">
+        <if test="condition != null and !condition.isEmpty()">
+            <!-- 条件映射-普通条件 -->
+            <include refid="_condition_param_">
+                <property name="_conditionParam_" value="condition"/>
+                <property name="_conditionType_" value="and"/>
+            </include>
+            <!-- 条件映射-集合之间使用AND，集合中元素使用OR-(list[0].1 or list[0].2) and (list[1].3 or list[1].4) -->
+            <if test="condition.containsKey('andConditionList') and !condition.andConditionList.isEmpty()">
+                and
+                <foreach collection="condition.andConditionList" open="(" close=")" index="index" item="andCondition" separator=" and ">
+                    <trim prefixOverrides="or" prefix="(" suffix=")">
+                        <include refid="_condition_param_">
+                            <property name="_conditionParam_" value="andCondition"/>
+                            <property name="_conditionType_" value="or"/>
+                        </include>
+                    </trim>
+                </foreach>
+            </if>
+            <!-- 条件映射-集合之间使用OR，集合中元素使用AND-(list[0].1 and list[0].2) or (list[1].3 and list[1].4) -->
+            <if test="condition.containsKey('orConditionList') and !condition.orConditionList.isEmpty()">
+                and
+                <foreach collection="condition.orConditionList" open="(" close=")" index="index" item="orCondition" separator=" or ">
+                    <trim prefixOverrides="and" prefix="(" suffix=")">
+                        <include refid="_condition_param_">
+                            <property name="_conditionParam_" value="orCondition"/>
+                            <property name="_conditionType_" value="and"/>
+                        </include>
+                    </trim>
+                </foreach>
+            </if>
+        </if>
+    </sql>
+    <!-- 条件映射-代参数 -->
+    <sql id="_condition_param_">
+        <bind name="conditionParamRef" value="${_conditionParam_}"/>
+        <if test="conditionParamRef.containsKey('id')">
+            <if test="conditionParamRef.id != null">
+                ${_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') and conditionParamRef.idList.size() > 0">
+                ${_conditionType_} a.id in
+                <foreach collection="conditionParamRef.idList" open="(" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+            <if test="conditionParamRef.containsKey('idNotList') and conditionParamRef.idNotList.size() > 0">
+                ${_conditionType_} a.id not in
+                <foreach collection="conditionParamRef.idNotList" 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('alarmId')">
+                <if test="conditionParamRef.alarmId != null ">
+                    ${_conditionType_} a.alarmId = #{${_conditionParam_}.alarmId}
+                </if>
+                <if test="conditionParamRef.alarmId == null">
+                    ${_conditionType_} a.alarmId is null
+                </if>
+            </if>
+            <if test="conditionParamRef.containsKey('alarmIdList') and conditionParamRef.alarmIdList.size() > 0">
+                ${_conditionType_} a.alarmId in
+                <foreach collection="conditionParamRef.alarmIdList" open="(" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+            <if test="conditionParamRef.containsKey('alarmIdNotList') and conditionParamRef.alarmIdNotList.size() > 0">
+                ${_conditionType_} a.alarmId not in
+                <foreach collection="conditionParamRef.alarmIdNotList" open="(" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+            <if test="conditionParamRef.containsKey('alarmIdStart') and conditionParamRef.alarmIdStart != null">
+                ${_conditionType_} a.alarmId <![CDATA[ >= ]]> #{${_conditionParam_}.alarmIdStart}
+            </if>
+            <if test="conditionParamRef.containsKey('alarmIdEnd') and conditionParamRef.alarmIdEnd != null">
+                ${_conditionType_} a.alarmId <![CDATA[ <= ]]> #{${_conditionParam_}.alarmIdEnd}
+            </if>
+
+
+            <if test="conditionParamRef.containsKey('reservationService')">
+                <if test="conditionParamRef.reservationService != null and conditionParamRef.reservationService != ''">
+                    ${_conditionType_} a.reservationService like #{${_conditionParam_}.reservationService}
+                </if>
+                <if test="conditionParamRef.reservationService == null">
+                    ${_conditionType_} a.reservationService is null
+                </if>
+            </if>
+            <if test="conditionParamRef.containsKey('reservationServiceList') and conditionParamRef.reservationServiceList.size() > 0">
+                ${_conditionType_} a.reservationService in
+                <foreach collection="conditionParamRef.reservationServiceList" open="(" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+            <if test="conditionParamRef.containsKey('reservationServiceNotList') and conditionParamRef.reservationServiceNotList.size() > 0">
+                ${_conditionType_} a.reservationService not in
+                <foreach collection="conditionParamRef.reservationServiceNotList" open="(" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+
+            <if test="conditionParamRef.containsKey('reservationNumber')">
+                <if test="conditionParamRef.reservationNumber != null and conditionParamRef.reservationNumber != ''">
+                    ${_conditionType_} a.reservationNumber like #{${_conditionParam_}.reservationNumber}
+                </if>
+                <if test="conditionParamRef.reservationNumber == null">
+                    ${_conditionType_} a.reservationNumber is null
+                </if>
+            </if>
+            <if test="conditionParamRef.containsKey('reservationNumberList') and conditionParamRef.reservationNumberList.size() > 0">
+                ${_conditionType_} a.reservationNumber in
+                <foreach collection="conditionParamRef.reservationNumberList" open="(" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+            <if test="conditionParamRef.containsKey('reservationNumberNotList') and conditionParamRef.reservationNumberNotList.size() > 0">
+                ${_conditionType_} a.reservationNumber not in
+                <foreach collection="conditionParamRef.reservationNumberNotList" open="(" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+
+            <if test="conditionParamRef.containsKey('monitorTime')">
+                <if test="conditionParamRef.monitorTime != null ">
+                    ${_conditionType_} a.monitorTime = #{${_conditionParam_}.monitorTime}
+                </if>
+                <if test="conditionParamRef.monitorTime == null">
+                    ${_conditionType_} a.monitorTime is null
+                </if>
+            </if>
+            <if test="conditionParamRef.containsKey('monitorTimeStart') and conditionParamRef.monitorTimeStart != null and conditionParamRef.monitorTimeStart!=''">
+                ${_conditionType_} a.monitorTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.monitorTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
+            </if>
+            <if test="conditionParamRef.containsKey('monitorTimeEnd') and conditionParamRef.monitorTimeEnd != null and conditionParamRef.monitorTimeEnd!=''">
+                ${_conditionType_} a.monitorTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.monitorTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
+            </if>
+            <if test="conditionParamRef.containsKey('monitorDeviceId')">
+                <if test="conditionParamRef.monitorDeviceId != null ">
+                    ${_conditionType_} a.monitorDeviceId = #{${_conditionParam_}.monitorDeviceId}
+                </if>
+                <if test="conditionParamRef.monitorDeviceId == null">
+                    ${_conditionType_} a.monitorDeviceId is null
+                </if>
+            </if>
+            <if test="conditionParamRef.containsKey('monitorDeviceIdList') and conditionParamRef.monitorDeviceIdList.size() > 0">
+                ${_conditionType_} a.monitorDeviceId in
+                <foreach collection="conditionParamRef.monitorDeviceIdList" open="(" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+            <if test="conditionParamRef.containsKey('monitorDeviceIdNotList') and conditionParamRef.monitorDeviceIdNotList.size() > 0">
+                ${_conditionType_} a.monitorDeviceId not in
+                <foreach collection="conditionParamRef.monitorDeviceIdNotList" open="(" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+            <if test="conditionParamRef.containsKey('monitorDeviceIdStart') and conditionParamRef.monitorDeviceIdStart != null">
+                ${_conditionType_} a.monitorDeviceId <![CDATA[ >= ]]> #{${_conditionParam_}.monitorDeviceIdStart}
+            </if>
+            <if test="conditionParamRef.containsKey('monitorDeviceIdEnd') and conditionParamRef.monitorDeviceIdEnd != null">
+                ${_conditionType_} a.monitorDeviceId <![CDATA[ <= ]]> #{${_conditionParam_}.monitorDeviceIdEnd}
+            </if>
+
+
+            <if test="conditionParamRef.containsKey('monitorDevice')">
+                <if test="conditionParamRef.monitorDevice != null and conditionParamRef.monitorDevice != ''">
+                    ${_conditionType_} a.monitorDevice like #{${_conditionParam_}.monitorDevice}
+                </if>
+                <if test="conditionParamRef.monitorDevice == null">
+                    ${_conditionType_} a.monitorDevice is null
+                </if>
+            </if>
+            <if test="conditionParamRef.containsKey('monitorDeviceList') and conditionParamRef.monitorDeviceList.size() > 0">
+                ${_conditionType_} a.monitorDevice in
+                <foreach collection="conditionParamRef.monitorDeviceList" open="(" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+            <if test="conditionParamRef.containsKey('monitorDeviceNotList') and conditionParamRef.monitorDeviceNotList.size() > 0">
+                ${_conditionType_} a.monitorDevice not in
+                <foreach collection="conditionParamRef.monitorDeviceNotList" open="(" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+            <if test="conditionParamRef.containsKey('checkInMethod')">
+                <if test="conditionParamRef.checkInMethod != null ">
+                    ${_conditionType_} a.checkInMethod = #{${_conditionParam_}.checkInMethod}
+                </if>
+                <if test="conditionParamRef.checkInMethod == null">
+                    ${_conditionType_} a.checkInMethod is null
+                </if>
+            </if>
+            <if test="conditionParamRef.containsKey('checkInMethodList') and conditionParamRef.checkInMethodList.size() > 0">
+                ${_conditionType_} a.checkInMethod in
+                <foreach collection="conditionParamRef.checkInMethodList" open="(" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+            <if test="conditionParamRef.containsKey('checkInMethodNotList') and conditionParamRef.checkInMethodNotList.size() > 0">
+                ${_conditionType_} a.checkInMethod not in
+                <foreach collection="conditionParamRef.checkInMethodNotList" open="(" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+            <if test="conditionParamRef.containsKey('checkInMethodStart') and conditionParamRef.checkInMethodStart != null">
+                ${_conditionType_} a.checkInMethod <![CDATA[ >= ]]> #{${_conditionParam_}.checkInMethodStart}
+            </if>
+            <if test="conditionParamRef.containsKey('checkInMethodEnd') and conditionParamRef.checkInMethodEnd != null">
+                ${_conditionType_} a.checkInMethod <![CDATA[ <= ]]> #{${_conditionParam_}.checkInMethodEnd}
+            </if>
+
+
+            <if test="conditionParamRef.containsKey('monitorCertificate')">
+                <if test="conditionParamRef.monitorCertificate != null and conditionParamRef.monitorCertificate != ''">
+                    ${_conditionType_} a.monitorCertificate like #{${_conditionParam_}.monitorCertificate}
+                </if>
+                <if test="conditionParamRef.monitorCertificate == null">
+                    ${_conditionType_} a.monitorCertificate is null
+                </if>
+            </if>
+            <if test="conditionParamRef.containsKey('monitorCertificateList') and conditionParamRef.monitorCertificateList.size() > 0">
+                ${_conditionType_} a.monitorCertificate in
+                <foreach collection="conditionParamRef.monitorCertificateList" open="(" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+            <if test="conditionParamRef.containsKey('monitorCertificateNotList') and conditionParamRef.monitorCertificateNotList.size() > 0">
+                ${_conditionType_} a.monitorCertificate not in
+                <foreach collection="conditionParamRef.monitorCertificateNotList" open="(" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+
+            <if test="conditionParamRef.containsKey('picUri')">
+                <if test="conditionParamRef.picUri != null and conditionParamRef.picUri != ''">
+                    ${_conditionType_} a.picUri like #{${_conditionParam_}.picUri}
+                </if>
+                <if test="conditionParamRef.picUri == null">
+                    ${_conditionType_} a.picUri is null
+                </if>
+            </if>
+            <if test="conditionParamRef.containsKey('picUriList') and conditionParamRef.picUriList.size() > 0">
+                ${_conditionType_} a.picUri in
+                <foreach collection="conditionParamRef.picUriList" open="(" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+            <if test="conditionParamRef.containsKey('picUriNotList') and conditionParamRef.picUriNotList.size() > 0">
+                ${_conditionType_} a.picUri not in
+                <foreach collection="conditionParamRef.picUriNotList" open="(" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+
+            <if test="conditionParamRef.containsKey('serverIndexCode')">
+                <if test="conditionParamRef.serverIndexCode != null and conditionParamRef.serverIndexCode != ''">
+                    ${_conditionType_} a.serverIndexCode like #{${_conditionParam_}.serverIndexCode}
+                </if>
+                <if test="conditionParamRef.serverIndexCode == null">
+                    ${_conditionType_} a.serverIndexCode is null
+                </if>
+            </if>
+            <if test="conditionParamRef.containsKey('serverIndexCodeList') and conditionParamRef.serverIndexCodeList.size() > 0">
+                ${_conditionType_} a.serverIndexCode in
+                <foreach collection="conditionParamRef.serverIndexCodeList" open="(" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+            <if test="conditionParamRef.containsKey('serverIndexCodeNotList') and conditionParamRef.serverIndexCodeNotList.size() > 0">
+                ${_conditionType_} a.serverIndexCode not in
+                <foreach collection="conditionParamRef.serverIndexCodeNotList" open="(" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+            </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>
+            <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('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') and conditionParamRef.createUserIdList.size() > 0">
+                ${_conditionType_} a.createUserId in
+                <foreach collection="conditionParamRef.createUserIdList" open="(" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+            <if test="conditionParamRef.containsKey('createUserIdNotList') and conditionParamRef.createUserIdNotList.size() > 0">
+                ${_conditionType_} a.createUserId not in
+                <foreach collection="conditionParamRef.createUserIdNotList" 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('updateTime')">
+                <if test="conditionParamRef.updateTime != null ">
+                    ${_conditionType_} a.updateTime = #{${_conditionParam_}.updateTime}
+                </if>
+                <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>
+            <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') and conditionParamRef.updateUserIdList.size() > 0">
+                ${_conditionType_} a.updateUserId in
+                <foreach collection="conditionParamRef.updateUserIdList" open="(" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+            <if test="conditionParamRef.containsKey('updateUserIdNotList') and conditionParamRef.updateUserIdNotList.size() > 0">
+                ${_conditionType_} a.updateUserId not in
+                <foreach collection="conditionParamRef.updateUserIdNotList" 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>
+
+    </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}
+                </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('alarmId')">
+                        a.alarmId
+                        <if test='orderCol.alarmId != null and "DESC".equalsIgnoreCase(orderCol.alarmId)'>DESC</if>
+                        ,
+                    </if>
+                    <if test="orderCol.containsKey('reservationService')">
+                        a.reservationService
+                        <if test='orderCol.reservationService != null and "DESC".equalsIgnoreCase(orderCol.reservationService)'>DESC</if>
+                        ,
+                    </if>
+                    <if test="orderCol.containsKey('reservationNumber')">
+                        a.reservationNumber
+                        <if test='orderCol.reservationNumber != null and "DESC".equalsIgnoreCase(orderCol.reservationNumber)'>DESC</if>
+                        ,
+                    </if>
+                    <if test="orderCol.containsKey('monitorTime')">
+                        a.monitorTime
+                        <if test='orderCol.monitorTime != null and "DESC".equalsIgnoreCase(orderCol.monitorTime)'>DESC</if>
+                        ,
+                    </if>
+                    <if test="orderCol.containsKey('monitorDeviceId')">
+                        a.monitorDeviceId
+                        <if test='orderCol.monitorDeviceId != null and "DESC".equalsIgnoreCase(orderCol.monitorDeviceId)'>DESC</if>
+                        ,
+                    </if>
+                    <if test="orderCol.containsKey('monitorDevice')">
+                        a.monitorDevice
+                        <if test='orderCol.monitorDevice != null and "DESC".equalsIgnoreCase(orderCol.monitorDevice)'>DESC</if>
+                        ,
+                    </if>
+                    <if test="orderCol.containsKey('checkInMethod')">
+                        a.checkInMethod
+                        <if test='orderCol.checkInMethod != null and "DESC".equalsIgnoreCase(orderCol.checkInMethod)'>DESC</if>
+                        ,
+                    </if>
+                    <if test="orderCol.containsKey('monitorCertificate')">
+                        a.monitorCertificate
+                        <if test='orderCol.monitorCertificate != null and "DESC".equalsIgnoreCase(orderCol.monitorCertificate)'>DESC</if>
+                        ,
+                    </if>
+                    <if test="orderCol.containsKey('picUri')">
+                        a.picUri
+                        <if test='orderCol.picUri != null and "DESC".equalsIgnoreCase(orderCol.picUri)'>DESC</if>
+                        ,
+                    </if>
+                    <if test="orderCol.containsKey('serverIndexCode')">
+                        a.serverIndexCode
+                        <if test='orderCol.serverIndexCode != null and "DESC".equalsIgnoreCase(orderCol.serverIndexCode)'>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('createUserId')">
+                        a.createUserId
+                        <if test='orderCol.createUserId != null and "DESC".equalsIgnoreCase(orderCol.createUserId)'>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('updateUserId')">
+                        a.updateUserId
+                        <if test='orderCol.updateUserId != null and "DESC".equalsIgnoreCase(orderCol.updateUserId)'>DESC</if>
+                        ,
+                    </if>
+            </trim>
+        </if>
+    </sql>
+    <sql id="_group_by_">
+        <if test="groupList != null and !groupList.isEmpty()">
+            GROUP BY
+            <trim suffixOverrides=","  suffix="">
+                <foreach collection="groupList" open="" close="" index="index" item="item" separator=",">
+                    ${item}
+                </foreach>
+            </trim>
+        </if>
+    </sql>
+</mapper>
\ No newline at end of file

refined-manager/src/main/resources/sqlmap/module/notice/NoticeMapper.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
+"mybatis-3-mapper.dtd">
+<mapper namespace="com.mortals.xhx.module.notice.dao.ibatis.NoticeDaoImpl">
+
+    <!-- 字段和属性映射 -->
+    <resultMap type="NoticeEntity" id="NoticeEntity-Map">
+            <id  property="id" column="id" />
+            <result property="userId" column="userId" />
+            <result property="title" column="title" />
+            <result property="content" column="content" />
+            <result property="read" column="read" />
+            <result property="priority" column="priority" />
+            <result property="expireTime" column="expireTime" />
+            <result property="sourceType" column="sourceType" />
+            <result property="createTime" column="createTime" />
+            <result property="createUserId" column="createUserId" />
+            <result property="updateTime" column="updateTime" />
+            <result property="updateUserId" column="updateUserId" />
+            
+    </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,
+                </if>
+                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('userId') or colPickMode == 1 and data.containsKey('userId')))">
+                    a.userId,
+                </if>
+                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('title') or colPickMode == 1 and data.containsKey('title')))">
+                    a.title,
+                </if>
+                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('content') or colPickMode == 1 and data.containsKey('content')))">
+                    a.content,
+                </if>
+                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('read') or colPickMode == 1 and data.containsKey('read')))">
+                    a.`read`,
+                </if>
+                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('priority') or colPickMode == 1 and data.containsKey('priority')))">
+                    a.priority,
+                </if>
+                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('expireTime') or colPickMode == 1 and data.containsKey('expireTime')))">
+                    a.expireTime,
+                </if>
+                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('sourceType') or colPickMode == 1 and data.containsKey('sourceType')))">
+                    a.sourceType,
+                </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('createUserId') or colPickMode == 1 and data.containsKey('createUserId')))">
+                    a.createUserId,
+                </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>
+                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateUserId') or colPickMode == 1 and data.containsKey('updateUserId')))">
+                    a.updateUserId,
+                </if>
+        </trim>
+    </sql>
+    <!-- 新增 区分主键自增加还是业务插入 -->
+    <insert id="insert" parameterType="NoticeEntity"  useGeneratedKeys="true" keyProperty="id">
+        insert into mortals_xhx_notice
+        (userId,title,content,`read`,priority,expireTime,sourceType,createTime,createUserId,updateTime,updateUserId)
+        VALUES
+        (#{userId},#{title},#{content},#{read},#{priority},#{expireTime},#{sourceType},#{createTime},#{createUserId},#{updateTime},#{updateUserId})
+    </insert>
+
+    <!-- 批量新增 -->
+    <insert id="insertBatch" parameterType="paramDto">
+        insert into mortals_xhx_notice
+        (userId,title,content,`read`,priority,expireTime,sourceType,createTime,createUserId,updateTime,updateUserId)
+        VALUES
+        <foreach collection="data.dataList" item="item" index="index" separator="," >
+            (#{item.userId},#{item.title},#{item.content},#{item.read},#{item.priority},#{item.expireTime},#{item.sourceType},#{item.createTime},#{item.createUserId},#{item.updateTime},#{item.updateUserId})
+        </foreach>
+    </insert>
+
+
+    <!-- 根据ParamDto更新 -->
+    <update id="update" parameterType="paramDto">
+        update mortals_xhx_notice as a
+        set
+        <trim suffixOverrides="," suffix="">
+            <if test="(colPickMode==0 and data.containsKey('userId')) or (colPickMode==1 and !data.containsKey('userId'))">
+                a.userId=#{data.userId},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('userIdIncrement')) or (colPickMode==1 and !data.containsKey('userIdIncrement'))">
+                a.userId=ifnull(a.userId,0) + #{data.userIdIncrement},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('title')) or (colPickMode==1 and !data.containsKey('title'))">
+                a.title=#{data.title},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('content')) or (colPickMode==1 and !data.containsKey('content'))">
+                a.content=#{data.content},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('read')) or (colPickMode==1 and !data.containsKey('read'))">
+                a.`read`=#{data.read},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('priority')) or (colPickMode==1 and !data.containsKey('priority'))">
+                a.priority=#{data.priority},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('priorityIncrement')) or (colPickMode==1 and !data.containsKey('priorityIncrement'))">
+                a.priority=ifnull(a.priority,0) + #{data.priorityIncrement},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('expireTime')) or (colPickMode==1 and !data.containsKey('expireTime'))">
+                a.expireTime=#{data.expireTime},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('sourceType')) or (colPickMode==1 and !data.containsKey('sourceType'))">
+                a.sourceType=#{data.sourceType},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('createTime')) or (colPickMode==1 and !data.containsKey('createTime'))">
+                a.createTime=#{data.createTime},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('createUserId')) or (colPickMode==1 and !data.containsKey('createUserId'))">
+                a.createUserId=#{data.createUserId},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('createUserIdIncrement')) or (colPickMode==1 and !data.containsKey('createUserIdIncrement'))">
+                a.createUserId=ifnull(a.createUserId,0) + #{data.createUserIdIncrement},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('updateTime')) or (colPickMode==1 and !data.containsKey('updateTime'))">
+                a.updateTime=#{data.updateTime},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('updateUserId')) or (colPickMode==1 and !data.containsKey('updateUserId'))">
+                a.updateUserId=#{data.updateUserId},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('updateUserIdIncrement')) or (colPickMode==1 and !data.containsKey('updateUserIdIncrement'))">
+                a.updateUserId=ifnull(a.updateUserId,0) + #{data.updateUserIdIncrement},
+            </if>
+        </trim>
+        <trim suffixOverrides="where" suffix="">
+            where
+            <trim prefixOverrides="and" prefix="">
+                <include refid="_condition_"/>
+            </trim>
+        </trim>
+    </update>
+    <!-- 批量更新 -->
+    <update id="updateBatch" parameterType="paramDto">
+        update mortals_xhx_notice as a
+        <trim prefix="set" suffixOverrides=",">
+                        <trim prefix="userId=(case" suffix="ELSE userId end),">
+                            <foreach collection="data.dataList" item="item" index="index" separator="" >
+                                <choose>
+                                    <when test="(colPickMode==0 and item.containsKey('userId')) or (colPickMode==1 and !item.containsKey('userId'))">
+                                        when a.id=#{item.id} then #{item.userId}
+                                    </when>
+                                    <when test="(colPickMode==0 and item.containsKey('userIdIncrement')) or (colPickMode==1 and !item.containsKey('userIdIncrement'))">
+                                        when a.id=#{item.id} then ifnull(a.userId,0) + #{item.userIdIncrement}
+                                    </when>
+                                </choose>
+                            </foreach>
+                        </trim>
+                <trim prefix="title=(case" suffix="ELSE title end),">
+                    <foreach collection="data.dataList" item="item" index="index" separator="" >
+                        <if test="(colPickMode==0 and item.containsKey('title')) or (colPickMode==1 and !item.containsKey('title'))">
+                            when a.id=#{item.id} then #{item.title}
+                        </if>
+                    </foreach>
+                </trim>
+                <trim prefix="content=(case" suffix="ELSE content end),">
+                    <foreach collection="data.dataList" item="item" index="index" separator="" >
+                        <if test="(colPickMode==0 and item.containsKey('content')) or (colPickMode==1 and !item.containsKey('content'))">
+                            when a.id=#{item.id} then #{item.content}
+                        </if>
+                    </foreach>
+                </trim>
+                <trim prefix="`read`=(case" suffix="ELSE `read` end),">
+                    <foreach collection="data.dataList" item="item" index="index" separator="" >
+                        <if test="(colPickMode==0 and item.containsKey('read')) or (colPickMode==1 and !item.containsKey('read'))">
+                            when a.id=#{item.id} then #{item.read}
+                        </if>
+                    </foreach>
+                </trim>
+                        <trim prefix="priority=(case" suffix="ELSE priority end),">
+                            <foreach collection="data.dataList" item="item" index="index" separator="" >
+                                <choose>
+                                    <when test="(colPickMode==0 and item.containsKey('priority')) or (colPickMode==1 and !item.containsKey('priority'))">
+                                        when a.id=#{item.id} then #{item.priority}
+                                    </when>
+                                    <when test="(colPickMode==0 and item.containsKey('priorityIncrement')) or (colPickMode==1 and !item.containsKey('priorityIncrement'))">
+                                        when a.id=#{item.id} then ifnull(a.priority,0) + #{item.priorityIncrement}
+                                    </when>
+                                </choose>
+                            </foreach>
+                        </trim>
+                <trim prefix="expireTime=(case" suffix="ELSE expireTime end),">
+                    <foreach collection="data.dataList" item="item" index="index" separator="" >
+                        <if test="(colPickMode==0 and item.containsKey('expireTime')) or (colPickMode==1 and !item.containsKey('expireTime'))">
+                            when a.id=#{item.id} then #{item.expireTime}
+                        </if>
+                    </foreach>
+                </trim>
+                <trim prefix="sourceType=(case" suffix="ELSE sourceType end),">
+                    <foreach collection="data.dataList" item="item" index="index" separator="" >
+                        <if test="(colPickMode==0 and item.containsKey('sourceType')) or (colPickMode==1 and !item.containsKey('sourceType'))">
+                            when a.id=#{item.id} then #{item.sourceType}
+                        </if>
+                    </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="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="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="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>
+        where id in
+        <foreach collection="data.dataList" item="item" index="index" open="(" separator="," close=")">
+            #{item.id}
+        </foreach>
+    </update>
+    <!-- 根据主健查询 -->
+    <select id="getByKey" parameterType="paramDto" resultMap="NoticeEntity-Map">
+        select <include refid="_columns"/>
+        from mortals_xhx_notice as a
+        where a.id=#{condition.id}
+    </select>
+    <!-- 根据主健删除 -->
+    <delete id="deleteByKey" parameterType="paramDto">
+        delete a.* from mortals_xhx_notice as a where a.id=#{condition.id}
+    </delete>
+    <!-- 根据主健删除一批，针对单一主健有效 -->
+    <delete id="deleteByKeys">
+        delete from mortals_xhx_notice where id in
+        <foreach collection="array" item="item" index="index" open="(" separator="," close=")">
+            #{item}
+        </foreach>
+    </delete>
+    <!-- 根据主健列表删除一批，针对单一主健有效 -->
+    <delete id="deleteByKeyList">
+        delete from mortals_xhx_notice where id in
+        <foreach collection="list" item="item" index="index" open="(" separator="," close=")">
+            #{item}
+        </foreach>
+    </delete>
+
+    <!-- 根据对象列表删除一批，针对单一主健有效 -->
+    <delete id="deleteByEntityList">
+        delete from mortals_xhx_notice where id in
+        <foreach collection="list" item="item" index="index" open="(" separator="," close=")">
+            #{item.id}
+        </foreach>
+    </delete>
+    <!-- 根据paramDto删除一批 -->
+    <delete id="deleteByMap" parameterType="paramDto">
+        delete a.* from mortals_xhx_notice as a
+        <trim suffixOverrides="where" suffix="">
+            where
+            <trim prefixOverrides="and" prefix="">
+                <include refid="_condition_"/>
+            </trim>
+        </trim>
+    </delete>
+    <!-- 获取列表 -->
+    <select id="getList" parameterType="paramDto" resultMap="NoticeEntity-Map">
+        select <include refid="_columns"/>
+        from mortals_xhx_notice as a
+        <trim suffixOverrides="where" suffix="">
+            where
+            <trim prefixOverrides="and" prefix="">
+                <include refid="_condition_"/>
+            </trim>
+        </trim>
+        <include refid="_orderCols_"/>
+    </select>
+
+
+
+    <!-- 获取 -->
+    <select id="getListCount" parameterType="paramDto" resultType="int">
+        select count(1)
+        from mortals_xhx_notice as a
+        <trim suffixOverrides="where" suffix="">
+            where
+            <trim prefixOverrides="and" prefix="">
+                <include refid="_condition_"/>
+            </trim>
+        </trim>
+    </select>
+    <!-- 条件映射 -->
+    <sql id="_condition_">
+        <if test="condition != null and !condition.isEmpty()">
+            <!-- 条件映射-普通条件 -->
+            <include refid="_condition_param_">
+                <property name="_conditionParam_" value="condition"/>
+                <property name="_conditionType_" value="and"/>
+            </include>
+            <!-- 条件映射-集合之间使用AND，集合中元素使用OR-(list[0].1 or list[0].2) and (list[1].3 or list[1].4) -->
+            <if test="condition.containsKey('andConditionList') and !condition.andConditionList.isEmpty()">
+                and
+                <foreach collection="condition.andConditionList" open="(" close=")" index="index" item="andCondition" separator=" and ">
+                    <trim prefixOverrides="or" prefix="(" suffix=")">
+                        <include refid="_condition_param_">
+                            <property name="_conditionParam_" value="andCondition"/>
+                            <property name="_conditionType_" value="or"/>
+                        </include>
+                    </trim>
+                </foreach>
+            </if>
+            <!-- 条件映射-集合之间使用OR，集合中元素使用AND-(list[0].1 and list[0].2) or (list[1].3 and list[1].4) -->
+            <if test="condition.containsKey('orConditionList') and !condition.orConditionList.isEmpty()">
+                and
+                <foreach collection="condition.orConditionList" open="(" close=")" index="index" item="orCondition" separator=" or ">
+                    <trim prefixOverrides="and" prefix="(" suffix=")">
+                        <include refid="_condition_param_">
+                            <property name="_conditionParam_" value="orCondition"/>
+                            <property name="_conditionType_" value="and"/>
+                        </include>
+                    </trim>
+                </foreach>
+            </if>
+        </if>
+    </sql>
+    <!-- 条件映射-代参数 -->
+    <sql id="_condition_param_">
+        <bind name="conditionParamRef" value="${_conditionParam_}"/>
+        <if test="conditionParamRef.containsKey('id')">
+            <if test="conditionParamRef.id != null">
+                ${_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') and conditionParamRef.idList.size() > 0">
+                ${_conditionType_} a.id in
+                <foreach collection="conditionParamRef.idList" open="(" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+            <if test="conditionParamRef.containsKey('idNotList') and conditionParamRef.idNotList.size() > 0">
+                ${_conditionType_} a.id not in
+                <foreach collection="conditionParamRef.idNotList" 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('userId')">
+                <if test="conditionParamRef.userId != null ">
+                    ${_conditionType_} a.userId = #{${_conditionParam_}.userId}
+                </if>
+                <if test="conditionParamRef.userId == null">
+                    ${_conditionType_} a.userId is null
+                </if>
+            </if>
+            <if test="conditionParamRef.containsKey('userIdList') and conditionParamRef.userIdList.size() > 0">
+                ${_conditionType_} a.userId in
+                <foreach collection="conditionParamRef.userIdList" open="(" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+            <if test="conditionParamRef.containsKey('userIdNotList') and conditionParamRef.userIdNotList.size() > 0">
+                ${_conditionType_} a.userId not in
+                <foreach collection="conditionParamRef.userIdNotList" open="(" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+            <if test="conditionParamRef.containsKey('userIdStart') and conditionParamRef.userIdStart != null">
+                ${_conditionType_} a.userId <![CDATA[ >= ]]> #{${_conditionParam_}.userIdStart}
+            </if>
+            <if test="conditionParamRef.containsKey('userIdEnd') and conditionParamRef.userIdEnd != null">
+                ${_conditionType_} a.userId <![CDATA[ <= ]]> #{${_conditionParam_}.userIdEnd}
+            </if>
+
+
+            <if test="conditionParamRef.containsKey('title')">
+                <if test="conditionParamRef.title != null and conditionParamRef.title != ''">
+                    ${_conditionType_} a.title like #{${_conditionParam_}.title}
+                </if>
+                <if test="conditionParamRef.title == null">
+                    ${_conditionType_} a.title is null
+                </if>
+            </if>
+            <if test="conditionParamRef.containsKey('titleList') and conditionParamRef.titleList.size() > 0">
+                ${_conditionType_} a.title in
+                <foreach collection="conditionParamRef.titleList" open="(" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+            <if test="conditionParamRef.containsKey('titleNotList') and conditionParamRef.titleNotList.size() > 0">
+                ${_conditionType_} a.title not in
+                <foreach collection="conditionParamRef.titleNotList" open="(" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+
+            <if test="conditionParamRef.containsKey('content')">
+                <if test="conditionParamRef.content != null and conditionParamRef.content != ''">
+                    ${_conditionType_} a.content like #{${_conditionParam_}.content}
+                </if>
+                <if test="conditionParamRef.content == null">
+                    ${_conditionType_} a.content is null
+                </if>
+            </if>
+            <if test="conditionParamRef.containsKey('contentList') and conditionParamRef.contentList.size() > 0">
+                ${_conditionType_} a.content in
+                <foreach collection="conditionParamRef.contentList" open="(" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+            <if test="conditionParamRef.containsKey('contentNotList') and conditionParamRef.contentNotList.size() > 0">
+                ${_conditionType_} a.content not in
+                <foreach collection="conditionParamRef.contentNotList" open="(" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+
+            <if test="conditionParamRef.containsKey('read')">
+                <if test="conditionParamRef.read != null ">
+                    ${_conditionType_} a.`read` = #{${_conditionParam_}.read}
+                </if>
+                <if test="conditionParamRef.read == null">
+                    ${_conditionType_} a.`read` is null
+                </if>
+            </if>
+            <if test="conditionParamRef.containsKey('readStart') and conditionParamRef.readStart != null and conditionParamRef.readStart!=''">
+                ${_conditionType_} a.`read` <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.readStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
+            </if>
+            <if test="conditionParamRef.containsKey('readEnd') and conditionParamRef.readEnd != null and conditionParamRef.readEnd!=''">
+                ${_conditionType_} a.`read` <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.readEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
+            </if>
+            <if test="conditionParamRef.containsKey('priority')">
+                <if test="conditionParamRef.priority != null ">
+                    ${_conditionType_} a.priority = #{${_conditionParam_}.priority}
+                </if>
+                <if test="conditionParamRef.priority == null">
+                    ${_conditionType_} a.priority is null
+                </if>
+            </if>
+            <if test="conditionParamRef.containsKey('priorityList') and conditionParamRef.priorityList.size() > 0">
+                ${_conditionType_} a.priority in
+                <foreach collection="conditionParamRef.priorityList" open="(" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+            <if test="conditionParamRef.containsKey('priorityNotList') and conditionParamRef.priorityNotList.size() > 0">
+                ${_conditionType_} a.priority not in
+                <foreach collection="conditionParamRef.priorityNotList" open="(" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+            <if test="conditionParamRef.containsKey('priorityStart') and conditionParamRef.priorityStart != null">
+                ${_conditionType_} a.priority <![CDATA[ >= ]]> #{${_conditionParam_}.priorityStart}
+            </if>
+            <if test="conditionParamRef.containsKey('priorityEnd') and conditionParamRef.priorityEnd != null">
+                ${_conditionType_} a.priority <![CDATA[ <= ]]> #{${_conditionParam_}.priorityEnd}
+            </if>
+
+
+            <if test="conditionParamRef.containsKey('expireTime')">
+                <if test="conditionParamRef.expireTime != null ">
+                    ${_conditionType_} a.expireTime = #{${_conditionParam_}.expireTime}
+                </if>
+                <if test="conditionParamRef.expireTime == null">
+                    ${_conditionType_} a.expireTime is null
+                </if>
+            </if>
+            <if test="conditionParamRef.containsKey('expireTimeStart') and conditionParamRef.expireTimeStart != null and conditionParamRef.expireTimeStart!=''">
+                ${_conditionType_} a.expireTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.expireTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
+            </if>
+            <if test="conditionParamRef.containsKey('expireTimeEnd') and conditionParamRef.expireTimeEnd != null and conditionParamRef.expireTimeEnd!=''">
+                ${_conditionType_} a.expireTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.expireTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
+            </if>
+
+            <if test="conditionParamRef.containsKey('sourceType')">
+                <if test="conditionParamRef.sourceType != null and conditionParamRef.sourceType != ''">
+                    ${_conditionType_} a.sourceType like #{${_conditionParam_}.sourceType}
+                </if>
+                <if test="conditionParamRef.sourceType == null">
+                    ${_conditionType_} a.sourceType is null
+                </if>
+            </if>
+            <if test="conditionParamRef.containsKey('sourceTypeList') and conditionParamRef.sourceTypeList.size() > 0">
+                ${_conditionType_} a.sourceType in
+                <foreach collection="conditionParamRef.sourceTypeList" open="(" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+            <if test="conditionParamRef.containsKey('sourceTypeNotList') and conditionParamRef.sourceTypeNotList.size() > 0">
+                ${_conditionType_} a.sourceType not in
+                <foreach collection="conditionParamRef.sourceTypeNotList" open="(" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+            </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>
+            <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('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') and conditionParamRef.createUserIdList.size() > 0">
+                ${_conditionType_} a.createUserId in
+                <foreach collection="conditionParamRef.createUserIdList" open="(" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+            <if test="conditionParamRef.containsKey('createUserIdNotList') and conditionParamRef.createUserIdNotList.size() > 0">
+                ${_conditionType_} a.createUserId not in
+                <foreach collection="conditionParamRef.createUserIdNotList" 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('updateTime')">
+                <if test="conditionParamRef.updateTime != null ">
+                    ${_conditionType_} a.updateTime = #{${_conditionParam_}.updateTime}
+                </if>
+                <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>
+            <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') and conditionParamRef.updateUserIdList.size() > 0">
+                ${_conditionType_} a.updateUserId in
+                <foreach collection="conditionParamRef.updateUserIdList" open="(" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+            <if test="conditionParamRef.containsKey('updateUserIdNotList') and conditionParamRef.updateUserIdNotList.size() > 0">
+                ${_conditionType_} a.updateUserId not in
+                <foreach collection="conditionParamRef.updateUserIdNotList" 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>
+
+    </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}
+                </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('userId')">
+                        a.userId
+                        <if test='orderCol.userId != null and "DESC".equalsIgnoreCase(orderCol.userId)'>DESC</if>
+                        ,
+                    </if>
+                    <if test="orderCol.containsKey('title')">
+                        a.title
+                        <if test='orderCol.title != null and "DESC".equalsIgnoreCase(orderCol.title)'>DESC</if>
+                        ,
+                    </if>
+                    <if test="orderCol.containsKey('content')">
+                        a.content
+                        <if test='orderCol.content != null and "DESC".equalsIgnoreCase(orderCol.content)'>DESC</if>
+                        ,
+                    </if>
+                    <if test="orderCol.containsKey('read')">
+                        a.`read`
+                        <if test='orderCol.read != null and "DESC".equalsIgnoreCase(orderCol.read)'>DESC</if>
+                        ,
+                    </if>
+                    <if test="orderCol.containsKey('priority')">
+                        a.priority
+                        <if test='orderCol.priority != null and "DESC".equalsIgnoreCase(orderCol.priority)'>DESC</if>
+                        ,
+                    </if>
+                    <if test="orderCol.containsKey('expireTime')">
+                        a.expireTime
+                        <if test='orderCol.expireTime != null and "DESC".equalsIgnoreCase(orderCol.expireTime)'>DESC</if>
+                        ,
+                    </if>
+                    <if test="orderCol.containsKey('sourceType')">
+                        a.sourceType
+                        <if test='orderCol.sourceType != null and "DESC".equalsIgnoreCase(orderCol.sourceType)'>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('createUserId')">
+                        a.createUserId
+                        <if test='orderCol.createUserId != null and "DESC".equalsIgnoreCase(orderCol.createUserId)'>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('updateUserId')">
+                        a.updateUserId
+                        <if test='orderCol.updateUserId != null and "DESC".equalsIgnoreCase(orderCol.updateUserId)'>DESC</if>
+                        ,
+                    </if>
+            </trim>
+        </if>
+    </sql>
+    <sql id="_group_by_">
+        <if test="groupList != null and !groupList.isEmpty()">
+            GROUP BY
+            <trim suffixOverrides=","  suffix="">
+                <foreach collection="groupList" open="" close="" index="index" item="item" separator=",">
+                    ${item}
+                </foreach>
+            </trim>
+        </if>
+    </sql>
+</mapper>
\ No newline at end of file

refined-manager/src/test/java/com/mortals/httpclient/monitor/MonitorAlarmController.http

+###登录
+POST {{baseUrl}}/login/login
+Content-Type: application/json
+
+{
+"loginName":"admin",
+"password":"admin",
+"securityCode":"8888"
+}
+
+> {%
+client.global.set("SmsSet_id", JSON.parse(response.body).data.id);
+client.global.set("authToken", JSON.parse(response.body).data.token);
+%}
+
+###监测预警记录列表
+POST {{baseUrl}}/monitor/alarm/list
+Authorization: {{authToken}}
+Content-Type: application/json
+
+{
+    "page":1,
+    "size":10
+}
+
+
+###监测预警记录更新与保存
+POST {{baseUrl}}/monitor/alarm/save
+Authorization: {{authToken}}
+Content-Type: application/json
+
+{
+        "siteId":805,
+        "siteName":"6zqre9",
+        "personId":47,
+        "name":"puktb3",
+        "contact":"toms0r",
+        "idNumber":"g2syhi",
+        "identifyNum":0,
+        "lastIdentifyTime":"1681488000000",
+        "year":962,
+        "month":391,
+        "day":975,
+}
+
+> {%
+client.global.set("MonitorAlarm_id", JSON.parse(response.body).data.id);
+%}
+
+###监测预警记录查看
+GET {{baseUrl}}/monitor/alarm/info?id={{MonitorAlarm_id}}
+Authorization: {{authToken}}
+Accept: application/json
+
+###监测预警记录编辑
+GET {{baseUrl}}/monitor/alarm/edit?id={{MonitorAlarm_id}}
+Authorization: {{authToken}}
+Accept: application/json
+
+
+###监测预警记录删除
+GET {{baseUrl}}/monitor/alarm/delete?id={{MonitorAlarm_id}}
+Authorization: {{authToken}}
+Accept: application/json
+
+
+
+

refined-manager/src/test/java/com/mortals/httpclient/monitor/MonitorAlarmRecordController.http

+###登录
+POST {{baseUrl}}/login/login
+Content-Type: application/json
+
+{
+"loginName":"admin",
+"password":"admin",
+"securityCode":"8888"
+}
+
+> {%
+client.global.set("SmsSet_id", JSON.parse(response.body).data.id);
+client.global.set("authToken", JSON.parse(response.body).data.token);
+%}
+
+###监测预警记录详细记录列表
+POST {{baseUrl}}/monitor/alarm/record/list
+Authorization: {{authToken}}
+Content-Type: application/json
+
+{
+    "page":1,
+    "size":10
+}
+
+
+###监测预警记录详细记录更新与保存
+POST {{baseUrl}}/monitor/alarm/record/save
+Authorization: {{authToken}}
+Content-Type: application/json
+
+{
+        "alarmId":163,
+        "reservationService":"9ycxhb",
+        "reservationNumber":"js1zjk",
+        "monitorTime":"1681488000000",
+        "monitorDeviceId":550,
+        "monitorDevice":"42k9bi",
+        "checkInMethod":0,
+        "monitorCertificate":"eeccuo",
+        "picUri":"yqhq40",
+        "serverIndexCode":"zb3oxf",
+}
+
+> {%
+client.global.set("MonitorAlarmRecord_id", JSON.parse(response.body).data.id);
+%}
+
+###监测预警记录详细记录查看
+GET {{baseUrl}}/monitor/alarm/record/info?id={{MonitorAlarmRecord_id}}
+Authorization: {{authToken}}
+Accept: application/json
+
+###监测预警记录详细记录编辑
+GET {{baseUrl}}/monitor/alarm/record/edit?id={{MonitorAlarmRecord_id}}
+Authorization: {{authToken}}
+Accept: application/json
+
+
+###监测预警记录详细记录删除
+GET {{baseUrl}}/monitor/alarm/record/delete?id={{MonitorAlarmRecord_id}}
+Authorization: {{authToken}}
+Accept: application/json
+
+
+
+

refined-manager/src/test/java/com/mortals/httpclient/notice/NoticeController.http

+###登录
+POST {{baseUrl}}/login/login
+Content-Type: application/json
+
+{
+"loginName":"admin",
+"password":"admin",
+"securityCode":"8888"
+}
+
+> {%
+client.global.set("SmsSet_id", JSON.parse(response.body).data.id);
+client.global.set("authToken", JSON.parse(response.body).data.token);
+%}
+
+###用户消息列表
+POST {{baseUrl}}/notice/list
+Authorization: {{authToken}}
+Content-Type: application/json
+
+{
+    "page":1,
+    "size":10
+}
+
+
+###用户消息更新与保存
+POST {{baseUrl}}/notice/save
+Authorization: {{authToken}}
+Content-Type: application/json
+
+{
+        "userId":935,
+        "title":"aj6hkx",
+        "content":"ubsb2j",
+        "read":"0",
+        "priority":0,
+        "expireTime":"1681488000000",
+        "sourceType":"m1nkqa",
+}
+
+> {%
+client.global.set("Notice_id", JSON.parse(response.body).data.id);
+%}
+
+###用户消息查看
+GET {{baseUrl}}/notice/info?id={{Notice_id}}
+Authorization: {{authToken}}
+Accept: application/json
+
+###用户消息编辑
+GET {{baseUrl}}/notice/edit?id={{Notice_id}}
+Authorization: {{authToken}}
+Accept: application/json
+
+
+###用户消息删除
+GET {{baseUrl}}/notice/delete?id={{Notice_id}}
+Authorization: {{authToken}}
+Accept: application/json
+
+
+
+