Skip to content

A
attendance-performance-platform
Commit 16096179 authored by 廖旭伟's avatar 廖旭伟
Browse files
Options

考勤设备管理

parent ed8e54a0
Hide whitespace changes
Inline Side-by-side
Showing with 4000 additions and 0 deletions
attendance-performance-manager/src/main/java/com/mortals/xhx/module/device/dao/DeviceDao.java 0 → 100644
View file @ 16096179
package com.mortals.xhx.module.device.dao;
import com.mortals.framework.dao.ICRUDDao;
import com.mortals.xhx.module.device.model.DeviceEntity;
import java.util.List;
/**
* 考勤机管理Dao
* 考勤机管理 DAO接口
*
* @author zxfei
* @date 2025-04-09
*/
public interface DeviceDao extends ICRUDDao<DeviceEntity,Long>{
}
attendance-performance-manager/src/main/java/com/mortals/xhx/module/device/dao/ibatis/DeviceDaoImpl.java 0 → 100644
View file @ 16096179
package com.mortals.xhx.module.device.dao.ibatis;
import org.springframework.stereotype.Repository;
import com.mortals.xhx.module.device.dao.DeviceDao;
import com.mortals.xhx.module.device.model.DeviceEntity;
import java.util.Date;
import com.mortals.framework.dao.ibatis.BaseCRUDDaoMybatis;
import java.util.List;
/**
* 考勤机管理DaoImpl DAO接口
*
* @author zxfei
* @date 2025-04-09
*/
@Repository("deviceDao")
public class DeviceDaoImpl extends BaseCRUDDaoMybatis<DeviceEntity,Long> implements DeviceDao {
}
attendance-performance-manager/src/main/java/com/mortals/xhx/module/device/model/DeviceEntity.java 0 → 100644
View file @ 16096179
package com.mortals.xhx.module.device.model;
import java.util.List;
import java.util.ArrayList;
import java.math.BigDecimal;
import cn.hutool.core.date.DateUtil;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.mortals.framework.annotation.Excel;
import com.mortals.framework.model.BaseEntityLong;
import com.mortals.xhx.module.device.model.vo.DeviceVo;
import lombok.Data;
/**
* 考勤机管理实体对象
*
* @author zxfei
* @date 2025-04-09
*/
@Data
public class DeviceEntity extends DeviceVo {
private static final long serialVersionUID = 1L;
/**
* 设备名称
*/
private String deviceName;
/**
* 设备编码
*/
private String deviceCode;
/**
* 设备类型1考勤机
*/
private Integer deviceType;
/**
* Mac地址
*/
private String deviceMac;
/**
* 设备厂商
*/
private String deviceFirmname;
/**
* 设备型号
*/
private String modelNum;
/**
* 设备IP地址
*/
private String ip;
/**
* 端口号
*/
private String port;
/**
* 设备分辨率
*/
private String resolution;
/**
* 负责人
*/
private String leadingOfficial;
/**
* 负责人电话
*/
private String telephone;
/**
* 设备经度
*/
private String longitude;
/**
* 设备纬度
*/
private String latitude;
/**
* 所在楼宇
*/
private Integer building;
/**
* 所在楼层
*/
private Integer floor;
/**
* 设备地址
*/
private String address;
/**
* 管理员账号
*/
private String manageUser;
/**
* 管理员密码
*/
private String managePWD;
/**
* 备注
*/
private String remark;
/**
* 设备状态，0：未激活，1：离线:2：在线
*/
private Integer status;
/**
* 启停状态，0：停用,1：启用
*/
private Integer enabled;
@Override
public int hashCode() {
return this.getId().hashCode();
}
@Override
public boolean equals(Object obj) {
if (obj == null) return false;
if (obj instanceof DeviceEntity) {
DeviceEntity tmp = (DeviceEntity) obj;
if (this.getId() == tmp.getId()) {
return true;
}
}
return false;
}
public void initAttrValue(){
this.deviceName = "";
this.deviceCode = "";
this.deviceType = 1;
this.deviceMac = "";
this.deviceFirmname = "";
this.modelNum = "";
this.ip = "";
this.port = "";
this.resolution = "";
this.leadingOfficial = "";
this.telephone = "";
this.longitude = "";
this.latitude = "";
this.building = 0;
this.floor = 0;
this.address = "";
this.manageUser = "";
this.managePWD = "";
this.remark = "";
this.status = 0;
this.enabled = 0;
}
}
\ No newline at end of file
attendance-performance-manager/src/main/java/com/mortals/xhx/module/device/model/DeviceQuery.java 0 → 100644
View file @ 16096179
package com.mortals.xhx.module.device.model;
import java.util.List;
import com.mortals.xhx.module.device.model.DeviceEntity;
/**
* 考勤机管理查询对象
*
* @author zxfei
* @date 2025-04-09
*/
public class DeviceQuery extends DeviceEntity {
/** 开始 序号，主键，自增长 */
private Long idStart;
/** 结束 序号，主键，自增长 */
private Long idEnd;
/** 增加 序号，主键，自增长 */
private Long idIncrement;
/** 序号，主键，自增长列表 */
private List <Long> idList;
/** 序号，主键，自增长排除列表 */
private List <Long> idNotList;
/** 设备名称 */
private List<String> deviceNameList;
/** 设备名称排除列表 */
private List <String> deviceNameNotList;
/** 设备编码 */
private List<String> deviceCodeList;
/** 设备编码排除列表 */
private List <String> deviceCodeNotList;
/** 开始 设备类型1考勤机 */
private Integer deviceTypeStart;
/** 结束 设备类型1考勤机 */
private Integer deviceTypeEnd;
/** 增加 设备类型1考勤机 */
private Integer deviceTypeIncrement;
/** 设备类型1考勤机列表 */
private List <Integer> deviceTypeList;
/** 设备类型1考勤机排除列表 */
private List <Integer> deviceTypeNotList;
/** Mac地址 */
private List<String> deviceMacList;
/** Mac地址排除列表 */
private List <String> deviceMacNotList;
/** 设备厂商 */
private List<String> deviceFirmnameList;
/** 设备厂商排除列表 */
private List <String> deviceFirmnameNotList;
/** 设备型号 */
private List<String> modelNumList;
/** 设备型号排除列表 */
private List <String> modelNumNotList;
/** 设备IP地址 */
private List<String> ipList;
/** 设备IP地址排除列表 */
private List <String> ipNotList;
/** 端口号 */
private List<String> portList;
/** 端口号排除列表 */
private List <String> portNotList;
/** 设备分辨率 */
private List<String> resolutionList;
/** 设备分辨率排除列表 */
private List <String> resolutionNotList;
/** 负责人 */
private List<String> leadingOfficialList;
/** 负责人排除列表 */
private List <String> leadingOfficialNotList;
/** 负责人电话 */
private List<String> telephoneList;
/** 负责人电话排除列表 */
private List <String> telephoneNotList;
/** 设备经度 */
private List<String> longitudeList;
/** 设备经度排除列表 */
private List <String> longitudeNotList;
/** 设备纬度 */
private List<String> latitudeList;
/** 设备纬度排除列表 */
private List <String> latitudeNotList;
/** 开始 所在楼宇 */
private Integer buildingStart;
/** 结束 所在楼宇 */
private Integer buildingEnd;
/** 增加 所在楼宇 */
private Integer buildingIncrement;
/** 所在楼宇列表 */
private List <Integer> buildingList;
/** 所在楼宇排除列表 */
private List <Integer> buildingNotList;
/** 开始 所在楼层 */
private Integer floorStart;
/** 结束 所在楼层 */
private Integer floorEnd;
/** 增加 所在楼层 */
private Integer floorIncrement;
/** 所在楼层列表 */
private List <Integer> floorList;
/** 所在楼层排除列表 */
private List <Integer> floorNotList;
/** 设备地址 */
private List<String> addressList;
/** 设备地址排除列表 */
private List <String> addressNotList;
/** 管理员账号 */
private List<String> manageUserList;
/** 管理员账号排除列表 */
private List <String> manageUserNotList;
/** 管理员密码 */
private List<String> managePWDList;
/** 管理员密码排除列表 */
private List <String> managePWDNotList;
/** 备注 */
private List<String> remarkList;
/** 备注排除列表 */
private List <String> remarkNotList;
/** 开始 设备状态，0：未激活，1：离线:2：在线 */
private Integer statusStart;
/** 结束 设备状态，0：未激活，1：离线:2：在线 */
private Integer statusEnd;
/** 增加 设备状态，0：未激活，1：离线:2：在线 */
private Integer statusIncrement;
/** 设备状态，0：未激活，1：离线:2：在线列表 */
private List <Integer> statusList;
/** 设备状态，0：未激活，1：离线:2：在线排除列表 */
private List <Integer> statusNotList;
/** 开始 启停状态，0：停用,1：启用 */
private Integer enabledStart;
/** 结束 启停状态，0：停用,1：启用 */
private Integer enabledEnd;
/** 增加 启停状态，0：停用,1：启用 */
private Integer enabledIncrement;
/** 启停状态，0：停用,1：启用列表 */
private List <Integer> enabledList;
/** 启停状态，0：停用,1：启用排除列表 */
private List <Integer> enabledNotList;
/** 开始 创建用户 */
private Long createUserIdStart;
/** 结束 创建用户 */
private Long createUserIdEnd;
/** 增加 创建用户 */
private Long createUserIdIncrement;
/** 创建用户列表 */
private List <Long> createUserIdList;
/** 创建用户排除列表 */
private List <Long> createUserIdNotList;
/** 开始 创建时间 */
private String createTimeStart;
/** 结束 创建时间 */
private String createTimeEnd;
/** 开始 更新用户 */
private Long updateUserIdStart;
/** 结束 更新用户 */
private Long updateUserIdEnd;
/** 增加 更新用户 */
private Long updateUserIdIncrement;
/** 更新用户列表 */
private List <Long> updateUserIdList;
/** 更新用户排除列表 */
private List <Long> updateUserIdNotList;
/** 开始 更新时间 */
private String updateTimeStart;
/** 结束 更新时间 */
private String updateTimeEnd;
/** OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4) */
private List<DeviceQuery> orConditionList;
/** AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4) */
private List<DeviceQuery> andConditionList;
public DeviceQuery(){}
/**
* 获取 开始 序号，主键，自增长
* @return idStart
*/
public Long getIdStart(){
return this.idStart;
}
/**
* 设置 开始 序号，主键，自增长
* @param idStart
*/
public void setIdStart(Long idStart){
this.idStart = idStart;
}
/**
* 获取 结束 序号，主键，自增长
* @return $idEnd
*/
public Long getIdEnd(){
return this.idEnd;
}
/**
* 设置 结束 序号，主键，自增长
* @param idEnd
*/
public void setIdEnd(Long idEnd){
this.idEnd = idEnd;
}
/**
* 获取 增加 序号，主键，自增长
* @return idIncrement
*/
public Long getIdIncrement(){
return this.idIncrement;
}
/**
* 设置 增加 序号，主键，自增长
* @param idIncrement
*/
public void setIdIncrement(Long idIncrement){
this.idIncrement = idIncrement;
}
/**
* 获取 序号，主键，自增长
* @return idList
*/
public List<Long> getIdList(){
return this.idList;
}
/**
* 设置 序号，主键，自增长
* @param idList
*/
public void setIdList(List<Long> idList){
this.idList = idList;
}
/**
* 获取 序号，主键，自增长
* @return idNotList
*/
public List<Long> getIdNotList(){
return this.idNotList;
}
/**
* 设置 序号，主键，自增长
* @param idNotList
*/
public void setIdNotList(List<Long> idNotList){
this.idNotList = idNotList;
}
/**
* 获取 设备名称
* @return deviceNameList
*/
public List<String> getDeviceNameList(){
return this.deviceNameList;
}
/**
* 设置 设备名称
* @param deviceNameList
*/
public void setDeviceNameList(List<String> deviceNameList){
this.deviceNameList = deviceNameList;
}
/**
* 获取 设备名称
* @return deviceNameNotList
*/
public List<String> getDeviceNameNotList(){
return this.deviceNameNotList;
}
/**
* 设置 设备名称
* @param deviceNameNotList
*/
public void setDeviceNameNotList(List<String> deviceNameNotList){
this.deviceNameNotList = deviceNameNotList;
}
/**
* 获取 设备编码
* @return deviceCodeList
*/
public List<String> getDeviceCodeList(){
return this.deviceCodeList;
}
/**
* 设置 设备编码
* @param deviceCodeList
*/
public void setDeviceCodeList(List<String> deviceCodeList){
this.deviceCodeList = deviceCodeList;
}
/**
* 获取 设备编码
* @return deviceCodeNotList
*/
public List<String> getDeviceCodeNotList(){
return this.deviceCodeNotList;
}
/**
* 设置 设备编码
* @param deviceCodeNotList
*/
public void setDeviceCodeNotList(List<String> deviceCodeNotList){
this.deviceCodeNotList = deviceCodeNotList;
}
/**
* 获取 开始 设备类型1考勤机
* @return deviceTypeStart
*/
public Integer getDeviceTypeStart(){
return this.deviceTypeStart;
}
/**
* 设置 开始 设备类型1考勤机
* @param deviceTypeStart
*/
public void setDeviceTypeStart(Integer deviceTypeStart){
this.deviceTypeStart = deviceTypeStart;
}
/**
* 获取 结束 设备类型1考勤机
* @return $deviceTypeEnd
*/
public Integer getDeviceTypeEnd(){
return this.deviceTypeEnd;
}
/**
* 设置 结束 设备类型1考勤机
* @param deviceTypeEnd
*/
public void setDeviceTypeEnd(Integer deviceTypeEnd){
this.deviceTypeEnd = deviceTypeEnd;
}
/**
* 获取 增加 设备类型1考勤机
* @return deviceTypeIncrement
*/
public Integer getDeviceTypeIncrement(){
return this.deviceTypeIncrement;
}
/**
* 设置 增加 设备类型1考勤机
* @param deviceTypeIncrement
*/
public void setDeviceTypeIncrement(Integer deviceTypeIncrement){
this.deviceTypeIncrement = deviceTypeIncrement;
}
/**
* 获取 设备类型1考勤机
* @return deviceTypeList
*/
public List<Integer> getDeviceTypeList(){
return this.deviceTypeList;
}
/**
* 设置 设备类型1考勤机
* @param deviceTypeList
*/
public void setDeviceTypeList(List<Integer> deviceTypeList){
this.deviceTypeList = deviceTypeList;
}
/**
* 获取 设备类型1考勤机
* @return deviceTypeNotList
*/
public List<Integer> getDeviceTypeNotList(){
return this.deviceTypeNotList;
}
/**
* 设置 设备类型1考勤机
* @param deviceTypeNotList
*/
public void setDeviceTypeNotList(List<Integer> deviceTypeNotList){
this.deviceTypeNotList = deviceTypeNotList;
}
/**
* 获取 Mac地址
* @return deviceMacList
*/
public List<String> getDeviceMacList(){
return this.deviceMacList;
}
/**
* 设置 Mac地址
* @param deviceMacList
*/
public void setDeviceMacList(List<String> deviceMacList){
this.deviceMacList = deviceMacList;
}
/**
* 获取 Mac地址
* @return deviceMacNotList
*/
public List<String> getDeviceMacNotList(){
return this.deviceMacNotList;
}
/**
* 设置 Mac地址
* @param deviceMacNotList
*/
public void setDeviceMacNotList(List<String> deviceMacNotList){
this.deviceMacNotList = deviceMacNotList;
}
/**
* 获取 设备厂商
* @return deviceFirmnameList
*/
public List<String> getDeviceFirmnameList(){
return this.deviceFirmnameList;
}
/**
* 设置 设备厂商
* @param deviceFirmnameList
*/
public void setDeviceFirmnameList(List<String> deviceFirmnameList){
this.deviceFirmnameList = deviceFirmnameList;
}
/**
* 获取 设备厂商
* @return deviceFirmnameNotList
*/
public List<String> getDeviceFirmnameNotList(){
return this.deviceFirmnameNotList;
}
/**
* 设置 设备厂商
* @param deviceFirmnameNotList
*/
public void setDeviceFirmnameNotList(List<String> deviceFirmnameNotList){
this.deviceFirmnameNotList = deviceFirmnameNotList;
}
/**
* 获取 设备型号
* @return modelNumList
*/
public List<String> getModelNumList(){
return this.modelNumList;
}
/**
* 设置 设备型号
* @param modelNumList
*/
public void setModelNumList(List<String> modelNumList){
this.modelNumList = modelNumList;
}
/**
* 获取 设备型号
* @return modelNumNotList
*/
public List<String> getModelNumNotList(){
return this.modelNumNotList;
}
/**
* 设置 设备型号
* @param modelNumNotList
*/
public void setModelNumNotList(List<String> modelNumNotList){
this.modelNumNotList = modelNumNotList;
}
/**
* 获取 设备IP地址
* @return ipList
*/
public List<String> getIpList(){
return this.ipList;
}
/**
* 设置 设备IP地址
* @param ipList
*/
public void setIpList(List<String> ipList){
this.ipList = ipList;
}
/**
* 获取 设备IP地址
* @return ipNotList
*/
public List<String> getIpNotList(){
return this.ipNotList;
}
/**
* 设置 设备IP地址
* @param ipNotList
*/
public void setIpNotList(List<String> ipNotList){
this.ipNotList = ipNotList;
}
/**
* 获取 端口号
* @return portList
*/
public List<String> getPortList(){
return this.portList;
}
/**
* 设置 端口号
* @param portList
*/
public void setPortList(List<String> portList){
this.portList = portList;
}
/**
* 获取 端口号
* @return portNotList
*/
public List<String> getPortNotList(){
return this.portNotList;
}
/**
* 设置 端口号
* @param portNotList
*/
public void setPortNotList(List<String> portNotList){
this.portNotList = portNotList;
}
/**
* 获取 设备分辨率
* @return resolutionList
*/
public List<String> getResolutionList(){
return this.resolutionList;
}
/**
* 设置 设备分辨率
* @param resolutionList
*/
public void setResolutionList(List<String> resolutionList){
this.resolutionList = resolutionList;
}
/**
* 获取 设备分辨率
* @return resolutionNotList
*/
public List<String> getResolutionNotList(){
return this.resolutionNotList;
}
/**
* 设置 设备分辨率
* @param resolutionNotList
*/
public void setResolutionNotList(List<String> resolutionNotList){
this.resolutionNotList = resolutionNotList;
}
/**
* 获取 负责人
* @return leadingOfficialList
*/
public List<String> getLeadingOfficialList(){
return this.leadingOfficialList;
}
/**
* 设置 负责人
* @param leadingOfficialList
*/
public void setLeadingOfficialList(List<String> leadingOfficialList){
this.leadingOfficialList = leadingOfficialList;
}
/**
* 获取 负责人
* @return leadingOfficialNotList
*/
public List<String> getLeadingOfficialNotList(){
return this.leadingOfficialNotList;
}
/**
* 设置 负责人
* @param leadingOfficialNotList
*/
public void setLeadingOfficialNotList(List<String> leadingOfficialNotList){
this.leadingOfficialNotList = leadingOfficialNotList;
}
/**
* 获取 负责人电话
* @return telephoneList
*/
public List<String> getTelephoneList(){
return this.telephoneList;
}
/**
* 设置 负责人电话
* @param telephoneList
*/
public void setTelephoneList(List<String> telephoneList){
this.telephoneList = telephoneList;
}
/**
* 获取 负责人电话
* @return telephoneNotList
*/
public List<String> getTelephoneNotList(){
return this.telephoneNotList;
}
/**
* 设置 负责人电话
* @param telephoneNotList
*/
public void setTelephoneNotList(List<String> telephoneNotList){
this.telephoneNotList = telephoneNotList;
}
/**
* 获取 设备经度
* @return longitudeList
*/
public List<String> getLongitudeList(){
return this.longitudeList;
}
/**
* 设置 设备经度
* @param longitudeList
*/
public void setLongitudeList(List<String> longitudeList){
this.longitudeList = longitudeList;
}
/**
* 获取 设备经度
* @return longitudeNotList
*/
public List<String> getLongitudeNotList(){
return this.longitudeNotList;
}
/**
* 设置 设备经度
* @param longitudeNotList
*/
public void setLongitudeNotList(List<String> longitudeNotList){
this.longitudeNotList = longitudeNotList;
}
/**
* 获取 设备纬度
* @return latitudeList
*/
public List<String> getLatitudeList(){
return this.latitudeList;
}
/**
* 设置 设备纬度
* @param latitudeList
*/
public void setLatitudeList(List<String> latitudeList){
this.latitudeList = latitudeList;
}
/**
* 获取 设备纬度
* @return latitudeNotList
*/
public List<String> getLatitudeNotList(){
return this.latitudeNotList;
}
/**
* 设置 设备纬度
* @param latitudeNotList
*/
public void setLatitudeNotList(List<String> latitudeNotList){
this.latitudeNotList = latitudeNotList;
}
/**
* 获取 开始 所在楼宇
* @return buildingStart
*/
public Integer getBuildingStart(){
return this.buildingStart;
}
/**
* 设置 开始 所在楼宇
* @param buildingStart
*/
public void setBuildingStart(Integer buildingStart){
this.buildingStart = buildingStart;
}
/**
* 获取 结束 所在楼宇
* @return $buildingEnd
*/
public Integer getBuildingEnd(){
return this.buildingEnd;
}
/**
* 设置 结束 所在楼宇
* @param buildingEnd
*/
public void setBuildingEnd(Integer buildingEnd){
this.buildingEnd = buildingEnd;
}
/**
* 获取 增加 所在楼宇
* @return buildingIncrement
*/
public Integer getBuildingIncrement(){
return this.buildingIncrement;
}
/**
* 设置 增加 所在楼宇
* @param buildingIncrement
*/
public void setBuildingIncrement(Integer buildingIncrement){
this.buildingIncrement = buildingIncrement;
}
/**
* 获取 所在楼宇
* @return buildingList
*/
public List<Integer> getBuildingList(){
return this.buildingList;
}
/**
* 设置 所在楼宇
* @param buildingList
*/
public void setBuildingList(List<Integer> buildingList){
this.buildingList = buildingList;
}
/**
* 获取 所在楼宇
* @return buildingNotList
*/
public List<Integer> getBuildingNotList(){
return this.buildingNotList;
}
/**
* 设置 所在楼宇
* @param buildingNotList
*/
public void setBuildingNotList(List<Integer> buildingNotList){
this.buildingNotList = buildingNotList;
}
/**
* 获取 开始 所在楼层
* @return floorStart
*/
public Integer getFloorStart(){
return this.floorStart;
}
/**
* 设置 开始 所在楼层
* @param floorStart
*/
public void setFloorStart(Integer floorStart){
this.floorStart = floorStart;
}
/**
* 获取 结束 所在楼层
* @return $floorEnd
*/
public Integer getFloorEnd(){
return this.floorEnd;
}
/**
* 设置 结束 所在楼层
* @param floorEnd
*/
public void setFloorEnd(Integer floorEnd){
this.floorEnd = floorEnd;
}
/**
* 获取 增加 所在楼层
* @return floorIncrement
*/
public Integer getFloorIncrement(){
return this.floorIncrement;
}
/**
* 设置 增加 所在楼层
* @param floorIncrement
*/
public void setFloorIncrement(Integer floorIncrement){
this.floorIncrement = floorIncrement;
}
/**
* 获取 所在楼层
* @return floorList
*/
public List<Integer> getFloorList(){
return this.floorList;
}
/**
* 设置 所在楼层
* @param floorList
*/
public void setFloorList(List<Integer> floorList){
this.floorList = floorList;
}
/**
* 获取 所在楼层
* @return floorNotList
*/
public List<Integer> getFloorNotList(){
return this.floorNotList;
}
/**
* 设置 所在楼层
* @param floorNotList
*/
public void setFloorNotList(List<Integer> floorNotList){
this.floorNotList = floorNotList;
}
/**
* 获取 设备地址
* @return addressList
*/
public List<String> getAddressList(){
return this.addressList;
}
/**
* 设置 设备地址
* @param addressList
*/
public void setAddressList(List<String> addressList){
this.addressList = addressList;
}
/**
* 获取 设备地址
* @return addressNotList
*/
public List<String> getAddressNotList(){
return this.addressNotList;
}
/**
* 设置 设备地址
* @param addressNotList
*/
public void setAddressNotList(List<String> addressNotList){
this.addressNotList = addressNotList;
}
/**
* 获取 管理员账号
* @return manageUserList
*/
public List<String> getManageUserList(){
return this.manageUserList;
}
/**
* 设置 管理员账号
* @param manageUserList
*/
public void setManageUserList(List<String> manageUserList){
this.manageUserList = manageUserList;
}
/**
* 获取 管理员账号
* @return manageUserNotList
*/
public List<String> getManageUserNotList(){
return this.manageUserNotList;
}
/**
* 设置 管理员账号
* @param manageUserNotList
*/
public void setManageUserNotList(List<String> manageUserNotList){
this.manageUserNotList = manageUserNotList;
}
/**
* 获取 管理员密码
* @return managePWDList
*/
public List<String> getManagePWDList(){
return this.managePWDList;
}
/**
* 设置 管理员密码
* @param managePWDList
*/
public void setManagePWDList(List<String> managePWDList){
this.managePWDList = managePWDList;
}
/**
* 获取 管理员密码
* @return managePWDNotList
*/
public List<String> getManagePWDNotList(){
return this.managePWDNotList;
}
/**
* 设置 管理员密码
* @param managePWDNotList
*/
public void setManagePWDNotList(List<String> managePWDNotList){
this.managePWDNotList = managePWDNotList;
}
/**
* 获取 备注
* @return remarkList
*/
public List<String> getRemarkList(){
return this.remarkList;
}
/**
* 设置 备注
* @param remarkList
*/
public void setRemarkList(List<String> remarkList){
this.remarkList = remarkList;
}
/**
* 获取 备注
* @return remarkNotList
*/
public List<String> getRemarkNotList(){
return this.remarkNotList;
}
/**
* 设置 备注
* @param remarkNotList
*/
public void setRemarkNotList(List<String> remarkNotList){
this.remarkNotList = remarkNotList;
}
/**
* 获取 开始 设备状态，0：未激活，1：离线:2：在线
* @return statusStart
*/
public Integer getStatusStart(){
return this.statusStart;
}
/**
* 设置 开始 设备状态，0：未激活，1：离线:2：在线
* @param statusStart
*/
public void setStatusStart(Integer statusStart){
this.statusStart = statusStart;
}
/**
* 获取 结束 设备状态，0：未激活，1：离线:2：在线
* @return $statusEnd
*/
public Integer getStatusEnd(){
return this.statusEnd;
}
/**
* 设置 结束 设备状态，0：未激活，1：离线:2：在线
* @param statusEnd
*/
public void setStatusEnd(Integer statusEnd){
this.statusEnd = statusEnd;
}
/**
* 获取 增加 设备状态，0：未激活，1：离线:2：在线
* @return statusIncrement
*/
public Integer getStatusIncrement(){
return this.statusIncrement;
}
/**
* 设置 增加 设备状态，0：未激活，1：离线:2：在线
* @param statusIncrement
*/
public void setStatusIncrement(Integer statusIncrement){
this.statusIncrement = statusIncrement;
}
/**
* 获取 设备状态，0：未激活，1：离线:2：在线
* @return statusList
*/
public List<Integer> getStatusList(){
return this.statusList;
}
/**
* 设置 设备状态，0：未激活，1：离线:2：在线
* @param statusList
*/
public void setStatusList(List<Integer> statusList){
this.statusList = statusList;
}
/**
* 获取 设备状态，0：未激活，1：离线:2：在线
* @return statusNotList
*/
public List<Integer> getStatusNotList(){
return this.statusNotList;
}
/**
* 设置 设备状态，0：未激活，1：离线:2：在线
* @param statusNotList
*/
public void setStatusNotList(List<Integer> statusNotList){
this.statusNotList = statusNotList;
}
/**
* 获取 开始 启停状态，0：停用,1：启用
* @return enabledStart
*/
public Integer getEnabledStart(){
return this.enabledStart;
}
/**
* 设置 开始 启停状态，0：停用,1：启用
* @param enabledStart
*/
public void setEnabledStart(Integer enabledStart){
this.enabledStart = enabledStart;
}
/**
* 获取 结束 启停状态，0：停用,1：启用
* @return $enabledEnd
*/
public Integer getEnabledEnd(){
return this.enabledEnd;
}
/**
* 设置 结束 启停状态，0：停用,1：启用
* @param enabledEnd
*/
public void setEnabledEnd(Integer enabledEnd){
this.enabledEnd = enabledEnd;
}
/**
* 获取 增加 启停状态，0：停用,1：启用
* @return enabledIncrement
*/
public Integer getEnabledIncrement(){
return this.enabledIncrement;
}
/**
* 设置 增加 启停状态，0：停用,1：启用
* @param enabledIncrement
*/
public void setEnabledIncrement(Integer enabledIncrement){
this.enabledIncrement = enabledIncrement;
}
/**
* 获取 启停状态，0：停用,1：启用
* @return enabledList
*/
public List<Integer> getEnabledList(){
return this.enabledList;
}
/**
* 设置 启停状态，0：停用,1：启用
* @param enabledList
*/
public void setEnabledList(List<Integer> enabledList){
this.enabledList = enabledList;
}
/**
* 获取 启停状态，0：停用,1：启用
* @return enabledNotList
*/
public List<Integer> getEnabledNotList(){
return this.enabledNotList;
}
/**
* 设置 启停状态，0：停用,1：启用
* @param enabledNotList
*/
public void setEnabledNotList(List<Integer> enabledNotList){
this.enabledNotList = enabledNotList;
}
/**
* 获取 开始 创建用户
* @return createUserIdStart
*/
public Long getCreateUserIdStart(){
return this.createUserIdStart;
}
/**
* 设置 开始 创建用户
* @param createUserIdStart
*/
public void setCreateUserIdStart(Long createUserIdStart){
this.createUserIdStart = createUserIdStart;
}
/**
* 获取 结束 创建用户
* @return $createUserIdEnd
*/
public Long getCreateUserIdEnd(){
return this.createUserIdEnd;
}
/**
* 设置 结束 创建用户
* @param createUserIdEnd
*/
public void setCreateUserIdEnd(Long createUserIdEnd){
this.createUserIdEnd = createUserIdEnd;
}
/**
* 获取 增加 创建用户
* @return createUserIdIncrement
*/
public Long getCreateUserIdIncrement(){
return this.createUserIdIncrement;
}
/**
* 设置 增加 创建用户
* @param createUserIdIncrement
*/
public void setCreateUserIdIncrement(Long createUserIdIncrement){
this.createUserIdIncrement = createUserIdIncrement;
}
/**
* 获取 创建用户
* @return createUserIdList
*/
public List<Long> getCreateUserIdList(){
return this.createUserIdList;
}
/**
* 设置 创建用户
* @param createUserIdList
*/
public void setCreateUserIdList(List<Long> createUserIdList){
this.createUserIdList = createUserIdList;
}
/**
* 获取 创建用户
* @return createUserIdNotList
*/
public List<Long> getCreateUserIdNotList(){
return this.createUserIdNotList;
}
/**
* 设置 创建用户
* @param createUserIdNotList
*/
public void setCreateUserIdNotList(List<Long> createUserIdNotList){
this.createUserIdNotList = createUserIdNotList;
}
/**
* 获取 开始 创建时间
* @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;
}
/**
* 获取 开始 更新用户
* @return updateUserIdStart
*/
public Long getUpdateUserIdStart(){
return this.updateUserIdStart;
}
/**
* 设置 开始 更新用户
* @param updateUserIdStart
*/
public void setUpdateUserIdStart(Long updateUserIdStart){
this.updateUserIdStart = updateUserIdStart;
}
/**
* 获取 结束 更新用户
* @return $updateUserIdEnd
*/
public Long getUpdateUserIdEnd(){
return this.updateUserIdEnd;
}
/**
* 设置 结束 更新用户
* @param updateUserIdEnd
*/
public void setUpdateUserIdEnd(Long updateUserIdEnd){
this.updateUserIdEnd = updateUserIdEnd;
}
/**
* 获取 增加 更新用户
* @return updateUserIdIncrement
*/
public Long getUpdateUserIdIncrement(){
return this.updateUserIdIncrement;
}
/**
* 设置 增加 更新用户
* @param updateUserIdIncrement
*/
public void setUpdateUserIdIncrement(Long updateUserIdIncrement){
this.updateUserIdIncrement = updateUserIdIncrement;
}
/**
* 获取 更新用户
* @return updateUserIdList
*/
public List<Long> getUpdateUserIdList(){
return this.updateUserIdList;
}
/**
* 设置 更新用户
* @param updateUserIdList
*/
public void setUpdateUserIdList(List<Long> updateUserIdList){
this.updateUserIdList = updateUserIdList;
}
/**
* 获取 更新用户
* @return updateUserIdNotList
*/
public List<Long> getUpdateUserIdNotList(){
return this.updateUserIdNotList;
}
/**
* 设置 更新用户
* @param updateUserIdNotList
*/
public void setUpdateUserIdNotList(List<Long> updateUserIdNotList){
this.updateUserIdNotList = updateUserIdNotList;
}
/**
* 获取 开始 更新时间
* @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;
}
/**
* 设置 序号，主键，自增长
* @param id
*/
public DeviceQuery id(Long id){
setId(id);
return this;
}
/**
* 设置 开始 序号，主键，自增长
* @param idStart
*/
public DeviceQuery idStart(Long idStart){
this.idStart = idStart;
return this;
}
/**
* 设置 结束 序号，主键，自增长
* @param idEnd
*/
public DeviceQuery idEnd(Long idEnd){
this.idEnd = idEnd;
return this;
}
/**
* 设置 增加 序号，主键，自增长
* @param idIncrement
*/
public DeviceQuery idIncrement(Long idIncrement){
this.idIncrement = idIncrement;
return this;
}
/**
* 设置 序号，主键，自增长
* @param idList
*/
public DeviceQuery idList(List<Long> idList){
this.idList = idList;
return this;
}
/**
* 设置 序号，主键，自增长
* @param idNotList
*/
public DeviceQuery idNotList(List<Long> idNotList){
this.idNotList = idNotList;
return this;
}
/**
* 设置 设备名称
* @param deviceName
*/
public DeviceQuery deviceName(String deviceName){
setDeviceName(deviceName);
return this;
}
/**
* 设置 设备名称
* @param deviceNameList
*/
public DeviceQuery deviceNameList(List<String> deviceNameList){
this.deviceNameList = deviceNameList;
return this;
}
/**
* 设置 设备编码
* @param deviceCode
*/
public DeviceQuery deviceCode(String deviceCode){
setDeviceCode(deviceCode);
return this;
}
/**
* 设置 设备编码
* @param deviceCodeList
*/
public DeviceQuery deviceCodeList(List<String> deviceCodeList){
this.deviceCodeList = deviceCodeList;
return this;
}
/**
* 设置 设备类型1考勤机
* @param deviceType
*/
public DeviceQuery deviceType(Integer deviceType){
setDeviceType(deviceType);
return this;
}
/**
* 设置 开始 设备类型1考勤机
* @param deviceTypeStart
*/
public DeviceQuery deviceTypeStart(Integer deviceTypeStart){
this.deviceTypeStart = deviceTypeStart;
return this;
}
/**
* 设置 结束 设备类型1考勤机
* @param deviceTypeEnd
*/
public DeviceQuery deviceTypeEnd(Integer deviceTypeEnd){
this.deviceTypeEnd = deviceTypeEnd;
return this;
}
/**
* 设置 增加 设备类型1考勤机
* @param deviceTypeIncrement
*/
public DeviceQuery deviceTypeIncrement(Integer deviceTypeIncrement){
this.deviceTypeIncrement = deviceTypeIncrement;
return this;
}
/**
* 设置 设备类型1考勤机
* @param deviceTypeList
*/
public DeviceQuery deviceTypeList(List<Integer> deviceTypeList){
this.deviceTypeList = deviceTypeList;
return this;
}
/**
* 设置 设备类型1考勤机
* @param deviceTypeNotList
*/
public DeviceQuery deviceTypeNotList(List<Integer> deviceTypeNotList){
this.deviceTypeNotList = deviceTypeNotList;
return this;
}
/**
* 设置 Mac地址
* @param deviceMac
*/
public DeviceQuery deviceMac(String deviceMac){
setDeviceMac(deviceMac);
return this;
}
/**
* 设置 Mac地址
* @param deviceMacList
*/
public DeviceQuery deviceMacList(List<String> deviceMacList){
this.deviceMacList = deviceMacList;
return this;
}
/**
* 设置 设备厂商
* @param deviceFirmname
*/
public DeviceQuery deviceFirmname(String deviceFirmname){
setDeviceFirmname(deviceFirmname);
return this;
}
/**
* 设置 设备厂商
* @param deviceFirmnameList
*/
public DeviceQuery deviceFirmnameList(List<String> deviceFirmnameList){
this.deviceFirmnameList = deviceFirmnameList;
return this;
}
/**
* 设置 设备型号
* @param modelNum
*/
public DeviceQuery modelNum(String modelNum){
setModelNum(modelNum);
return this;
}
/**
* 设置 设备型号
* @param modelNumList
*/
public DeviceQuery modelNumList(List<String> modelNumList){
this.modelNumList = modelNumList;
return this;
}
/**
* 设置 设备IP地址
* @param ip
*/
public DeviceQuery ip(String ip){
setIp(ip);
return this;
}
/**
* 设置 设备IP地址
* @param ipList
*/
public DeviceQuery ipList(List<String> ipList){
this.ipList = ipList;
return this;
}
/**
* 设置 端口号
* @param port
*/
public DeviceQuery port(String port){
setPort(port);
return this;
}
/**
* 设置 端口号
* @param portList
*/
public DeviceQuery portList(List<String> portList){
this.portList = portList;
return this;
}
/**
* 设置 设备分辨率
* @param resolution
*/
public DeviceQuery resolution(String resolution){
setResolution(resolution);
return this;
}
/**
* 设置 设备分辨率
* @param resolutionList
*/
public DeviceQuery resolutionList(List<String> resolutionList){
this.resolutionList = resolutionList;
return this;
}
/**
* 设置 负责人
* @param leadingOfficial
*/
public DeviceQuery leadingOfficial(String leadingOfficial){
setLeadingOfficial(leadingOfficial);
return this;
}
/**
* 设置 负责人
* @param leadingOfficialList
*/
public DeviceQuery leadingOfficialList(List<String> leadingOfficialList){
this.leadingOfficialList = leadingOfficialList;
return this;
}
/**
* 设置 负责人电话
* @param telephone
*/
public DeviceQuery telephone(String telephone){
setTelephone(telephone);
return this;
}
/**
* 设置 负责人电话
* @param telephoneList
*/
public DeviceQuery telephoneList(List<String> telephoneList){
this.telephoneList = telephoneList;
return this;
}
/**
* 设置 设备经度
* @param longitude
*/
public DeviceQuery longitude(String longitude){
setLongitude(longitude);
return this;
}
/**
* 设置 设备经度
* @param longitudeList
*/
public DeviceQuery longitudeList(List<String> longitudeList){
this.longitudeList = longitudeList;
return this;
}
/**
* 设置 设备纬度
* @param latitude
*/
public DeviceQuery latitude(String latitude){
setLatitude(latitude);
return this;
}
/**
* 设置 设备纬度
* @param latitudeList
*/
public DeviceQuery latitudeList(List<String> latitudeList){
this.latitudeList = latitudeList;
return this;
}
/**
* 设置 所在楼宇
* @param building
*/
public DeviceQuery building(Integer building){
setBuilding(building);
return this;
}
/**
* 设置 开始 所在楼宇
* @param buildingStart
*/
public DeviceQuery buildingStart(Integer buildingStart){
this.buildingStart = buildingStart;
return this;
}
/**
* 设置 结束 所在楼宇
* @param buildingEnd
*/
public DeviceQuery buildingEnd(Integer buildingEnd){
this.buildingEnd = buildingEnd;
return this;
}
/**
* 设置 增加 所在楼宇
* @param buildingIncrement
*/
public DeviceQuery buildingIncrement(Integer buildingIncrement){
this.buildingIncrement = buildingIncrement;
return this;
}
/**
* 设置 所在楼宇
* @param buildingList
*/
public DeviceQuery buildingList(List<Integer> buildingList){
this.buildingList = buildingList;
return this;
}
/**
* 设置 所在楼宇
* @param buildingNotList
*/
public DeviceQuery buildingNotList(List<Integer> buildingNotList){
this.buildingNotList = buildingNotList;
return this;
}
/**
* 设置 所在楼层
* @param floor
*/
public DeviceQuery floor(Integer floor){
setFloor(floor);
return this;
}
/**
* 设置 开始 所在楼层
* @param floorStart
*/
public DeviceQuery floorStart(Integer floorStart){
this.floorStart = floorStart;
return this;
}
/**
* 设置 结束 所在楼层
* @param floorEnd
*/
public DeviceQuery floorEnd(Integer floorEnd){
this.floorEnd = floorEnd;
return this;
}
/**
* 设置 增加 所在楼层
* @param floorIncrement
*/
public DeviceQuery floorIncrement(Integer floorIncrement){
this.floorIncrement = floorIncrement;
return this;
}
/**
* 设置 所在楼层
* @param floorList
*/
public DeviceQuery floorList(List<Integer> floorList){
this.floorList = floorList;
return this;
}
/**
* 设置 所在楼层
* @param floorNotList
*/
public DeviceQuery floorNotList(List<Integer> floorNotList){
this.floorNotList = floorNotList;
return this;
}
/**
* 设置 设备地址
* @param address
*/
public DeviceQuery address(String address){
setAddress(address);
return this;
}
/**
* 设置 设备地址
* @param addressList
*/
public DeviceQuery addressList(List<String> addressList){
this.addressList = addressList;
return this;
}
/**
* 设置 管理员账号
* @param manageUser
*/
public DeviceQuery manageUser(String manageUser){
setManageUser(manageUser);
return this;
}
/**
* 设置 管理员账号
* @param manageUserList
*/
public DeviceQuery manageUserList(List<String> manageUserList){
this.manageUserList = manageUserList;
return this;
}
/**
* 设置 管理员密码
* @param managePWD
*/
public DeviceQuery managePWD(String managePWD){
setManagePWD(managePWD);
return this;
}
/**
* 设置 管理员密码
* @param managePWDList
*/
public DeviceQuery managePWDList(List<String> managePWDList){
this.managePWDList = managePWDList;
return this;
}
/**
* 设置 备注
* @param remark
*/
public DeviceQuery remark(String remark){
setRemark(remark);
return this;
}
/**
* 设置 备注
* @param remarkList
*/
public DeviceQuery remarkList(List<String> remarkList){
this.remarkList = remarkList;
return this;
}
/**
* 设置 设备状态，0：未激活，1：离线:2：在线
* @param status
*/
public DeviceQuery status(Integer status){
setStatus(status);
return this;
}
/**
* 设置 开始 设备状态，0：未激活，1：离线:2：在线
* @param statusStart
*/
public DeviceQuery statusStart(Integer statusStart){
this.statusStart = statusStart;
return this;
}
/**
* 设置 结束 设备状态，0：未激活，1：离线:2：在线
* @param statusEnd
*/
public DeviceQuery statusEnd(Integer statusEnd){
this.statusEnd = statusEnd;
return this;
}
/**
* 设置 增加 设备状态，0：未激活，1：离线:2：在线
* @param statusIncrement
*/
public DeviceQuery statusIncrement(Integer statusIncrement){
this.statusIncrement = statusIncrement;
return this;
}
/**
* 设置 设备状态，0：未激活，1：离线:2：在线
* @param statusList
*/
public DeviceQuery statusList(List<Integer> statusList){
this.statusList = statusList;
return this;
}
/**
* 设置 设备状态，0：未激活，1：离线:2：在线
* @param statusNotList
*/
public DeviceQuery statusNotList(List<Integer> statusNotList){
this.statusNotList = statusNotList;
return this;
}
/**
* 设置 启停状态，0：停用,1：启用
* @param enabled
*/
public DeviceQuery enabled(Integer enabled){
setEnabled(enabled);
return this;
}
/**
* 设置 开始 启停状态，0：停用,1：启用
* @param enabledStart
*/
public DeviceQuery enabledStart(Integer enabledStart){
this.enabledStart = enabledStart;
return this;
}
/**
* 设置 结束 启停状态，0：停用,1：启用
* @param enabledEnd
*/
public DeviceQuery enabledEnd(Integer enabledEnd){
this.enabledEnd = enabledEnd;
return this;
}
/**
* 设置 增加 启停状态，0：停用,1：启用
* @param enabledIncrement
*/
public DeviceQuery enabledIncrement(Integer enabledIncrement){
this.enabledIncrement = enabledIncrement;
return this;
}
/**
* 设置 启停状态，0：停用,1：启用
* @param enabledList
*/
public DeviceQuery enabledList(List<Integer> enabledList){
this.enabledList = enabledList;
return this;
}
/**
* 设置 启停状态，0：停用,1：启用
* @param enabledNotList
*/
public DeviceQuery enabledNotList(List<Integer> enabledNotList){
this.enabledNotList = enabledNotList;
return this;
}
/**
* 设置 创建用户
* @param createUserId
*/
public DeviceQuery createUserId(Long createUserId){
setCreateUserId(createUserId);
return this;
}
/**
* 设置 开始 创建用户
* @param createUserIdStart
*/
public DeviceQuery createUserIdStart(Long createUserIdStart){
this.createUserIdStart = createUserIdStart;
return this;
}
/**
* 设置 结束 创建用户
* @param createUserIdEnd
*/
public DeviceQuery createUserIdEnd(Long createUserIdEnd){
this.createUserIdEnd = createUserIdEnd;
return this;
}
/**
* 设置 增加 创建用户
* @param createUserIdIncrement
*/
public DeviceQuery createUserIdIncrement(Long createUserIdIncrement){
this.createUserIdIncrement = createUserIdIncrement;
return this;
}
/**
* 设置 创建用户
* @param createUserIdList
*/
public DeviceQuery createUserIdList(List<Long> createUserIdList){
this.createUserIdList = createUserIdList;
return this;
}
/**
* 设置 创建用户
* @param createUserIdNotList
*/
public DeviceQuery createUserIdNotList(List<Long> createUserIdNotList){
this.createUserIdNotList = createUserIdNotList;
return this;
}
/**
* 设置 更新用户
* @param updateUserId
*/
public DeviceQuery updateUserId(Long updateUserId){
setUpdateUserId(updateUserId);
return this;
}
/**
* 设置 开始 更新用户
* @param updateUserIdStart
*/
public DeviceQuery updateUserIdStart(Long updateUserIdStart){
this.updateUserIdStart = updateUserIdStart;
return this;
}
/**
* 设置 结束 更新用户
* @param updateUserIdEnd
*/
public DeviceQuery updateUserIdEnd(Long updateUserIdEnd){
this.updateUserIdEnd = updateUserIdEnd;
return this;
}
/**
* 设置 增加 更新用户
* @param updateUserIdIncrement
*/
public DeviceQuery updateUserIdIncrement(Long updateUserIdIncrement){
this.updateUserIdIncrement = updateUserIdIncrement;
return this;
}
/**
* 设置 更新用户
* @param updateUserIdList
*/
public DeviceQuery updateUserIdList(List<Long> updateUserIdList){
this.updateUserIdList = updateUserIdList;
return this;
}
/**
* 设置 更新用户
* @param updateUserIdNotList
*/
public DeviceQuery 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<DeviceQuery> 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<DeviceQuery> orConditionList){
this.orConditionList = orConditionList;
}
/**
* 获取 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
* @return andConditionList
*/
public List<DeviceQuery> getAndConditionList(){
return this.andConditionList;
}
/**
* 设置 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
* @param andConditionList
*/
public void setAndConditionList(List<DeviceQuery> andConditionList){
this.andConditionList = andConditionList;
}
}
\ No newline at end of file
attendance-performance-manager/src/main/java/com/mortals/xhx/module/device/model/vo/DeviceVo.java 0 → 100644
View file @ 16096179
package com.mortals.xhx.module.device.model.vo;
import com.mortals.framework.model.BaseEntityLong;
import com.mortals.xhx.module.device.model.DeviceEntity;
import java.util.ArrayList;
import java.util.List;
import lombok.Data;
import com.mortals.framework.annotation.Excel;
import java.math.BigDecimal;
import java.util.Date;
/**
* 考勤机管理视图对象
*
* @author zxfei
* @date 2025-04-09
*/
@Data
public class DeviceVo extends BaseEntityLong {
/** 序号，主键，自增长列表 */
private List <Long> idList;
}
\ No newline at end of file
attendance-performance-manager/src/main/java/com/mortals/xhx/module/device/service/DeviceService.java 0 → 100644
View file @ 16096179
package com.mortals.xhx.module.device.service;
import com.mortals.framework.service.ICRUDService;
import com.mortals.xhx.module.device.model.DeviceEntity;
import com.mortals.xhx.module.device.dao.DeviceDao;
/**
* DeviceService
*
* 考勤机管理 service接口
*
* @author zxfei
* @date 2025-04-09
*/
public interface DeviceService extends ICRUDService<DeviceEntity,Long>{
DeviceDao getDao();
}
\ No newline at end of file
attendance-performance-manager/src/main/java/com/mortals/xhx/module/device/service/impl/DeviceServiceImpl.java 0 → 100644
View file @ 16096179
package com.mortals.xhx.module.device.service.impl;
import com.mortals.framework.model.PageInfo;
import org.springframework.beans.BeanUtils;
import java.util.function.Function;
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.device.dao.DeviceDao;
import com.mortals.xhx.module.device.model.DeviceEntity;
import com.mortals.xhx.module.device.service.DeviceService;
import lombok.extern.slf4j.Slf4j;
/**
* DeviceService
* 考勤机管理 service实现
*
* @author zxfei
* @date 2025-04-09
*/
@Service("deviceService")
@Slf4j
public class DeviceServiceImpl extends AbstractCRUDServiceImpl<DeviceDao, DeviceEntity, Long> implements DeviceService {
}
\ No newline at end of file
attendance-performance-manager/src/main/java/com/mortals/xhx/module/device/web/DeviceController.java 0 → 100644
View file @ 16096179
package com.mortals.xhx.module.device.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.device.model.DeviceEntity;
import com.mortals.xhx.module.device.service.DeviceService;
import org.apache.commons.lang3.ArrayUtils;
import com.mortals.framework.util.StringUtils;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import com.alibaba.fastjson.JSONObject;
import java.util.Arrays;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import static com.mortals.framework.ap.SysConstains.*;
import com.mortals.xhx.common.code.*;
/**
*
* 考勤机管理
*
* @author zxfei
* @date 2025-04-09
*/
@RestController
@RequestMapping("device")
public class DeviceController extends BaseCRUDJsonBodyMappingController<DeviceService,DeviceEntity,Long> {
@Autowired
private ParamService paramService;
public DeviceController(){
super.setModuleDesc( "考勤机管理");
}
@Override
protected void init(Map<String, Object> model, Context context) {
this.addDict(model, "deviceType", DeviceTypeEnum.getEnumMap());
this.addDict(model, "building", BuildingEnum.getEnumMap());
this.addDict(model, "floor", FloorEnum.getEnumMap());
this.addDict(model, "status", StatusEnum.getEnumMap());
this.addDict(model, "enabled", EnabledEnum.getEnumMap());
super.init(model, context);
}
}
\ No newline at end of file
attendance-performance-manager/src/main/resources/sqlmap/module/device/DeviceMapper.xml 0 → 100644
View file @ 16096179
<?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">
<!-- 字段和属性映射 -->
<resultMap type="DeviceEntity" id="DeviceEntity-Map">
<id property="id" column="id" />
<result property="deviceName" column="deviceName" />
<result property="deviceCode" column="deviceCode" />
<result property="deviceType" column="deviceType" />
<result property="deviceMac" column="deviceMac" />
<result property="deviceFirmname" column="deviceFirmname" />
<result property="modelNum" column="modelNum" />
<result property="ip" column="ip" />
<result property="port" column="port" />
<result property="resolution" column="resolution" />
<result property="leadingOfficial" column="leadingOfficial" />
<result property="telephone" column="telephone" />
<result property="longitude" column="longitude" />
<result property="latitude" column="latitude" />
<result property="building" column="building" />
<result property="floor" column="floor" />
<result property="address" column="address" />
<result property="manageUser" column="manageUser" />
<result property="managePWD" column="managePWD" />
<result property="remark" column="remark" />
<result property="status" column="status" />
<result property="enabled" column="enabled" />
<result property="createUserId" column="createUserId" />
<result property="createTime" column="createTime" />
<result property="updateUserId" column="updateUserId" />
<result property="updateTime" column="updateTime" />
</resultMap>
<!-- 表所有列 -->
<sql id="_columns">
<trim suffixOverrides="," suffix="">
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('id') or colPickMode == 1 and data.containsKey('id')))">
a.id,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('deviceName') or colPickMode == 1 and data.containsKey('deviceName')))">
a.deviceName,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('deviceCode') or colPickMode == 1 and data.containsKey('deviceCode')))">
a.deviceCode,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('deviceType') or colPickMode == 1 and data.containsKey('deviceType')))">
a.deviceType,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('deviceMac') or colPickMode == 1 and data.containsKey('deviceMac')))">
a.deviceMac,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('deviceFirmname') or colPickMode == 1 and data.containsKey('deviceFirmname')))">
a.deviceFirmname,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('modelNum') or colPickMode == 1 and data.containsKey('modelNum')))">
a.modelNum,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('ip') or colPickMode == 1 and data.containsKey('ip')))">
a.ip,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('port') or colPickMode == 1 and data.containsKey('port')))">
a.port,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('resolution') or colPickMode == 1 and data.containsKey('resolution')))">
a.resolution,
</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>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('telephone') or colPickMode == 1 and data.containsKey('telephone')))">
a.telephone,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('longitude') or colPickMode == 1 and data.containsKey('longitude')))">
a.longitude,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('latitude') or colPickMode == 1 and data.containsKey('latitude')))">
a.latitude,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('building') or colPickMode == 1 and data.containsKey('building')))">
a.building,
</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>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('address') or colPickMode == 1 and data.containsKey('address')))">
a.address,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('manageUser') or colPickMode == 1 and data.containsKey('manageUser')))">
a.manageUser,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('managePWD') or colPickMode == 1 and data.containsKey('managePWD')))">
a.managePWD,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('remark') or colPickMode == 1 and data.containsKey('remark')))">
a.remark,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('status') or colPickMode == 1 and data.containsKey('status')))">
a.status,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('enabled') or colPickMode == 1 and data.containsKey('enabled')))">
a.enabled,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createUserId') or colPickMode == 1 and data.containsKey('createUserId')))">
a.createUserId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createTime') or colPickMode == 1 and data.containsKey('createTime')))">
a.createTime,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateUserId') or colPickMode == 1 and data.containsKey('updateUserId')))">
a.updateUserId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateTime') or colPickMode == 1 and data.containsKey('updateTime')))">
a.updateTime,
</if>
</trim>
</sql>
<!-- 新增 区分主键自增加还是业务插入 -->
<insert id="insert" parameterType="DeviceEntity" useGeneratedKeys="true" keyProperty="id">
insert into mortals_xhx_device
(deviceName,deviceCode,deviceType,deviceMac,deviceFirmname,modelNum,ip,port,resolution,leadingOfficial,telephone,longitude,latitude,building,floor,address,manageUser,managePWD,remark,status,enabled,createUserId,createTime,updateUserId,updateTime)
VALUES
(#{deviceName},#{deviceCode},#{deviceType},#{deviceMac},#{deviceFirmname},#{modelNum},#{ip},#{port},#{resolution},#{leadingOfficial},#{telephone},#{longitude},#{latitude},#{building},#{floor},#{address},#{manageUser},#{managePWD},#{remark},#{status},#{enabled},#{createUserId},#{createTime},#{updateUserId},#{updateTime})
</insert>
<!-- 批量新增 -->
<insert id="insertBatch" parameterType="paramDto">
insert into mortals_xhx_device
(deviceName,deviceCode,deviceType,deviceMac,deviceFirmname,modelNum,ip,port,resolution,leadingOfficial,telephone,longitude,latitude,building,floor,address,manageUser,managePWD,remark,status,enabled,createUserId,createTime,updateUserId,updateTime)
VALUES
<foreach collection="data.dataList" item="item" index="index" separator="," >
(#{item.deviceName},#{item.deviceCode},#{item.deviceType},#{item.deviceMac},#{item.deviceFirmname},#{item.modelNum},#{item.ip},#{item.port},#{item.resolution},#{item.leadingOfficial},#{item.telephone},#{item.longitude},#{item.latitude},#{item.building},#{item.floor},#{item.address},#{item.manageUser},#{item.managePWD},#{item.remark},#{item.status},#{item.enabled},#{item.createUserId},#{item.createTime},#{item.updateUserId},#{item.updateTime})
</foreach>
</insert>
<!-- 根据ParamDto更新 -->
<update id="update" parameterType="paramDto">
update mortals_xhx_device as a
set
<trim suffixOverrides="," suffix="">
<if test="(colPickMode==0 and data.containsKey('deviceName')) or (colPickMode==1 and !data.containsKey('deviceName'))">
a.deviceName=#{data.deviceName},
</if>
<if test="(colPickMode==0 and data.containsKey('deviceCode')) or (colPickMode==1 and !data.containsKey('deviceCode'))">
a.deviceCode=#{data.deviceCode},
</if>
<if test="(colPickMode==0 and data.containsKey('deviceType')) or (colPickMode==1 and !data.containsKey('deviceType'))">
a.deviceType=#{data.deviceType},
</if>
<if test="(colPickMode==0 and data.containsKey('deviceTypeIncrement')) or (colPickMode==1 and !data.containsKey('deviceTypeIncrement'))">
a.deviceType=ifnull(a.deviceType,0) + #{data.deviceTypeIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('deviceMac')) or (colPickMode==1 and !data.containsKey('deviceMac'))">
a.deviceMac=#{data.deviceMac},
</if>
<if test="(colPickMode==0 and data.containsKey('deviceFirmname')) or (colPickMode==1 and !data.containsKey('deviceFirmname'))">
a.deviceFirmname=#{data.deviceFirmname},
</if>
<if test="(colPickMode==0 and data.containsKey('modelNum')) or (colPickMode==1 and !data.containsKey('modelNum'))">
a.modelNum=#{data.modelNum},
</if>
<if test="(colPickMode==0 and data.containsKey('ip')) or (colPickMode==1 and !data.containsKey('ip'))">
a.ip=#{data.ip},
</if>
<if test="(colPickMode==0 and data.containsKey('port')) or (colPickMode==1 and !data.containsKey('port'))">
a.port=#{data.port},
</if>
<if test="(colPickMode==0 and data.containsKey('resolution')) or (colPickMode==1 and !data.containsKey('resolution'))">
a.resolution=#{data.resolution},
</if>
<if test="(colPickMode==0 and data.containsKey('leadingOfficial')) or (colPickMode==1 and !data.containsKey('leadingOfficial'))">
a.leadingOfficial=#{data.leadingOfficial},
</if>
<if test="(colPickMode==0 and data.containsKey('telephone')) or (colPickMode==1 and !data.containsKey('telephone'))">
a.telephone=#{data.telephone},
</if>
<if test="(colPickMode==0 and data.containsKey('longitude')) or (colPickMode==1 and !data.containsKey('longitude'))">
a.longitude=#{data.longitude},
</if>
<if test="(colPickMode==0 and data.containsKey('latitude')) or (colPickMode==1 and !data.containsKey('latitude'))">
a.latitude=#{data.latitude},
</if>
<if test="(colPickMode==0 and data.containsKey('building')) or (colPickMode==1 and !data.containsKey('building'))">
a.building=#{data.building},
</if>
<if test="(colPickMode==0 and data.containsKey('buildingIncrement')) or (colPickMode==1 and !data.containsKey('buildingIncrement'))">
a.building=ifnull(a.building,0) + #{data.buildingIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('floor')) or (colPickMode==1 and !data.containsKey('floor'))">
a.floor=#{data.floor},
</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>
<if test="(colPickMode==0 and data.containsKey('address')) or (colPickMode==1 and !data.containsKey('address'))">
a.address=#{data.address},
</if>
<if test="(colPickMode==0 and data.containsKey('manageUser')) or (colPickMode==1 and !data.containsKey('manageUser'))">
a.manageUser=#{data.manageUser},
</if>
<if test="(colPickMode==0 and data.containsKey('managePWD')) or (colPickMode==1 and !data.containsKey('managePWD'))">
a.managePWD=#{data.managePWD},
</if>
<if test="(colPickMode==0 and data.containsKey('remark')) or (colPickMode==1 and !data.containsKey('remark'))">
a.remark=#{data.remark},
</if>
<if test="(colPickMode==0 and data.containsKey('status')) or (colPickMode==1 and !data.containsKey('status'))">
a.status=#{data.status},
</if>
<if test="(colPickMode==0 and data.containsKey('statusIncrement')) or (colPickMode==1 and !data.containsKey('statusIncrement'))">
a.status=ifnull(a.status,0) + #{data.statusIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('enabled')) or (colPickMode==1 and !data.containsKey('enabled'))">
a.enabled=#{data.enabled},
</if>
<if test="(colPickMode==0 and data.containsKey('enabledIncrement')) or (colPickMode==1 and !data.containsKey('enabledIncrement'))">
a.enabled=ifnull(a.enabled,0) + #{data.enabledIncrement},
</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('createTime')) or (colPickMode==1 and !data.containsKey('createTime'))">
a.createTime=#{data.createTime},
</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>
<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
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</update>
<!-- 批量更新 -->
<update id="updateBatch" parameterType="paramDto">
update mortals_xhx_device as a
<trim prefix="set" suffixOverrides=",">
<trim prefix="deviceName=(case" suffix="ELSE deviceName end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('deviceName')) or (colPickMode==1 and !item.containsKey('deviceName'))">
when a.id=#{item.id} then #{item.deviceName}
</if>
</foreach>
</trim>
<trim prefix="deviceCode=(case" suffix="ELSE deviceCode end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('deviceCode')) or (colPickMode==1 and !item.containsKey('deviceCode'))">
when a.id=#{item.id} then #{item.deviceCode}
</if>
</foreach>
</trim>
<trim prefix="deviceType=(case" suffix="ELSE deviceType end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('deviceType')) or (colPickMode==1 and !item.containsKey('deviceType'))">
when a.id=#{item.id} then #{item.deviceType}
</when>
<when test="(colPickMode==0 and item.containsKey('deviceTypeIncrement')) or (colPickMode==1 and !item.containsKey('deviceTypeIncrement'))">
when a.id=#{item.id} then ifnull(a.deviceType,0) + #{item.deviceTypeIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="deviceMac=(case" suffix="ELSE deviceMac end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('deviceMac')) or (colPickMode==1 and !item.containsKey('deviceMac'))">
when a.id=#{item.id} then #{item.deviceMac}
</if>
</foreach>
</trim>
<trim prefix="deviceFirmname=(case" suffix="ELSE deviceFirmname end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('deviceFirmname')) or (colPickMode==1 and !item.containsKey('deviceFirmname'))">
when a.id=#{item.id} then #{item.deviceFirmname}
</if>
</foreach>
</trim>
<trim prefix="modelNum=(case" suffix="ELSE modelNum end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('modelNum')) or (colPickMode==1 and !item.containsKey('modelNum'))">
when a.id=#{item.id} then #{item.modelNum}
</if>
</foreach>
</trim>
<trim prefix="ip=(case" suffix="ELSE ip end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('ip')) or (colPickMode==1 and !item.containsKey('ip'))">
when a.id=#{item.id} then #{item.ip}
</if>
</foreach>
</trim>
<trim prefix="port=(case" suffix="ELSE port end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('port')) or (colPickMode==1 and !item.containsKey('port'))">
when a.id=#{item.id} then #{item.port}
</if>
</foreach>
</trim>
<trim prefix="resolution=(case" suffix="ELSE resolution end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('resolution')) or (colPickMode==1 and !item.containsKey('resolution'))">
when a.id=#{item.id} then #{item.resolution}
</if>
</foreach>
</trim>
<trim prefix="leadingOfficial=(case" suffix="ELSE leadingOfficial 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>
</foreach>
</trim>
<trim prefix="telephone=(case" suffix="ELSE telephone end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('telephone')) or (colPickMode==1 and !item.containsKey('telephone'))">
when a.id=#{item.id} then #{item.telephone}
</if>
</foreach>
</trim>
<trim prefix="longitude=(case" suffix="ELSE longitude end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('longitude')) or (colPickMode==1 and !item.containsKey('longitude'))">
when a.id=#{item.id} then #{item.longitude}
</if>
</foreach>
</trim>
<trim prefix="latitude=(case" suffix="ELSE latitude end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('latitude')) or (colPickMode==1 and !item.containsKey('latitude'))">
when a.id=#{item.id} then #{item.latitude}
</if>
</foreach>
</trim>
<trim prefix="building=(case" suffix="ELSE building end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('building')) or (colPickMode==1 and !item.containsKey('building'))">
when a.id=#{item.id} then #{item.building}
</when>
<when test="(colPickMode==0 and item.containsKey('buildingIncrement')) or (colPickMode==1 and !item.containsKey('buildingIncrement'))">
when a.id=#{item.id} then ifnull(a.building,0) + #{item.buildingIncrement}
</when>
</choose>
</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="address=(case" suffix="ELSE address end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('address')) or (colPickMode==1 and !item.containsKey('address'))">
when a.id=#{item.id} then #{item.address}
</if>
</foreach>
</trim>
<trim prefix="manageUser=(case" suffix="ELSE manageUser end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('manageUser')) or (colPickMode==1 and !item.containsKey('manageUser'))">
when a.id=#{item.id} then #{item.manageUser}
</if>
</foreach>
</trim>
<trim prefix="managePWD=(case" suffix="ELSE managePWD end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('managePWD')) or (colPickMode==1 and !item.containsKey('managePWD'))">
when a.id=#{item.id} then #{item.managePWD}
</if>
</foreach>
</trim>
<trim prefix="remark=(case" suffix="ELSE remark end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('remark')) or (colPickMode==1 and !item.containsKey('remark'))">
when a.id=#{item.id} then #{item.remark}
</if>
</foreach>
</trim>
<trim prefix="status=(case" suffix="ELSE status end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('status')) or (colPickMode==1 and !item.containsKey('status'))">
when a.id=#{item.id} then #{item.status}
</when>
<when test="(colPickMode==0 and item.containsKey('statusIncrement')) or (colPickMode==1 and !item.containsKey('statusIncrement'))">
when a.id=#{item.id} then ifnull(a.status,0) + #{item.statusIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="enabled=(case" suffix="ELSE enabled end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('enabled')) or (colPickMode==1 and !item.containsKey('enabled'))">
when a.id=#{item.id} then #{item.enabled}
</when>
<when test="(colPickMode==0 and item.containsKey('enabledIncrement')) or (colPickMode==1 and !item.containsKey('enabledIncrement'))">
when a.id=#{item.id} then ifnull(a.enabled,0) + #{item.enabledIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="createUserId=(case" suffix="ELSE createUserId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('createUserId')) or (colPickMode==1 and !item.containsKey('createUserId'))">
when a.id=#{item.id} then #{item.createUserId}
</when>
<when test="(colPickMode==0 and item.containsKey('createUserIdIncrement')) or (colPickMode==1 and !item.containsKey('createUserIdIncrement'))">
when a.id=#{item.id} then ifnull(a.createUserId,0) + #{item.createUserIdIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="createTime=(case" suffix="ELSE createTime end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('createTime')) or (colPickMode==1 and !item.containsKey('createTime'))">
when a.id=#{item.id} then #{item.createTime}
</if>
</foreach>
</trim>
<trim prefix="updateUserId=(case" suffix="ELSE updateUserId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('updateUserId')) or (colPickMode==1 and !item.containsKey('updateUserId'))">
when a.id=#{item.id} then #{item.updateUserId}
</when>
<when test="(colPickMode==0 and item.containsKey('updateUserIdIncrement')) or (colPickMode==1 and !item.containsKey('updateUserIdIncrement'))">
when a.id=#{item.id} then ifnull(a.updateUserId,0) + #{item.updateUserIdIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="updateTime=(case" suffix="ELSE updateTime end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('updateTime')) or (colPickMode==1 and !item.containsKey('updateTime'))">
when a.id=#{item.id} then #{item.updateTime}
</if>
</foreach>
</trim>
</trim>
where id in
<foreach collection="data.dataList" item="item" index="index" open="(" separator="," close=")">
#{item.id}
</foreach>
</update>
<!-- 根据主健查询 -->
<select id="getByKey" parameterType="paramDto" resultMap="DeviceEntity-Map">
select <include refid="_columns"/>
from mortals_xhx_device as a
where a.id=#{condition.id}
</select>
<!-- 根据主健删除 -->
<delete id="deleteByKey" parameterType="paramDto">
delete from mortals_xhx_device as a where a.id=#{condition.id}
</delete>
<!-- 根据主健删除一批，针对单一主健有效 -->
<delete id="deleteByKeys">
delete from mortals_xhx_device 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
<foreach collection="list" item="item" index="index" open="(" separator="," close=")">
#{item}
</foreach>
</delete>
<!-- 根据对象列表删除一批，针对单一主健有效 -->
<delete id="deleteByEntityList">
delete from mortals_xhx_device 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
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</delete>
<!-- 获取列表 -->
<select id="getList" parameterType="paramDto" resultMap="DeviceEntity-Map">
select <include refid="_columns"/>
from mortals_xhx_device 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_device 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="permissionSql != null and permissionSql != ''">
${permissionSql}
</if>
<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('deviceName')">
<if test="conditionParamRef.deviceName != null and conditionParamRef.deviceName != ''">
${_conditionType_} a.deviceName like #{${_conditionParam_}.deviceName}
</if>
<if test="conditionParamRef.deviceName == null">
${_conditionType_} a.deviceName is null
</if>
</if>
<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>
<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('deviceType')">
<if test="conditionParamRef.deviceType != null ">
${_conditionType_} a.deviceType = #{${_conditionParam_}.deviceType}
</if>
<if test="conditionParamRef.deviceType == null">
${_conditionType_} a.deviceType is null
</if>
</if>
<if test="conditionParamRef.containsKey('deviceTypeList') and conditionParamRef.deviceTypeList.size() > 0">
${_conditionType_} a.deviceType in
<foreach collection="conditionParamRef.deviceTypeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('deviceTypeNotList') and conditionParamRef.deviceTypeNotList.size() > 0">
${_conditionType_} a.deviceType not in
<foreach collection="conditionParamRef.deviceTypeNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('deviceTypeStart') and conditionParamRef.deviceTypeStart != null">
${_conditionType_} a.deviceType <![CDATA[ >= ]]> #{${_conditionParam_}.deviceTypeStart}
</if>
<if test="conditionParamRef.containsKey('deviceTypeEnd') and conditionParamRef.deviceTypeEnd != null">
${_conditionType_} a.deviceType <![CDATA[ <= ]]> #{${_conditionParam_}.deviceTypeEnd}
</if>
<if test="conditionParamRef.containsKey('deviceMac')">
<if test="conditionParamRef.deviceMac != null and conditionParamRef.deviceMac != ''">
${_conditionType_} a.deviceMac like #{${_conditionParam_}.deviceMac}
</if>
<if test="conditionParamRef.deviceMac == null">
${_conditionType_} a.deviceMac is null
</if>
</if>
<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('deviceFirmname')">
<if test="conditionParamRef.deviceFirmname != null and conditionParamRef.deviceFirmname != ''">
${_conditionType_} a.deviceFirmname like #{${_conditionParam_}.deviceFirmname}
</if>
<if test="conditionParamRef.deviceFirmname == null">
${_conditionType_} a.deviceFirmname is null
</if>
</if>
<if test="conditionParamRef.containsKey('deviceFirmnameList') and conditionParamRef.deviceFirmnameList.size() > 0">
${_conditionType_} a.deviceFirmname in
<foreach collection="conditionParamRef.deviceFirmnameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('deviceFirmnameNotList') and conditionParamRef.deviceFirmnameNotList.size() > 0">
${_conditionType_} a.deviceFirmname not in
<foreach collection="conditionParamRef.deviceFirmnameNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('modelNum')">
<if test="conditionParamRef.modelNum != null and conditionParamRef.modelNum != ''">
${_conditionType_} a.modelNum like #{${_conditionParam_}.modelNum}
</if>
<if test="conditionParamRef.modelNum == null">
${_conditionType_} a.modelNum is null
</if>
</if>
<if test="conditionParamRef.containsKey('modelNumList') and conditionParamRef.modelNumList.size() > 0">
${_conditionType_} a.modelNum in
<foreach collection="conditionParamRef.modelNumList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('modelNumNotList') and conditionParamRef.modelNumNotList.size() > 0">
${_conditionType_} a.modelNum not in
<foreach collection="conditionParamRef.modelNumNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('ip')">
<if test="conditionParamRef.ip != null and conditionParamRef.ip != ''">
${_conditionType_} a.ip like #{${_conditionParam_}.ip}
</if>
<if test="conditionParamRef.ip == null">
${_conditionType_} a.ip is null
</if>
</if>
<if test="conditionParamRef.containsKey('ipList') and conditionParamRef.ipList.size() > 0">
${_conditionType_} a.ip in
<foreach collection="conditionParamRef.ipList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('ipNotList') and conditionParamRef.ipNotList.size() > 0">
${_conditionType_} a.ip not in
<foreach collection="conditionParamRef.ipNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('port')">
<if test="conditionParamRef.port != null and conditionParamRef.port != ''">
${_conditionType_} a.port like #{${_conditionParam_}.port}
</if>
<if test="conditionParamRef.port == null">
${_conditionType_} a.port is null
</if>
</if>
<if test="conditionParamRef.containsKey('portList') and conditionParamRef.portList.size() > 0">
${_conditionType_} a.port in
<foreach collection="conditionParamRef.portList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('portNotList') and conditionParamRef.portNotList.size() > 0">
${_conditionType_} a.port not in
<foreach collection="conditionParamRef.portNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('resolution')">
<if test="conditionParamRef.resolution != null and conditionParamRef.resolution != ''">
${_conditionType_} a.resolution like #{${_conditionParam_}.resolution}
</if>
<if test="conditionParamRef.resolution == null">
${_conditionType_} a.resolution is null
</if>
</if>
<if test="conditionParamRef.containsKey('resolutionList') and conditionParamRef.resolutionList.size() > 0">
${_conditionType_} a.resolution in
<foreach collection="conditionParamRef.resolutionList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('resolutionNotList') and conditionParamRef.resolutionNotList.size() > 0">
${_conditionType_} a.resolution not in
<foreach collection="conditionParamRef.resolutionNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</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('telephone')">
<if test="conditionParamRef.telephone != null and conditionParamRef.telephone != ''">
${_conditionType_} a.telephone like #{${_conditionParam_}.telephone}
</if>
<if test="conditionParamRef.telephone == null">
${_conditionType_} a.telephone is null
</if>
</if>
<if test="conditionParamRef.containsKey('telephoneList') and conditionParamRef.telephoneList.size() > 0">
${_conditionType_} a.telephone in
<foreach collection="conditionParamRef.telephoneList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('telephoneNotList') and conditionParamRef.telephoneNotList.size() > 0">
${_conditionType_} a.telephone not in
<foreach collection="conditionParamRef.telephoneNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('longitude')">
<if test="conditionParamRef.longitude != null and conditionParamRef.longitude != ''">
${_conditionType_} a.longitude like #{${_conditionParam_}.longitude}
</if>
<if test="conditionParamRef.longitude == null">
${_conditionType_} a.longitude is null
</if>
</if>
<if test="conditionParamRef.containsKey('longitudeList') and conditionParamRef.longitudeList.size() > 0">
${_conditionType_} a.longitude in
<foreach collection="conditionParamRef.longitudeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('longitudeNotList') and conditionParamRef.longitudeNotList.size() > 0">
${_conditionType_} a.longitude not in
<foreach collection="conditionParamRef.longitudeNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('latitude')">
<if test="conditionParamRef.latitude != null and conditionParamRef.latitude != ''">
${_conditionType_} a.latitude like #{${_conditionParam_}.latitude}
</if>
<if test="conditionParamRef.latitude == null">
${_conditionType_} a.latitude is null
</if>
</if>
<if test="conditionParamRef.containsKey('latitudeList') and conditionParamRef.latitudeList.size() > 0">
${_conditionType_} a.latitude in
<foreach collection="conditionParamRef.latitudeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('latitudeNotList') and conditionParamRef.latitudeNotList.size() > 0">
${_conditionType_} a.latitude not in
<foreach collection="conditionParamRef.latitudeNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('building')">
<if test="conditionParamRef.building != null ">
${_conditionType_} a.building = #{${_conditionParam_}.building}
</if>
<if test="conditionParamRef.building == null">
${_conditionType_} a.building is null
</if>
</if>
<if test="conditionParamRef.containsKey('buildingList') and conditionParamRef.buildingList.size() > 0">
${_conditionType_} a.building in
<foreach collection="conditionParamRef.buildingList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('buildingNotList') and conditionParamRef.buildingNotList.size() > 0">
${_conditionType_} a.building not in
<foreach collection="conditionParamRef.buildingNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('buildingStart') and conditionParamRef.buildingStart != null">
${_conditionType_} a.building <![CDATA[ >= ]]> #{${_conditionParam_}.buildingStart}
</if>
<if test="conditionParamRef.containsKey('buildingEnd') and conditionParamRef.buildingEnd != null">
${_conditionType_} a.building <![CDATA[ <= ]]> #{${_conditionParam_}.buildingEnd}
</if>
<if test="conditionParamRef.containsKey('floor')">
<if test="conditionParamRef.floor != null ">
${_conditionType_} a.floor = #{${_conditionParam_}.floor}
</if>
<if test="conditionParamRef.floor == null">
${_conditionType_} a.floor 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=",">
#{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=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('floorStart') and conditionParamRef.floorStart != null">
${_conditionType_} a.floor <![CDATA[ >= ]]> #{${_conditionParam_}.floorStart}
</if>
<if test="conditionParamRef.containsKey('floorEnd') and conditionParamRef.floorEnd != null">
${_conditionType_} a.floor <![CDATA[ <= ]]> #{${_conditionParam_}.floorEnd}
</if>
<if test="conditionParamRef.containsKey('address')">
<if test="conditionParamRef.address != null and conditionParamRef.address != ''">
${_conditionType_} a.address like #{${_conditionParam_}.address}
</if>
<if test="conditionParamRef.address == null">
${_conditionType_} a.address is null
</if>
</if>
<if test="conditionParamRef.containsKey('addressList') and conditionParamRef.addressList.size() > 0">
${_conditionType_} a.address in
<foreach collection="conditionParamRef.addressList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('addressNotList') and conditionParamRef.addressNotList.size() > 0">
${_conditionType_} a.address not in
<foreach collection="conditionParamRef.addressNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('manageUser')">
<if test="conditionParamRef.manageUser != null and conditionParamRef.manageUser != ''">
${_conditionType_} a.manageUser like #{${_conditionParam_}.manageUser}
</if>
<if test="conditionParamRef.manageUser == null">
${_conditionType_} a.manageUser is null
</if>
</if>
<if test="conditionParamRef.containsKey('manageUserList') and conditionParamRef.manageUserList.size() > 0">
${_conditionType_} a.manageUser in
<foreach collection="conditionParamRef.manageUserList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('manageUserNotList') and conditionParamRef.manageUserNotList.size() > 0">
${_conditionType_} a.manageUser not in
<foreach collection="conditionParamRef.manageUserNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('managePWD')">
<if test="conditionParamRef.managePWD != null and conditionParamRef.managePWD != ''">
${_conditionType_} a.managePWD like #{${_conditionParam_}.managePWD}
</if>
<if test="conditionParamRef.managePWD == null">
${_conditionType_} a.managePWD is null
</if>
</if>
<if test="conditionParamRef.containsKey('managePWDList') and conditionParamRef.managePWDList.size() > 0">
${_conditionType_} a.managePWD in
<foreach collection="conditionParamRef.managePWDList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('managePWDNotList') and conditionParamRef.managePWDNotList.size() > 0">
${_conditionType_} a.managePWD not in
<foreach collection="conditionParamRef.managePWDNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('remark')">
<if test="conditionParamRef.remark != null and conditionParamRef.remark != ''">
${_conditionType_} a.remark like #{${_conditionParam_}.remark}
</if>
<if test="conditionParamRef.remark == null">
${_conditionType_} a.remark is null
</if>
</if>
<if test="conditionParamRef.containsKey('remarkList') and conditionParamRef.remarkList.size() > 0">
${_conditionType_} a.remark in
<foreach collection="conditionParamRef.remarkList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('remarkNotList') and conditionParamRef.remarkNotList.size() > 0">
${_conditionType_} a.remark not in
<foreach collection="conditionParamRef.remarkNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('status')">
<if test="conditionParamRef.status != null ">
${_conditionType_} a.status = #{${_conditionParam_}.status}
</if>
<if test="conditionParamRef.status == null">
${_conditionType_} a.status is null
</if>
</if>
<if test="conditionParamRef.containsKey('statusList') and conditionParamRef.statusList.size() > 0">
${_conditionType_} a.status in
<foreach collection="conditionParamRef.statusList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('statusNotList') and conditionParamRef.statusNotList.size() > 0">
${_conditionType_} a.status not in
<foreach collection="conditionParamRef.statusNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('statusStart') and conditionParamRef.statusStart != null">
${_conditionType_} a.status <![CDATA[ >= ]]> #{${_conditionParam_}.statusStart}
</if>
<if test="conditionParamRef.containsKey('statusEnd') and conditionParamRef.statusEnd != null">
${_conditionType_} a.status <![CDATA[ <= ]]> #{${_conditionParam_}.statusEnd}
</if>
<if test="conditionParamRef.containsKey('enabled')">
<if test="conditionParamRef.enabled != null ">
${_conditionType_} a.enabled = #{${_conditionParam_}.enabled}
</if>
<if test="conditionParamRef.enabled == null">
${_conditionType_} a.enabled is null
</if>
</if>
<if test="conditionParamRef.containsKey('enabledList') and conditionParamRef.enabledList.size() > 0">
${_conditionType_} a.enabled in
<foreach collection="conditionParamRef.enabledList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('enabledNotList') and conditionParamRef.enabledNotList.size() > 0">
${_conditionType_} a.enabled not in
<foreach collection="conditionParamRef.enabledNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('enabledStart') and conditionParamRef.enabledStart != null">
${_conditionType_} a.enabled <![CDATA[ >= ]]> #{${_conditionParam_}.enabledStart}
</if>
<if test="conditionParamRef.containsKey('enabledEnd') and conditionParamRef.enabledEnd != null">
${_conditionType_} a.enabled <![CDATA[ <= ]]> #{${_conditionParam_}.enabledEnd}
</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('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('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>
<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()">
order by
<if test="conditionParamRef.containsKey('idList') and conditionParamRef.idList.size() > 0">
field(a.id,
<foreach collection="conditionParamRef.idList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('deviceTypeList') and conditionParamRef.deviceTypeList.size() > 0">
field(a.deviceType,
<foreach collection="conditionParamRef.deviceTypeList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('buildingList') and conditionParamRef.buildingList.size() > 0">
field(a.building,
<foreach collection="conditionParamRef.buildingList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('floorList') and conditionParamRef.floorList.size() > 0">
field(a.floor,
<foreach collection="conditionParamRef.floorList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('statusList') and conditionParamRef.statusList.size() > 0">
field(a.status,
<foreach collection="conditionParamRef.statusList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('enabledList') and conditionParamRef.enabledList.size() > 0">
field(a.enabled,
<foreach collection="conditionParamRef.enabledList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('createUserIdList') and conditionParamRef.createUserIdList.size() > 0">
field(a.createUserId,
<foreach collection="conditionParamRef.createUserIdList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('updateUserIdList') and conditionParamRef.updateUserIdList.size() > 0">
field(a.updateUserId,
<foreach collection="conditionParamRef.updateUserIdList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<trim suffixOverrides="," suffix="">
<foreach collection="orderColList" open="" close="" index="index" item="item" separator=",">
a.${item.colName} ${item.sortKind}
</foreach>
</trim>
</if>
<if test="(orderColList == null or orderColList.isEmpty()) and orderCol != null and !orderCol.isEmpty()">
order by
<if test="conditionParamRef.containsKey('idList') and conditionParamRef.idList.size() > 0">
field(a.id,
<foreach collection="conditionParamRef.idList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('deviceTypeList') and conditionParamRef.deviceTypeList.size() > 0">
field(a.deviceType,
<foreach collection="conditionParamRef.deviceTypeList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('buildingList') and conditionParamRef.buildingList.size() > 0">
field(a.building,
<foreach collection="conditionParamRef.buildingList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('floorList') and conditionParamRef.floorList.size() > 0">
field(a.floor,
<foreach collection="conditionParamRef.floorList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('statusList') and conditionParamRef.statusList.size() > 0">
field(a.status,
<foreach collection="conditionParamRef.statusList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('enabledList') and conditionParamRef.enabledList.size() > 0">
field(a.enabled,
<foreach collection="conditionParamRef.enabledList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('createUserIdList') and conditionParamRef.createUserIdList.size() > 0">
field(a.createUserId,
<foreach collection="conditionParamRef.createUserIdList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('updateUserIdList') and conditionParamRef.updateUserIdList.size() > 0">
field(a.updateUserId,
<foreach collection="conditionParamRef.updateUserIdList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<trim suffixOverrides="," suffix="">
<if test="orderCol.containsKey('id')">
a.id
<if test='orderCol.id != null and "DESC".equalsIgnoreCase(orderCol.id)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('deviceName')">
a.deviceName
<if test='orderCol.deviceName != null and "DESC".equalsIgnoreCase(orderCol.deviceName)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('deviceCode')">
a.deviceCode
<if test='orderCol.deviceCode != null and "DESC".equalsIgnoreCase(orderCol.deviceCode)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('deviceType')">
a.deviceType
<if test='orderCol.deviceType != null and "DESC".equalsIgnoreCase(orderCol.deviceType)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('deviceMac')">
a.deviceMac
<if test='orderCol.deviceMac != null and "DESC".equalsIgnoreCase(orderCol.deviceMac)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('deviceFirmname')">
a.deviceFirmname
<if test='orderCol.deviceFirmname != null and "DESC".equalsIgnoreCase(orderCol.deviceFirmname)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('modelNum')">
a.modelNum
<if test='orderCol.modelNum != null and "DESC".equalsIgnoreCase(orderCol.modelNum)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('ip')">
a.ip
<if test='orderCol.ip != null and "DESC".equalsIgnoreCase(orderCol.ip)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('port')">
a.port
<if test='orderCol.port != null and "DESC".equalsIgnoreCase(orderCol.port)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('resolution')">
a.resolution
<if test='orderCol.resolution != null and "DESC".equalsIgnoreCase(orderCol.resolution)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('leadingOfficial')">
a.leadingOfficial
<if test='orderCol.leadingOfficial != null and "DESC".equalsIgnoreCase(orderCol.leadingOfficial)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('telephone')">
a.telephone
<if test='orderCol.telephone != null and "DESC".equalsIgnoreCase(orderCol.telephone)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('longitude')">
a.longitude
<if test='orderCol.longitude != null and "DESC".equalsIgnoreCase(orderCol.longitude)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('latitude')">
a.latitude
<if test='orderCol.latitude != null and "DESC".equalsIgnoreCase(orderCol.latitude)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('building')">
a.building
<if test='orderCol.building != null and "DESC".equalsIgnoreCase(orderCol.building)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('floor')">
a.floor
<if test='orderCol.floor != null and "DESC".equalsIgnoreCase(orderCol.floor)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('address')">
a.address
<if test='orderCol.address != null and "DESC".equalsIgnoreCase(orderCol.address)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('manageUser')">
a.manageUser
<if test='orderCol.manageUser != null and "DESC".equalsIgnoreCase(orderCol.manageUser)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('managePWD')">
a.managePWD
<if test='orderCol.managePWD != null and "DESC".equalsIgnoreCase(orderCol.managePWD)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('remark')">
a.remark
<if test='orderCol.remark != null and "DESC".equalsIgnoreCase(orderCol.remark)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('status')">
a.status
<if test='orderCol.status != null and "DESC".equalsIgnoreCase(orderCol.status)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('enabled')">
a.enabled
<if test='orderCol.enabled != null and "DESC".equalsIgnoreCase(orderCol.enabled)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('createUserId')">
a.createUserId
<if test='orderCol.createUserId != null and "DESC".equalsIgnoreCase(orderCol.createUserId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('createTime')">
a.createTime
<if test='orderCol.createTime != null and "DESC".equalsIgnoreCase(orderCol.createTime)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('updateUserId')">
a.updateUserId
<if test='orderCol.updateUserId != null and "DESC".equalsIgnoreCase(orderCol.updateUserId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('updateTime')">
a.updateTime
<if test='orderCol.updateTime != null and "DESC".equalsIgnoreCase(orderCol.updateTime)'>DESC</if>
,
</if>
</trim>
</if>
</sql>
<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
db/add.sql
View file @ 16096179
......@@ -1389,3 +1389,43 @@ ALTER TABLE mortals_xhx_staff ADD COLUMN `dingUserId` varchar(128) COMMENT '
-- ----------------------------
ALTER TABLE `mortals_xhx_window_workman_perform` ADD COLUMN `season` int(4) DEFAULT NULL COMMENT '考核季度',ADD COLUMN `timeType` tinyint(2) DEFAULT '0' COMMENT '时间类型(0,按月,1按季度,2按年)';
ALTER TABLE `mortals_xhx_check_window_workman_perform` ADD COLUMN `season` int(4) DEFAULT NULL COMMENT '考核季度',ADD COLUMN `timeType` tinyint(2) DEFAULT '0' COMMENT '时间类型(0,按月,1按季度,2按年)';
-- ----------------------------
-- 考勤机管理表
-- ----------------------------
DROP TABLE IF EXISTS `mortals_xhx_device`;
CREATE TABLE `mortals_xhx_device` (
`id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '序号，主键，自增长',
`deviceName` varchar(64) NOT NULL COMMENT '设备名称',
`deviceCode` varchar(128) DEFAULT NULL COMMENT '设备编码',
`deviceType` tinyint(2) DEFAULT '1' COMMENT '设备类型1考勤机',
`deviceMac` varchar(64) DEFAULT NULL COMMENT 'Mac地址',
`deviceFirmname` varchar(20) DEFAULT NULL COMMENT '设备厂商',
`modelNum` varchar(128) DEFAULT NULL COMMENT '设备型号',
`ip` varchar(64) DEFAULT NULL COMMENT '设备IP地址',
`port` varchar(64) DEFAULT NULL COMMENT '端口号',
`resolution` varchar(64) DEFAULT NULL COMMENT '设备分辨率',
`leadingOfficial` varchar(64) DEFAULT NULL COMMENT '负责人',
`telephone` varchar(64) DEFAULT NULL COMMENT '负责人电话',
`longitude` varchar(64) DEFAULT NULL COMMENT '设备经度',
`latitude` varchar(64) DEFAULT NULL COMMENT '设备纬度',
`building` tinyint(2) DEFAULT NULL COMMENT '所在楼宇',
`floor` tinyint(2) DEFAULT NULL COMMENT '所在楼层',
`address` varchar(128) DEFAULT NULL COMMENT '设备地址',
`manageUser` varchar(64) DEFAULT NULL COMMENT '管理员账号',
`managePWD` varchar(64) DEFAULT NULL COMMENT '管理员密码',
`remark` varchar(128) DEFAULT NULL COMMENT '备注',
`status` tinyint(2) DEFAULT '0' COMMENT '设备状态，0：未激活，1：离线:2：在线',
`enabled` tinyint(2) DEFAULT '0' COMMENT '启停状态，0：停用,1：启用',
`createUserId` bigint(20) DEFAULT NULL COMMENT '创建用户',
`createTime` datetime DEFAULT NULL COMMENT '创建时间',
`updateUserId` bigint(20) DEFAULT NULL COMMENT '更新用户',
`updateTime` datetime DEFAULT NULL COMMENT '更新时间',
PRIMARY KEY (`id`),
KEY `deviceName` (`deviceName`) USING BTREE,
KEY `deviceCode` (`deviceCode`) USING BTREE,
KEY `deviceType` (`deviceType`) USING BTREE,
KEY `deviceFirmname` (`deviceFirmname`) USING BTREE,
KEY `status` (`status`) USING BTREE,
KEY `enabled` (`enabled`) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='考勤机管理';
\ No newline at end of file
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment