三级等保登录逻辑修改

portal-manager/db/add.sql

@@ -18,3 +18,26 @@ CREATE TABLE mortals_xhx_product_interface_log(
     `updateTime` datetime      COMMENT '更新时间',
 PRIMARY KEY  (`id`)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='产品接口';
+
+ALTER TABLE `mortals_xhx_user`
+ADD COLUMN `saltKey` varchar(32)  DEFAULT NULL  COMMENT '密码盐值',
+ADD COLUMN `lastUpdatePwdTime` datetime  DEFAULT NULL  COMMENT '最后一次修改密码时间',
+ADD COLUMN `errorCount` tinyint(2)  DEFAULT '0'  COMMENT '当日登录失败数',
+ADD COLUMN `loginLock` tinyint(2)  DEFAULT '0'  COMMENT '登录锁定状态0未锁定1已锁定',
+ADD COLUMN `lockTime` datetime DEFAULT NULL COMMENT '锁定时间';
+
+-- ----------------------------
+-- 用户密码修改记录表
+-- ----------------------------
+DROP TABLE IF EXISTS `mortals_xhx_user_pwd_record`;
+CREATE TABLE `mortals_xhx_user_pwd_record` (
+  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键，自增长',
+  `userId` bigint(20) DEFAULT NULL COMMENT '用户ID，主键，自增长',
+  `loginName` varchar(50) DEFAULT NULL COMMENT '登录名',
+  `loginPwd` varchar(128) DEFAULT NULL COMMENT '登录密码，使用md5双次加密',
+  `createTime` datetime DEFAULT NULL COMMENT '创建时间',
+  `createUserId` bigint(20) DEFAULT NULL COMMENT '创建用户',
+  PRIMARY KEY (`id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='用户密码修改记录';
+
+UPDATE mortals_xhx_user SET lastUpdatePwdTime=NOW();
\ No newline at end of file

portal-manager/src/main/java/com/mortals/xhx/base/login/web/LoginController.java

@@ -6,14 +6,12 @@ import com.alibaba.fastjson.JSONArray;
 import com.alibaba.fastjson.JSONObject;
 import com.mortals.framework.exception.AppException;
 import com.mortals.framework.service.IAuthTokenService;
-import com.mortals.framework.service.ICacheService;
 import com.mortals.framework.service.IUser;
-import com.mortals.framework.util.DataUtil;
 import com.mortals.framework.util.DateUtils;
 import com.mortals.framework.util.StringUtils;
 import com.mortals.framework.web.BaseCRUDJsonBodyMappingController;
+import com.mortals.xhx.base.system.valid.service.ValidCodeService;
 import com.mortals.xhx.common.code.YesNoEnum;
-import com.mortals.xhx.common.key.Constant;
 import com.mortals.xhx.common.pdu.SitePdu;
 import com.mortals.xhx.feign.model.IApiModelFeign;
 import com.mortals.xhx.feign.rsp.ApiResp;
@@ -22,8 +20,6 @@ import com.mortals.xhx.module.menu.service.MenuService;
 import com.mortals.xhx.module.user.model.UserEntity;
 import com.mortals.xhx.module.user.service.UserService;
 import lombok.extern.slf4j.Slf4j;
-import org.apache.commons.collections.ArrayStack;
-import org.apache.commons.collections4.CollectionUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestMapping;
@@ -44,6 +40,8 @@ public class LoginController extends BaseCRUDJsonBodyMappingController<UserServi
     private IAuthTokenService authTokenService;
     @Autowired
     private IApiModelFeign apiModelFeign;
+    @Autowired
+    private ValidCodeService validCodeService;
 
     @RequestMapping("login")
     public String login(@RequestBody LoginForm loginForm) throws Exception {
@@ -60,7 +58,11 @@ public class LoginController extends BaseCRUDJsonBodyMappingController<UserServi
         UserEntity userEntity = null;
         try {
             loginForm.validate();
-            userEntity = userService.doLogin(loginName, password, ip);
+            boolean validCode = validCodeService.doCheckImageValidCode(request.getSession().getId(),super.getRequestIP(request),loginForm.getCode());
+            if(!validCode){
+                throw new AppException("验证码错误");
+            }
+            userEntity = userService.userdoLogin(loginName, password, ip);
             userEntity.setLastLoginAddress(ip);
             userEntity.setLoginTime(System.currentTimeMillis());
             String tmpToken = userEntity.getId() + ":" + IdUtil.fastSimpleUUID();

portal-manager/src/main/java/com/mortals/xhx/base/login/web/LoginForm.java

 package com.mortals.xhx.base.login.web;
 
 import com.mortals.framework.exception.AppException;
-import com.mortals.framework.web.BaseForm;
 import lombok.Data;
 
 
@@ -11,6 +10,8 @@ public class LoginForm {
 
     private String password;
 
+    private String code;
+
 
     @Override
     public String toString() {

portal-manager/src/main/java/com/mortals/xhx/common/utils/Solution.java

+package com.mortals.xhx.common.utils;
+
+
+public class Solution {
+    //判断输入是否为数字
+    public static boolean isNumber(char s) {
+        return s >= '0' && s <= '9';
+    }
+
+    //判断输入是否为大写字母
+    public static boolean isUpper(char s) {
+        return s >= 'A' && s <= 'Z';
+    }
+
+    //判断输入是否为小写字母
+    public static boolean isLower(char s) {
+        return s >= 'a' && s <= 'z';
+    }
+
+    //判断输入是否为特殊字符
+    public static boolean isCharacter(char s) {
+        return (s < 'a' || s > 'z') && (s < 'A' || s > 'Z') && (s < '0' || s > '9');
+    }
+
+    //判断输入长度是否合法
+    public static boolean lengthOK(String s, int length) {
+        return s.length() >= length;
+    }
+
+    //判断是否有连续相同输入
+    public static boolean isSample(char[] arr) {
+        for (int i = 0; i < arr.length; i++) {
+            if (i < arr.length - 1 && (arr[i] == arr[i + 1])) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    //判断密码是否是强密码
+    public static boolean strongPasswordCheckerII(String password) {
+        //以五个boolean变量记录是否包含其指定字符，若包含，将对应值置为true
+        boolean isSample = false, isNumber = false, isUpper = false, isLower = false, isCharacter = false;
+        //首先判断长度，若长度不符，return false
+        if (lengthOK(password, 8)) {
+            //将输入转为数组，便于操作
+            char[] arr = password.toCharArray();
+            //判断是否有连续相同输入，若有则isSample=false
+            isSample = isSample(arr);
+            for (char c : arr) {
+                //判断是否包含数字，若有则isNumber=true
+                if (!isNumber) {
+                    isNumber = isNumber(c);
+                }
+                //判断是否包含大写字母，若有则isUpper=true
+                if (!isUpper) {
+                    isUpper = isUpper(c);
+                }
+                //判断是否包含小写字母，若有则isLower=true
+                if (!isLower) {
+                    isLower = isLower(c);
+                }
+                //判断是否包含特殊字符，若有则isCharacter=true
+                if (!isCharacter) {
+                    isCharacter = isCharacter(c);
+                }
+            }
+        }
+        //若满足强密码所有条件，则返回true
+        return isNumber && isUpper && isLower && isCharacter && isSample;
+    }
+}
+

portal-manager/src/main/java/com/mortals/xhx/module/user/dao/UserPwdRecordDao.java

+package com.mortals.xhx.module.user.dao;
+
+import com.mortals.framework.dao.ICRUDDao;
+import com.mortals.xhx.module.user.model.UserPwdRecordEntity;
+import java.util.List;
+/**
+* 用户密码修改记录Dao
+* 用户密码修改记录 DAO接口
+*
+* @author zxfei
+* @date 2023-07-26
+*/
+
+public interface  UserPwdRecordDao extends ICRUDDao<UserPwdRecordEntity,Long>{
+
+
+}

portal-manager/src/main/java/com/mortals/xhx/module/user/dao/ibatis/UserPwdRecordDaoImpl.java

+package com.mortals.xhx.module.user.dao.ibatis;
+
+
+import com.mortals.framework.dao.ibatis.BaseCRUDDaoMybatis;
+import com.mortals.xhx.module.user.dao.UserPwdRecordDao;
+import com.mortals.xhx.module.user.model.UserPwdRecordEntity;
+import org.springframework.stereotype.Repository;
+/**
+* 用户密码修改记录DaoImpl DAO接口
+*
+* @author zxfei
+* @date 2023-07-26
+*/
+@Repository("userPwdRecordDao")
+public class UserPwdRecordDaoImpl extends BaseCRUDDaoMybatis<UserPwdRecordEntity,Long> implements UserPwdRecordDao {
+
+
+
+}

portal-manager/src/main/java/com/mortals/xhx/module/user/model/UserEntity.java

 package com.mortals.xhx.module.user.model;
 
-import java.util.Date;
-import java.util.List;
-import java.util.ArrayList;
-
 import com.alibaba.fastjson.annotation.JSONField;
-import com.fasterxml.jackson.annotation.JsonFormat;
 import com.mortals.framework.annotation.Excel;
 import com.mortals.framework.ap.SysConstains;
-import com.mortals.framework.model.BaseEntityLong;
 import com.mortals.framework.service.IUser;
 import com.mortals.xhx.module.user.model.vo.UserVo;
+
+import java.util.Date;
 /**
 * 用户信息业务实体对象
 *
@@ -94,7 +90,26 @@ public class UserEntity extends UserVo implements IUser {
      * 所属区域code,多个逗号分隔
      */
     private String areaNames;
-
+    /**
+     * 密码盐值
+     */
+    private String saltKey;
+    /**
+     * 最后一次修改密码时间
+     */
+    private Date lastUpdatePwdTime;
+    /**
+     * 当日登录失败数
+     */
+    private Integer errorCount;
+    /**
+     * 登录锁定状态0未锁定1已锁定
+     */
+    private Integer loginLock;
+    /**
+     * 锁定时间
+     */
+    private Date lockTime;
 
 
     public UserEntity(){}
@@ -379,6 +394,45 @@ public class UserEntity extends UserVo implements IUser {
         this.areaNames = areaNames;
     }
 
+    public String getSaltKey() {
+        return saltKey;
+    }
+
+    public void setSaltKey(String saltKey) {
+        this.saltKey = saltKey;
+    }
+
+    public Date getLastUpdatePwdTime() {
+        return lastUpdatePwdTime;
+    }
+
+    public void setLastUpdatePwdTime(Date lastUpdatePwdTime) {
+        this.lastUpdatePwdTime = lastUpdatePwdTime;
+    }
+
+    public Integer getErrorCount() {
+        return errorCount;
+    }
+
+    public void setErrorCount(Integer errorCount) {
+        this.errorCount = errorCount;
+    }
+
+    public Integer getLoginLock() {
+        return loginLock;
+    }
+
+    public void setLoginLock(Integer loginLock) {
+        this.loginLock = loginLock;
+    }
+
+    public Date getLockTime() {
+        return lockTime;
+    }
+
+    public void setLockTime(Date lockTime) {
+        this.lockTime = lockTime;
+    }
 
     @Override
     public int hashCode() {
@@ -450,5 +504,15 @@ public class UserEntity extends UserVo implements IUser {
             this.lastLoginAddress = "";
 
             this.areaNames = "";
+
+            this.saltKey = "";
+
+            this.lastUpdatePwdTime = null;
+
+            this.errorCount = 0;
+
+            this.loginLock = 0;
+
+            this.lockTime = null;
     }
 }
\ No newline at end of file

portal-manager/src/main/java/com/mortals/xhx/module/user/model/UserPwdRecordEntity.java

+package com.mortals.xhx.module.user.model;
+import java.util.List;
+import java.util.ArrayList;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import com.mortals.framework.annotation.Excel;
+import com.mortals.framework.model.BaseEntityLong;
+import com.mortals.xhx.module.user.model.vo.UserPwdRecordVo;
+import lombok.Data;
+/**
+* 用户密码修改记录实体对象
+*
+* @author zxfei
+* @date 2023-07-26
+*/
+@Data
+public class UserPwdRecordEntity extends UserPwdRecordVo {
+    private static final long serialVersionUID = 1L;
+
+    /**
+    * 用户ID，主键，自增长
+    */
+    private Long userId;
+    /**
+    * 登录名
+    */
+    private String loginName;
+    /**
+    * 登录密码，使用md5双次加密
+    */
+    private String loginPwd;
+    @Override
+    public int hashCode() {
+         return this.getId().hashCode();
+    }
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == null) return false;
+        if (obj instanceof UserPwdRecordEntity) {
+            UserPwdRecordEntity tmp = (UserPwdRecordEntity) obj;
+            if (this.getId() == tmp.getId()) {
+                 return true;
+            }
+        }
+        return false;
+    }
+
+    public void initAttrValue(){
+
+            this.userId = -1L;
+
+            this.loginName = "";
+
+            this.loginPwd = "";
+    }
+}
\ No newline at end of file

portal-manager/src/main/java/com/mortals/xhx/module/user/model/UserPwdRecordQuery.java

+package com.mortals.xhx.module.user.model;
+
+import java.util.List;
+import com.mortals.xhx.module.user.model.UserPwdRecordEntity;
+/**
+* 用户密码修改记录查询对象
+*
+* @author zxfei
+* @date 2023-07-26
+*/
+public class UserPwdRecordQuery extends UserPwdRecordEntity {
+    /** 开始 主键，自增长 */
+    private Long idStart;
+
+    /** 结束 主键，自增长 */
+    private Long idEnd;
+
+    /** 增加 主键，自增长 */
+    private Long idIncrement;
+
+    /** 主键，自增长列表 */
+    private List <Long> idList;
+
+    /** 主键，自增长排除列表 */
+    private List <Long> idNotList;
+
+    /** 开始 用户ID，主键，自增长 */
+    private Long userIdStart;
+
+    /** 结束 用户ID，主键，自增长 */
+    private Long userIdEnd;
+
+    /** 增加 用户ID，主键，自增长 */
+    private Long userIdIncrement;
+
+    /** 用户ID，主键，自增长列表 */
+    private List <Long> userIdList;
+
+    /** 用户ID，主键，自增长排除列表 */
+    private List <Long> userIdNotList;
+
+    /** 登录名 */
+    private List<String> loginNameList;
+
+    /** 登录名排除列表 */
+    private List <String> loginNameNotList;
+    /** 登录密码，使用md5双次加密 */
+    private List<String> loginPwdList;
+
+    /** 登录密码，使用md5双次加密排除列表 */
+    private List <String> loginPwdNotList;
+    /** 开始 创建时间 */
+    private String createTimeStart;
+
+    /** 结束 创建时间 */
+    private String createTimeEnd;
+
+    /** 开始 创建用户 */
+    private Long createUserIdStart;
+
+    /** 结束 创建用户 */
+    private Long createUserIdEnd;
+
+    /** 增加 创建用户 */
+    private Long createUserIdIncrement;
+
+    /** 创建用户列表 */
+    private List <Long> createUserIdList;
+
+    /** 创建用户排除列表 */
+    private List <Long> createUserIdNotList;
+
+    /** OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4) */
+    private List<UserPwdRecordQuery> orConditionList;
+
+    /** AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4) */
+    private List<UserPwdRecordQuery> andConditionList;
+
+    public UserPwdRecordQuery(){}
+
+    /**
+    * 获取 开始 主键，自增长
+    * @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;
+    }
+
+
+    /**
+    * 获取 开始 用户ID，主键，自增长
+    * @return userIdStart
+    */
+    public Long getUserIdStart(){
+        return this.userIdStart;
+    }
+
+    /**
+    * 设置 开始 用户ID，主键，自增长
+    * @param userIdStart
+    */
+    public void setUserIdStart(Long userIdStart){
+        this.userIdStart = userIdStart;
+    }
+
+    /**
+    * 获取 结束 用户ID，主键，自增长
+    * @return $userIdEnd
+    */
+    public Long getUserIdEnd(){
+        return this.userIdEnd;
+    }
+
+    /**
+    * 设置 结束 用户ID，主键，自增长
+    * @param userIdEnd
+    */
+    public void setUserIdEnd(Long userIdEnd){
+        this.userIdEnd = userIdEnd;
+    }
+
+    /**
+    * 获取 增加 用户ID，主键，自增长
+    * @return userIdIncrement
+    */
+    public Long getUserIdIncrement(){
+        return this.userIdIncrement;
+    }
+
+    /**
+    * 设置 增加 用户ID，主键，自增长
+    * @param userIdIncrement
+    */
+    public void setUserIdIncrement(Long userIdIncrement){
+        this.userIdIncrement = userIdIncrement;
+    }
+
+    /**
+    * 获取 用户ID，主键，自增长
+    * @return userIdList
+    */
+    public List<Long> getUserIdList(){
+        return this.userIdList;
+    }
+
+    /**
+    * 设置 用户ID，主键，自增长
+    * @param userIdList
+    */
+    public void setUserIdList(List<Long> userIdList){
+        this.userIdList = userIdList;
+    }
+
+    /**
+    * 获取 用户ID，主键，自增长
+    * @return userIdNotList
+    */
+    public List<Long> getUserIdNotList(){
+        return this.userIdNotList;
+    }
+
+    /**
+    * 设置 用户ID，主键，自增长
+    * @param userIdNotList
+    */
+    public void setUserIdNotList(List<Long> userIdNotList){
+        this.userIdNotList = userIdNotList;
+    }
+
+
+    /**
+    * 获取 登录名
+    * @return loginNameList
+    */
+    public List<String> getLoginNameList(){
+        return this.loginNameList;
+    }
+
+    /**
+    * 设置 登录名
+    * @param loginNameList
+    */
+    public void setLoginNameList(List<String> loginNameList){
+        this.loginNameList = loginNameList;
+    }
+
+    /**
+    * 获取 登录名
+    * @return loginNameNotList
+    */
+    public List<String> getLoginNameNotList(){
+        return this.loginNameNotList;
+    }
+
+    /**
+    * 设置 登录名
+    * @param loginNameNotList
+    */
+    public void setLoginNameNotList(List<String> loginNameNotList){
+        this.loginNameNotList = loginNameNotList;
+    }
+
+    /**
+    * 获取 登录密码，使用md5双次加密
+    * @return loginPwdList
+    */
+    public List<String> getLoginPwdList(){
+        return this.loginPwdList;
+    }
+
+    /**
+    * 设置 登录密码，使用md5双次加密
+    * @param loginPwdList
+    */
+    public void setLoginPwdList(List<String> loginPwdList){
+        this.loginPwdList = loginPwdList;
+    }
+
+    /**
+    * 获取 登录密码，使用md5双次加密
+    * @return loginPwdNotList
+    */
+    public List<String> getLoginPwdNotList(){
+        return this.loginPwdNotList;
+    }
+
+    /**
+    * 设置 登录密码，使用md5双次加密
+    * @param loginPwdNotList
+    */
+    public void setLoginPwdNotList(List<String> loginPwdNotList){
+        this.loginPwdNotList = loginPwdNotList;
+    }
+
+    /**
+    * 获取 开始 创建时间
+    * @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 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;
+    }
+
+
+    /**
+    * 设置  主键，自增长
+    * @param id
+    */
+    public UserPwdRecordQuery id(Long id){
+	    setId(id);
+		return this;
+    }
+	
+	 /**
+    * 设置 开始 主键，自增长
+    * @param idStart
+    */
+    public UserPwdRecordQuery idStart(Long idStart){
+		this.idStart = idStart;
+		return this;
+    }
+
+    /**
+    * 设置 结束 主键，自增长
+    * @param idEnd
+    */
+    public UserPwdRecordQuery idEnd(Long idEnd){
+		this.idEnd = idEnd;
+		return this;
+    }
+
+    /**
+    * 设置 增加 主键，自增长
+    * @param idIncrement
+    */
+    public UserPwdRecordQuery idIncrement(Long idIncrement){
+		this.idIncrement = idIncrement;
+		return this;
+    }
+
+    /**
+    * 设置 主键，自增长
+    * @param idList
+    */
+    public UserPwdRecordQuery idList(List<Long> idList){
+        this.idList = idList;
+		return this;
+        }
+
+        /**
+        * 设置 主键，自增长
+        * @param idNotList
+        */
+        public UserPwdRecordQuery idNotList(List<Long> idNotList){
+        this.idNotList = idNotList;
+        return this;
+        }
+
+    /**
+    * 设置  用户ID，主键，自增长
+    * @param userId
+    */
+    public UserPwdRecordQuery userId(Long userId){
+	    setUserId(userId);
+		return this;
+    }
+	
+	 /**
+    * 设置 开始 用户ID，主键，自增长
+    * @param userIdStart
+    */
+    public UserPwdRecordQuery userIdStart(Long userIdStart){
+		this.userIdStart = userIdStart;
+		return this;
+    }
+
+    /**
+    * 设置 结束 用户ID，主键，自增长
+    * @param userIdEnd
+    */
+    public UserPwdRecordQuery userIdEnd(Long userIdEnd){
+		this.userIdEnd = userIdEnd;
+		return this;
+    }
+
+    /**
+    * 设置 增加 用户ID，主键，自增长
+    * @param userIdIncrement
+    */
+    public UserPwdRecordQuery userIdIncrement(Long userIdIncrement){
+		this.userIdIncrement = userIdIncrement;
+		return this;
+    }
+
+    /**
+    * 设置 用户ID，主键，自增长
+    * @param userIdList
+    */
+    public UserPwdRecordQuery userIdList(List<Long> userIdList){
+        this.userIdList = userIdList;
+		return this;
+        }
+
+        /**
+        * 设置 用户ID，主键，自增长
+        * @param userIdNotList
+        */
+        public UserPwdRecordQuery userIdNotList(List<Long> userIdNotList){
+        this.userIdNotList = userIdNotList;
+        return this;
+        }
+
+
+	/**
+    * 设置 登录名
+    * @param loginName
+    */
+    public UserPwdRecordQuery loginName(String loginName){
+        setLoginName(loginName);
+		return this;
+    }
+
+    /**
+    * 设置 登录名
+    * @param loginNameList
+    */
+    public UserPwdRecordQuery loginNameList(List<String> loginNameList){
+        this.loginNameList = loginNameList;
+		return this;
+    }
+
+
+	/**
+    * 设置 登录密码，使用md5双次加密
+    * @param loginPwd
+    */
+    public UserPwdRecordQuery loginPwd(String loginPwd){
+        setLoginPwd(loginPwd);
+		return this;
+    }
+
+    /**
+    * 设置 登录密码，使用md5双次加密
+    * @param loginPwdList
+    */
+    public UserPwdRecordQuery loginPwdList(List<String> loginPwdList){
+        this.loginPwdList = loginPwdList;
+		return this;
+    }
+
+
+    /**
+    * 设置  创建用户
+    * @param createUserId
+    */
+    public UserPwdRecordQuery createUserId(Long createUserId){
+	    setCreateUserId(createUserId);
+		return this;
+    }
+	
+	 /**
+    * 设置 开始 创建用户
+    * @param createUserIdStart
+    */
+    public UserPwdRecordQuery createUserIdStart(Long createUserIdStart){
+		this.createUserIdStart = createUserIdStart;
+		return this;
+    }
+
+    /**
+    * 设置 结束 创建用户
+    * @param createUserIdEnd
+    */
+    public UserPwdRecordQuery createUserIdEnd(Long createUserIdEnd){
+		this.createUserIdEnd = createUserIdEnd;
+		return this;
+    }
+
+    /**
+    * 设置 增加 创建用户
+    * @param createUserIdIncrement
+    */
+    public UserPwdRecordQuery createUserIdIncrement(Long createUserIdIncrement){
+		this.createUserIdIncrement = createUserIdIncrement;
+		return this;
+    }
+
+    /**
+    * 设置 创建用户
+    * @param createUserIdList
+    */
+    public UserPwdRecordQuery createUserIdList(List<Long> createUserIdList){
+        this.createUserIdList = createUserIdList;
+		return this;
+        }
+
+        /**
+        * 设置 创建用户
+        * @param createUserIdNotList
+        */
+        public UserPwdRecordQuery createUserIdNotList(List<Long> createUserIdNotList){
+        this.createUserIdNotList = createUserIdNotList;
+        return this;
+        }
+
+    /**
+    * 获取 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
+    * @return orConditionList
+    */
+    public List<UserPwdRecordQuery> 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<UserPwdRecordQuery> 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<UserPwdRecordQuery> 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<UserPwdRecordQuery> andConditionList){
+        this.andConditionList = andConditionList;
+    }
+
+}
\ No newline at end of file

portal-manager/src/main/java/com/mortals/xhx/module/user/model/UserQuery.java

 package com.mortals.xhx.module.user.model;
 
-import java.util.Date;
 import java.util.List;
-import com.mortals.xhx.module.user.model.UserEntity;
 /**
-* 用户信息业务查询对象
-*
-* @author zxfei
-* @date 2022-06-02
-*/
+ * 用户信息业务查询对象
+ *
+ * @author zxfei
+ * @date 2023-07-26
+ */
 public class UserQuery extends UserEntity {
     /** 开始 用户ID，主键，自增长 */
     private Long idStart;
@@ -22,30 +20,49 @@ public class UserQuery extends UserEntity {
     /** 用户ID，主键，自增长列表 */
     private List <Long> idList;
 
+    /** 用户ID，主键，自增长排除列表 */
+    private List <Long> idNotList;
+
     /** 登录名 */
     private List<String> loginNameList;
 
+    /** 登录名排除列表 */
+    private List <String> loginNameNotList;
     /** 登录密码，使用md5双次加密 */
     private List<String> loginPwdList;
 
+    /** 登录密码，使用md5双次加密排除列表 */
+    private List <String> loginPwdNotList;
     /** 登录限制地址，多个IP地址用逗号分隔，可以使用IP段匹配，如：172.17.*非空：则只能该值内的IP可以登录 */
     private List<String> loginLimitAddressList;
 
+    /** 登录限制地址，多个IP地址用逗号分隔，可以使用IP段匹配，如：172.17.*非空：则只能该值内的IP可以登录排除列表 */
+    private List <String> loginLimitAddressNotList;
     /** 用户名 */
     private List<String> realNameList;
 
+    /** 用户名排除列表 */
+    private List <String> realNameNotList;
     /** 用户手机号 */
     private List<String> mobileList;
 
+    /** 用户手机号排除列表 */
+    private List <String> mobileNotList;
     /** 用户联系电话 */
     private List<String> phoneList;
 
+    /** 用户联系电话排除列表 */
+    private List <String> phoneNotList;
     /** 用户邮箱 */
     private List<String> emailList;
 
+    /** 用户邮箱排除列表 */
+    private List <String> emailNotList;
     /** QQ号码 */
     private List<String> qqList;
 
+    /** QQ号码排除列表 */
+    private List <String> qqNotList;
     /** 开始 用户类型(0.系统用户,1.普通用户,2.工作人员) */
     private Integer userTypeStart;
 
@@ -58,12 +75,19 @@ public class UserQuery extends UserEntity {
     /** 用户类型(0.系统用户,1.普通用户,2.工作人员)列表 */
     private List <Integer> userTypeList;
 
+    /** 用户类型(0.系统用户,1.普通用户,2.工作人员)排除列表 */
+    private List <Integer> userTypeNotList;
+
     /** 所属站点id,多个逗号分隔 */
     private List<String> siteIdsList;
 
+    /** 所属站点id,多个逗号分隔排除列表 */
+    private List <String> siteIdsNotList;
     /** 所属区域code,多个逗号分隔 */
     private List<String> areaCodesList;
 
+    /** 所属区域code,多个逗号分隔排除列表 */
+    private List <String> areaCodesNotList;
     /** 开始 用户状态(0.停用，1.正常，2.冻结，3.销户，4.离职) */
     private Integer statusStart;
 
@@ -76,6 +100,9 @@ public class UserQuery extends UserEntity {
     /** 用户状态(0.停用，1.正常，2.冻结，3.销户，4.离职)列表 */
     private List <Integer> statusList;
 
+    /** 用户状态(0.停用，1.正常，2.冻结，3.销户，4.离职)排除列表 */
+    private List <Integer> statusNotList;
+
     /** 开始 创建时间 */
     private String createTimeStart;
 
@@ -94,9 +121,14 @@ public class UserQuery extends UserEntity {
     /** 创建用户列表 */
     private List <Long> createUserIdList;
 
+    /** 创建用户排除列表 */
+    private List <Long> createUserIdNotList;
+
     /** 创建用户名称 */
     private List<String> createUserNameList;
 
+    /** 创建用户名称排除列表 */
+    private List <String> createUserNameNotList;
     /** 开始 最后一次登录时间 */
     private String lastLoginTimeStart;
 
@@ -106,6 +138,54 @@ public class UserQuery extends UserEntity {
     /** 最后一次登录地址 */
     private List<String> lastLoginAddressList;
 
+    /** 最后一次登录地址排除列表 */
+    private List <String> lastLoginAddressNotList;
+    /** 所属区域code,多个逗号分隔 */
+    private List<String> areaNamesList;
+
+    /** 所属区域code,多个逗号分隔排除列表 */
+    private List <String> areaNamesNotList;
+    /** 密码盐值 */
+    private List<String> saltKeyList;
+
+    /** 密码盐值排除列表 */
+    private List <String> saltKeyNotList;
+    /** 开始 最后一次修改密码时间 */
+    private String lastUpdatePwdTimeStart;
+
+    /** 结束 最后一次修改密码时间 */
+    private String lastUpdatePwdTimeEnd;
+
+    /** 开始 当日登录失败数 */
+    private Integer errorCountStart;
+
+    /** 结束 当日登录失败数 */
+    private Integer errorCountEnd;
+
+    /** 增加 当日登录失败数 */
+    private Integer errorCountIncrement;
+
+    /** 当日登录失败数列表 */
+    private List <Integer> errorCountList;
+
+    /** 当日登录失败数排除列表 */
+    private List <Integer> errorCountNotList;
+
+    /** 开始 登录锁定状态0未锁定1已锁定 */
+    private Integer loginLockStart;
+
+    /** 结束 登录锁定状态0未锁定1已锁定 */
+    private Integer loginLockEnd;
+
+    /** 增加 登录锁定状态0未锁定1已锁定 */
+    private Integer loginLockIncrement;
+
+    /** 登录锁定状态0未锁定1已锁定列表 */
+    private List <Integer> loginLockList;
+
+    /** 登录锁定状态0未锁定1已锁定排除列表 */
+    private List <Integer> loginLockNotList;
+
     /** OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4) */
     private List<UserQuery> orConditionList;
 
@@ -115,943 +195,1656 @@ public class UserQuery extends UserEntity {
     public UserQuery(){}
 
     /**
-    * 获取 开始 用户ID，主键，自增长
-    * @return idStart
-    */
+     * 获取 开始 用户ID，主键，自增长
+     * @return idStart
+     */
     public Long getIdStart(){
         return this.idStart;
     }
 
     /**
-    * 设置 开始 用户ID，主键，自增长
-    * @param idStart
-    */
+     * 设置 开始 用户ID，主键，自增长
+     * @param idStart
+     */
     public void setIdStart(Long idStart){
         this.idStart = idStart;
     }
 
     /**
-    * 获取 结束 用户ID，主键，自增长
-    * @return $idEnd
-    */
+     * 获取 结束 用户ID，主键，自增长
+     * @return $idEnd
+     */
     public Long getIdEnd(){
         return this.idEnd;
     }
 
     /**
-    * 设置 结束 用户ID，主键，自增长
-    * @param idEnd
-    */
+     * 设置 结束 用户ID，主键，自增长
+     * @param idEnd
+     */
     public void setIdEnd(Long idEnd){
         this.idEnd = idEnd;
     }
 
     /**
-    * 获取 增加 用户ID，主键，自增长
-    * @return idIncrement
-    */
+     * 获取 增加 用户ID，主键，自增长
+     * @return idIncrement
+     */
     public Long getIdIncrement(){
         return this.idIncrement;
     }
 
     /**
-    * 设置 增加 用户ID，主键，自增长
-    * @param idIncrement
-    */
+     * 设置 增加 用户ID，主键，自增长
+     * @param idIncrement
+     */
     public void setIdIncrement(Long idIncrement){
         this.idIncrement = idIncrement;
     }
 
     /**
-    * 获取 用户ID，主键，自增长
-    * @return idList
-    */
+     * 获取 用户ID，主键，自增长
+     * @return idList
+     */
     public List<Long> getIdList(){
         return this.idList;
     }
 
     /**
-    * 设置 用户ID，主键，自增长
-    * @param idList
-    */
+     * 设置 用户ID，主键，自增长
+     * @param idList
+     */
     public void setIdList(List<Long> idList){
         this.idList = idList;
     }
 
     /**
-    * 获取 登录名
-    * @return loginNameList
-    */
+     * 获取 用户ID，主键，自增长
+     * @return idNotList
+     */
+    public List<Long> getIdNotList(){
+        return this.idNotList;
+    }
+
+    /**
+     * 设置 用户ID，主键，自增长
+     * @param idNotList
+     */
+    public void setIdNotList(List<Long> idNotList){
+        this.idNotList = idNotList;
+    }
+
+
+    /**
+     * 获取 登录名
+     * @return loginNameList
+     */
     public List<String> getLoginNameList(){
         return this.loginNameList;
     }
 
     /**
-    * 设置 登录名
-    * @param loginNameList
-    */
+     * 设置 登录名
+     * @param loginNameList
+     */
     public void setLoginNameList(List<String> loginNameList){
         this.loginNameList = loginNameList;
     }
+
     /**
-    * 获取 登录密码，使用md5双次加密
-    * @return loginPwdList
-    */
+     * 获取 登录名
+     * @return loginNameNotList
+     */
+    public List<String> getLoginNameNotList(){
+        return this.loginNameNotList;
+    }
+
+    /**
+     * 设置 登录名
+     * @param loginNameNotList
+     */
+    public void setLoginNameNotList(List<String> loginNameNotList){
+        this.loginNameNotList = loginNameNotList;
+    }
+
+    /**
+     * 获取 登录密码，使用md5双次加密
+     * @return loginPwdList
+     */
     public List<String> getLoginPwdList(){
         return this.loginPwdList;
     }
 
     /**
-    * 设置 登录密码，使用md5双次加密
-    * @param loginPwdList
-    */
+     * 设置 登录密码，使用md5双次加密
+     * @param loginPwdList
+     */
     public void setLoginPwdList(List<String> loginPwdList){
         this.loginPwdList = loginPwdList;
     }
+
+    /**
+     * 获取 登录密码，使用md5双次加密
+     * @return loginPwdNotList
+     */
+    public List<String> getLoginPwdNotList(){
+        return this.loginPwdNotList;
+    }
+
+    /**
+     * 设置 登录密码，使用md5双次加密
+     * @param loginPwdNotList
+     */
+    public void setLoginPwdNotList(List<String> loginPwdNotList){
+        this.loginPwdNotList = loginPwdNotList;
+    }
+
     /**
-    * 获取 登录限制地址，多个IP地址用逗号分隔，可以使用IP段匹配，如：172.17.*非空：则只能该值内的IP可以登录
-    * @return loginLimitAddressList
-    */
+     * 获取 登录限制地址，多个IP地址用逗号分隔，可以使用IP段匹配，如：172.17.*非空：则只能该值内的IP可以登录
+     * @return loginLimitAddressList
+     */
     public List<String> getLoginLimitAddressList(){
         return this.loginLimitAddressList;
     }
 
     /**
-    * 设置 登录限制地址，多个IP地址用逗号分隔，可以使用IP段匹配，如：172.17.*非空：则只能该值内的IP可以登录
-    * @param loginLimitAddressList
-    */
+     * 设置 登录限制地址，多个IP地址用逗号分隔，可以使用IP段匹配，如：172.17.*非空：则只能该值内的IP可以登录
+     * @param loginLimitAddressList
+     */
     public void setLoginLimitAddressList(List<String> loginLimitAddressList){
         this.loginLimitAddressList = loginLimitAddressList;
     }
+
     /**
-    * 获取 用户名
-    * @return realNameList
-    */
+     * 获取 登录限制地址，多个IP地址用逗号分隔，可以使用IP段匹配，如：172.17.*非空：则只能该值内的IP可以登录
+     * @return loginLimitAddressNotList
+     */
+    public List<String> getLoginLimitAddressNotList(){
+        return this.loginLimitAddressNotList;
+    }
+
+    /**
+     * 设置 登录限制地址，多个IP地址用逗号分隔，可以使用IP段匹配，如：172.17.*非空：则只能该值内的IP可以登录
+     * @param loginLimitAddressNotList
+     */
+    public void setLoginLimitAddressNotList(List<String> loginLimitAddressNotList){
+        this.loginLimitAddressNotList = loginLimitAddressNotList;
+    }
+
+    /**
+     * 获取 用户名
+     * @return realNameList
+     */
     public List<String> getRealNameList(){
         return this.realNameList;
     }
 
     /**
-    * 设置 用户名
-    * @param realNameList
-    */
+     * 设置 用户名
+     * @param realNameList
+     */
     public void setRealNameList(List<String> realNameList){
         this.realNameList = realNameList;
     }
+
     /**
-    * 获取 用户手机号
-    * @return mobileList
-    */
+     * 获取 用户名
+     * @return realNameNotList
+     */
+    public List<String> getRealNameNotList(){
+        return this.realNameNotList;
+    }
+
+    /**
+     * 设置 用户名
+     * @param realNameNotList
+     */
+    public void setRealNameNotList(List<String> realNameNotList){
+        this.realNameNotList = realNameNotList;
+    }
+
+    /**
+     * 获取 用户手机号
+     * @return mobileList
+     */
     public List<String> getMobileList(){
         return this.mobileList;
     }
 
     /**
-    * 设置 用户手机号
-    * @param mobileList
-    */
+     * 设置 用户手机号
+     * @param mobileList
+     */
     public void setMobileList(List<String> mobileList){
         this.mobileList = mobileList;
     }
+
+    /**
+     * 获取 用户手机号
+     * @return mobileNotList
+     */
+    public List<String> getMobileNotList(){
+        return this.mobileNotList;
+    }
+
+    /**
+     * 设置 用户手机号
+     * @param mobileNotList
+     */
+    public void setMobileNotList(List<String> mobileNotList){
+        this.mobileNotList = mobileNotList;
+    }
+
     /**
-    * 获取 用户联系电话
-    * @return phoneList
-    */
+     * 获取 用户联系电话
+     * @return phoneList
+     */
     public List<String> getPhoneList(){
         return this.phoneList;
     }
 
     /**
-    * 设置 用户联系电话
-    * @param phoneList
-    */
+     * 设置 用户联系电话
+     * @param phoneList
+     */
     public void setPhoneList(List<String> phoneList){
         this.phoneList = phoneList;
     }
+
     /**
-    * 获取 用户邮箱
-    * @return emailList
-    */
+     * 获取 用户联系电话
+     * @return phoneNotList
+     */
+    public List<String> getPhoneNotList(){
+        return this.phoneNotList;
+    }
+
+    /**
+     * 设置 用户联系电话
+     * @param phoneNotList
+     */
+    public void setPhoneNotList(List<String> phoneNotList){
+        this.phoneNotList = phoneNotList;
+    }
+
+    /**
+     * 获取 用户邮箱
+     * @return emailList
+     */
     public List<String> getEmailList(){
         return this.emailList;
     }
 
     /**
-    * 设置 用户邮箱
-    * @param emailList
-    */
+     * 设置 用户邮箱
+     * @param emailList
+     */
     public void setEmailList(List<String> emailList){
         this.emailList = emailList;
     }
+
+    /**
+     * 获取 用户邮箱
+     * @return emailNotList
+     */
+    public List<String> getEmailNotList(){
+        return this.emailNotList;
+    }
+
+    /**
+     * 设置 用户邮箱
+     * @param emailNotList
+     */
+    public void setEmailNotList(List<String> emailNotList){
+        this.emailNotList = emailNotList;
+    }
+
     /**
-    * 获取 QQ号码
-    * @return qqList
-    */
+     * 获取 QQ号码
+     * @return qqList
+     */
     public List<String> getQqList(){
         return this.qqList;
     }
 
     /**
-    * 设置 QQ号码
-    * @param qqList
-    */
+     * 设置 QQ号码
+     * @param qqList
+     */
     public void setQqList(List<String> qqList){
         this.qqList = qqList;
     }
+
+    /**
+     * 获取 QQ号码
+     * @return qqNotList
+     */
+    public List<String> getQqNotList(){
+        return this.qqNotList;
+    }
+
     /**
-    * 获取 开始 用户类型(0.系统用户,1.普通用户,2.工作人员)
-    * @return userTypeStart
-    */
+     * 设置 QQ号码
+     * @param qqNotList
+     */
+    public void setQqNotList(List<String> qqNotList){
+        this.qqNotList = qqNotList;
+    }
+
+    /**
+     * 获取 开始 用户类型(0.系统用户,1.普通用户,2.工作人员)
+     * @return userTypeStart
+     */
     public Integer getUserTypeStart(){
         return this.userTypeStart;
     }
 
     /**
-    * 设置 开始 用户类型(0.系统用户,1.普通用户,2.工作人员)
-    * @param userTypeStart
-    */
+     * 设置 开始 用户类型(0.系统用户,1.普通用户,2.工作人员)
+     * @param userTypeStart
+     */
     public void setUserTypeStart(Integer userTypeStart){
         this.userTypeStart = userTypeStart;
     }
 
     /**
-    * 获取 结束 用户类型(0.系统用户,1.普通用户,2.工作人员)
-    * @return $userTypeEnd
-    */
+     * 获取 结束 用户类型(0.系统用户,1.普通用户,2.工作人员)
+     * @return $userTypeEnd
+     */
     public Integer getUserTypeEnd(){
         return this.userTypeEnd;
     }
 
     /**
-    * 设置 结束 用户类型(0.系统用户,1.普通用户,2.工作人员)
-    * @param userTypeEnd
-    */
+     * 设置 结束 用户类型(0.系统用户,1.普通用户,2.工作人员)
+     * @param userTypeEnd
+     */
     public void setUserTypeEnd(Integer userTypeEnd){
         this.userTypeEnd = userTypeEnd;
     }
 
     /**
-    * 获取 增加 用户类型(0.系统用户,1.普通用户,2.工作人员)
-    * @return userTypeIncrement
-    */
+     * 获取 增加 用户类型(0.系统用户,1.普通用户,2.工作人员)
+     * @return userTypeIncrement
+     */
     public Integer getUserTypeIncrement(){
         return this.userTypeIncrement;
     }
 
     /**
-    * 设置 增加 用户类型(0.系统用户,1.普通用户,2.工作人员)
-    * @param userTypeIncrement
-    */
+     * 设置 增加 用户类型(0.系统用户,1.普通用户,2.工作人员)
+     * @param userTypeIncrement
+     */
     public void setUserTypeIncrement(Integer userTypeIncrement){
         this.userTypeIncrement = userTypeIncrement;
     }
 
     /**
-    * 获取 用户类型(0.系统用户,1.普通用户,2.工作人员)
-    * @return userTypeList
-    */
+     * 获取 用户类型(0.系统用户,1.普通用户,2.工作人员)
+     * @return userTypeList
+     */
     public List<Integer> getUserTypeList(){
         return this.userTypeList;
     }
 
     /**
-    * 设置 用户类型(0.系统用户,1.普通用户,2.工作人员)
-    * @param userTypeList
-    */
+     * 设置 用户类型(0.系统用户,1.普通用户,2.工作人员)
+     * @param userTypeList
+     */
     public void setUserTypeList(List<Integer> userTypeList){
         this.userTypeList = userTypeList;
     }
 
     /**
-    * 获取 所属站点id,多个逗号分隔
-    * @return siteIdsList
-    */
+     * 获取 用户类型(0.系统用户,1.普通用户,2.工作人员)
+     * @return userTypeNotList
+     */
+    public List<Integer> getUserTypeNotList(){
+        return this.userTypeNotList;
+    }
+
+    /**
+     * 设置 用户类型(0.系统用户,1.普通用户,2.工作人员)
+     * @param userTypeNotList
+     */
+    public void setUserTypeNotList(List<Integer> userTypeNotList){
+        this.userTypeNotList = userTypeNotList;
+    }
+
+
+    /**
+     * 获取 所属站点id,多个逗号分隔
+     * @return siteIdsList
+     */
     public List<String> getSiteIdsList(){
         return this.siteIdsList;
     }
 
     /**
-    * 设置 所属站点id,多个逗号分隔
-    * @param siteIdsList
-    */
+     * 设置 所属站点id,多个逗号分隔
+     * @param siteIdsList
+     */
     public void setSiteIdsList(List<String> siteIdsList){
         this.siteIdsList = siteIdsList;
     }
+
     /**
-    * 获取 所属区域code,多个逗号分隔
-    * @return areaCodesList
-    */
+     * 获取 所属站点id,多个逗号分隔
+     * @return siteIdsNotList
+     */
+    public List<String> getSiteIdsNotList(){
+        return this.siteIdsNotList;
+    }
+
+    /**
+     * 设置 所属站点id,多个逗号分隔
+     * @param siteIdsNotList
+     */
+    public void setSiteIdsNotList(List<String> siteIdsNotList){
+        this.siteIdsNotList = siteIdsNotList;
+    }
+
+    /**
+     * 获取 所属区域code,多个逗号分隔
+     * @return areaCodesList
+     */
     public List<String> getAreaCodesList(){
         return this.areaCodesList;
     }
 
     /**
-    * 设置 所属区域code,多个逗号分隔
-    * @param areaCodesList
-    */
+     * 设置 所属区域code,多个逗号分隔
+     * @param areaCodesList
+     */
     public void setAreaCodesList(List<String> areaCodesList){
         this.areaCodesList = areaCodesList;
     }
+
+    /**
+     * 获取 所属区域code,多个逗号分隔
+     * @return areaCodesNotList
+     */
+    public List<String> getAreaCodesNotList(){
+        return this.areaCodesNotList;
+    }
+
     /**
-    * 获取 开始 用户状态(0.停用，1.正常，2.冻结，3.销户，4.离职)
-    * @return statusStart
-    */
+     * 设置 所属区域code,多个逗号分隔
+     * @param areaCodesNotList
+     */
+    public void setAreaCodesNotList(List<String> areaCodesNotList){
+        this.areaCodesNotList = areaCodesNotList;
+    }
+
+    /**
+     * 获取 开始 用户状态(0.停用，1.正常，2.冻结，3.销户，4.离职)
+     * @return statusStart
+     */
     public Integer getStatusStart(){
         return this.statusStart;
     }
 
     /**
-    * 设置 开始 用户状态(0.停用，1.正常，2.冻结，3.销户，4.离职)
-    * @param statusStart
-    */
+     * 设置 开始 用户状态(0.停用，1.正常，2.冻结，3.销户，4.离职)
+     * @param statusStart
+     */
     public void setStatusStart(Integer statusStart){
         this.statusStart = statusStart;
     }
 
     /**
-    * 获取 结束 用户状态(0.停用，1.正常，2.冻结，3.销户，4.离职)
-    * @return $statusEnd
-    */
+     * 获取 结束 用户状态(0.停用，1.正常，2.冻结，3.销户，4.离职)
+     * @return $statusEnd
+     */
     public Integer getStatusEnd(){
         return this.statusEnd;
     }
 
     /**
-    * 设置 结束 用户状态(0.停用，1.正常，2.冻结，3.销户，4.离职)
-    * @param statusEnd
-    */
+     * 设置 结束 用户状态(0.停用，1.正常，2.冻结，3.销户，4.离职)
+     * @param statusEnd
+     */
     public void setStatusEnd(Integer statusEnd){
         this.statusEnd = statusEnd;
     }
 
     /**
-    * 获取 增加 用户状态(0.停用，1.正常，2.冻结，3.销户，4.离职)
-    * @return statusIncrement
-    */
+     * 获取 增加 用户状态(0.停用，1.正常，2.冻结，3.销户，4.离职)
+     * @return statusIncrement
+     */
     public Integer getStatusIncrement(){
         return this.statusIncrement;
     }
 
     /**
-    * 设置 增加 用户状态(0.停用，1.正常，2.冻结，3.销户，4.离职)
-    * @param statusIncrement
-    */
+     * 设置 增加 用户状态(0.停用，1.正常，2.冻结，3.销户，4.离职)
+     * @param statusIncrement
+     */
     public void setStatusIncrement(Integer statusIncrement){
         this.statusIncrement = statusIncrement;
     }
 
     /**
-    * 获取 用户状态(0.停用，1.正常，2.冻结，3.销户，4.离职)
-    * @return statusList
-    */
+     * 获取 用户状态(0.停用，1.正常，2.冻结，3.销户，4.离职)
+     * @return statusList
+     */
     public List<Integer> getStatusList(){
         return this.statusList;
     }
 
     /**
-    * 设置 用户状态(0.停用，1.正常，2.冻结，3.销户，4.离职)
-    * @param statusList
-    */
+     * 设置 用户状态(0.停用，1.正常，2.冻结，3.销户，4.离职)
+     * @param statusList
+     */
     public void setStatusList(List<Integer> statusList){
         this.statusList = statusList;
     }
 
     /**
-    * 获取 开始 创建时间
-    * @return createTimeStart
-    */
+     * 获取 用户状态(0.停用，1.正常，2.冻结，3.销户，4.离职)
+     * @return statusNotList
+     */
+    public List<Integer> getStatusNotList(){
+        return this.statusNotList;
+    }
+
+    /**
+     * 设置 用户状态(0.停用，1.正常，2.冻结，3.销户，4.离职)
+     * @param statusNotList
+     */
+    public void setStatusNotList(List<Integer> statusNotList){
+        this.statusNotList = statusNotList;
+    }
+
+
+    /**
+     * 获取 开始 创建时间
+     * @return createTimeStart
+     */
     public String getCreateTimeStart(){
         return this.createTimeStart;
     }
 
     /**
-    * 设置 开始 创建时间
-    * @param createTimeStart
-    */
+     * 设置 开始 创建时间
+     * @param createTimeStart
+     */
     public void setCreateTimeStart(String createTimeStart){
         this.createTimeStart = createTimeStart;
     }
 
     /**
-    * 获取 结束 创建时间
-    * @return createTimeEnd
-    */
+     * 获取 结束 创建时间
+     * @return createTimeEnd
+     */
     public String getCreateTimeEnd(){
         return this.createTimeEnd;
     }
 
     /**
-    * 设置 结束 创建时间
-    * @param createTimeEnd
-    */
+     * 设置 结束 创建时间
+     * @param createTimeEnd
+     */
     public void setCreateTimeEnd(String createTimeEnd){
         this.createTimeEnd = createTimeEnd;
     }
 
     /**
-    * 获取 开始 创建用户
-    * @return createUserIdStart
-    */
+     * 获取 开始 创建用户
+     * @return createUserIdStart
+     */
     public Long getCreateUserIdStart(){
         return this.createUserIdStart;
     }
 
     /**
-    * 设置 开始 创建用户
-    * @param createUserIdStart
-    */
+     * 设置 开始 创建用户
+     * @param createUserIdStart
+     */
     public void setCreateUserIdStart(Long createUserIdStart){
         this.createUserIdStart = createUserIdStart;
     }
 
     /**
-    * 获取 结束 创建用户
-    * @return $createUserIdEnd
-    */
+     * 获取 结束 创建用户
+     * @return $createUserIdEnd
+     */
     public Long getCreateUserIdEnd(){
         return this.createUserIdEnd;
     }
 
     /**
-    * 设置 结束 创建用户
-    * @param createUserIdEnd
-    */
+     * 设置 结束 创建用户
+     * @param createUserIdEnd
+     */
     public void setCreateUserIdEnd(Long createUserIdEnd){
         this.createUserIdEnd = createUserIdEnd;
     }
 
     /**
-    * 获取 增加 创建用户
-    * @return createUserIdIncrement
-    */
+     * 获取 增加 创建用户
+     * @return createUserIdIncrement
+     */
     public Long getCreateUserIdIncrement(){
         return this.createUserIdIncrement;
     }
 
     /**
-    * 设置 增加 创建用户
-    * @param createUserIdIncrement
-    */
+     * 设置 增加 创建用户
+     * @param createUserIdIncrement
+     */
     public void setCreateUserIdIncrement(Long createUserIdIncrement){
         this.createUserIdIncrement = createUserIdIncrement;
     }
 
     /**
-    * 获取 创建用户
-    * @return createUserIdList
-    */
+     * 获取 创建用户
+     * @return createUserIdList
+     */
     public List<Long> getCreateUserIdList(){
         return this.createUserIdList;
     }
 
     /**
-    * 设置 创建用户
-    * @param createUserIdList
-    */
+     * 设置 创建用户
+     * @param createUserIdList
+     */
     public void setCreateUserIdList(List<Long> createUserIdList){
         this.createUserIdList = createUserIdList;
     }
 
     /**
-    * 获取 创建用户名称
-    * @return createUserNameList
-    */
+     * 获取 创建用户
+     * @return createUserIdNotList
+     */
+    public List<Long> getCreateUserIdNotList(){
+        return this.createUserIdNotList;
+    }
+
+    /**
+     * 设置 创建用户
+     * @param createUserIdNotList
+     */
+    public void setCreateUserIdNotList(List<Long> createUserIdNotList){
+        this.createUserIdNotList = createUserIdNotList;
+    }
+
+
+    /**
+     * 获取 创建用户名称
+     * @return createUserNameList
+     */
     public List<String> getCreateUserNameList(){
         return this.createUserNameList;
     }
 
     /**
-    * 设置 创建用户名称
-    * @param createUserNameList
-    */
+     * 设置 创建用户名称
+     * @param createUserNameList
+     */
     public void setCreateUserNameList(List<String> createUserNameList){
         this.createUserNameList = createUserNameList;
     }
+
+    /**
+     * 获取 创建用户名称
+     * @return createUserNameNotList
+     */
+    public List<String> getCreateUserNameNotList(){
+        return this.createUserNameNotList;
+    }
+
     /**
-    * 获取 开始 最后一次登录时间
-    * @return lastLoginTimeStart
-    */
+     * 设置 创建用户名称
+     * @param createUserNameNotList
+     */
+    public void setCreateUserNameNotList(List<String> createUserNameNotList){
+        this.createUserNameNotList = createUserNameNotList;
+    }
+
+    /**
+     * 获取 开始 最后一次登录时间
+     * @return lastLoginTimeStart
+     */
     public String getLastLoginTimeStart(){
         return this.lastLoginTimeStart;
     }
 
     /**
-    * 设置 开始 最后一次登录时间
-    * @param lastLoginTimeStart
-    */
+     * 设置 开始 最后一次登录时间
+     * @param lastLoginTimeStart
+     */
     public void setLastLoginTimeStart(String lastLoginTimeStart){
         this.lastLoginTimeStart = lastLoginTimeStart;
     }
 
     /**
-    * 获取 结束 最后一次登录时间
-    * @return lastLoginTimeEnd
-    */
+     * 获取 结束 最后一次登录时间
+     * @return lastLoginTimeEnd
+     */
     public String getLastLoginTimeEnd(){
         return this.lastLoginTimeEnd;
     }
 
     /**
-    * 设置 结束 最后一次登录时间
-    * @param lastLoginTimeEnd
-    */
+     * 设置 结束 最后一次登录时间
+     * @param lastLoginTimeEnd
+     */
     public void setLastLoginTimeEnd(String lastLoginTimeEnd){
         this.lastLoginTimeEnd = lastLoginTimeEnd;
     }
 
     /**
-    * 获取 最后一次登录地址
-    * @return lastLoginAddressList
-    */
+     * 获取 最后一次登录地址
+     * @return lastLoginAddressList
+     */
     public List<String> getLastLoginAddressList(){
         return this.lastLoginAddressList;
     }
 
     /**
-    * 设置 最后一次登录地址
-    * @param lastLoginAddressList
-    */
+     * 设置 最后一次登录地址
+     * @param lastLoginAddressList
+     */
     public void setLastLoginAddressList(List<String> lastLoginAddressList){
         this.lastLoginAddressList = lastLoginAddressList;
     }
+
+    /**
+     * 获取 最后一次登录地址
+     * @return lastLoginAddressNotList
+     */
+    public List<String> getLastLoginAddressNotList(){
+        return this.lastLoginAddressNotList;
+    }
+
+    /**
+     * 设置 最后一次登录地址
+     * @param lastLoginAddressNotList
+     */
+    public void setLastLoginAddressNotList(List<String> lastLoginAddressNotList){
+        this.lastLoginAddressNotList = lastLoginAddressNotList;
+    }
+
+    /**
+     * 获取 所属区域code,多个逗号分隔
+     * @return areaNamesList
+     */
+    public List<String> getAreaNamesList(){
+        return this.areaNamesList;
+    }
+
+    /**
+     * 设置 所属区域code,多个逗号分隔
+     * @param areaNamesList
+     */
+    public void setAreaNamesList(List<String> areaNamesList){
+        this.areaNamesList = areaNamesList;
+    }
+
+    /**
+     * 获取 所属区域code,多个逗号分隔
+     * @return areaNamesNotList
+     */
+    public List<String> getAreaNamesNotList(){
+        return this.areaNamesNotList;
+    }
+
+    /**
+     * 设置 所属区域code,多个逗号分隔
+     * @param areaNamesNotList
+     */
+    public void setAreaNamesNotList(List<String> areaNamesNotList){
+        this.areaNamesNotList = areaNamesNotList;
+    }
+
+    /**
+     * 获取 密码盐值
+     * @return saltKeyList
+     */
+    public List<String> getSaltKeyList(){
+        return this.saltKeyList;
+    }
+
+    /**
+     * 设置 密码盐值
+     * @param saltKeyList
+     */
+    public void setSaltKeyList(List<String> saltKeyList){
+        this.saltKeyList = saltKeyList;
+    }
+
+    /**
+     * 获取 密码盐值
+     * @return saltKeyNotList
+     */
+    public List<String> getSaltKeyNotList(){
+        return this.saltKeyNotList;
+    }
+
+    /**
+     * 设置 密码盐值
+     * @param saltKeyNotList
+     */
+    public void setSaltKeyNotList(List<String> saltKeyNotList){
+        this.saltKeyNotList = saltKeyNotList;
+    }
+
+    /**
+     * 获取 开始 最后一次修改密码时间
+     * @return lastUpdatePwdTimeStart
+     */
+    public String getLastUpdatePwdTimeStart(){
+        return this.lastUpdatePwdTimeStart;
+    }
+
+    /**
+     * 设置 开始 最后一次修改密码时间
+     * @param lastUpdatePwdTimeStart
+     */
+    public void setLastUpdatePwdTimeStart(String lastUpdatePwdTimeStart){
+        this.lastUpdatePwdTimeStart = lastUpdatePwdTimeStart;
+    }
+
+    /**
+     * 获取 结束 最后一次修改密码时间
+     * @return lastUpdatePwdTimeEnd
+     */
+    public String getLastUpdatePwdTimeEnd(){
+        return this.lastUpdatePwdTimeEnd;
+    }
+
+    /**
+     * 设置 结束 最后一次修改密码时间
+     * @param lastUpdatePwdTimeEnd
+     */
+    public void setLastUpdatePwdTimeEnd(String lastUpdatePwdTimeEnd){
+        this.lastUpdatePwdTimeEnd = lastUpdatePwdTimeEnd;
+    }
+
+    /**
+     * 获取 开始 当日登录失败数
+     * @return errorCountStart
+     */
+    public Integer getErrorCountStart(){
+        return this.errorCountStart;
+    }
+
+    /**
+     * 设置 开始 当日登录失败数
+     * @param errorCountStart
+     */
+    public void setErrorCountStart(Integer errorCountStart){
+        this.errorCountStart = errorCountStart;
+    }
+
+    /**
+     * 获取 结束 当日登录失败数
+     * @return $errorCountEnd
+     */
+    public Integer getErrorCountEnd(){
+        return this.errorCountEnd;
+    }
+
+    /**
+     * 设置 结束 当日登录失败数
+     * @param errorCountEnd
+     */
+    public void setErrorCountEnd(Integer errorCountEnd){
+        this.errorCountEnd = errorCountEnd;
+    }
+
+    /**
+     * 获取 增加 当日登录失败数
+     * @return errorCountIncrement
+     */
+    public Integer getErrorCountIncrement(){
+        return this.errorCountIncrement;
+    }
+
+    /**
+     * 设置 增加 当日登录失败数
+     * @param errorCountIncrement
+     */
+    public void setErrorCountIncrement(Integer errorCountIncrement){
+        this.errorCountIncrement = errorCountIncrement;
+    }
+
+    /**
+     * 获取 当日登录失败数
+     * @return errorCountList
+     */
+    public List<Integer> getErrorCountList(){
+        return this.errorCountList;
+    }
+
+    /**
+     * 设置 当日登录失败数
+     * @param errorCountList
+     */
+    public void setErrorCountList(List<Integer> errorCountList){
+        this.errorCountList = errorCountList;
+    }
+
+    /**
+     * 获取 当日登录失败数
+     * @return errorCountNotList
+     */
+    public List<Integer> getErrorCountNotList(){
+        return this.errorCountNotList;
+    }
+
+    /**
+     * 设置 当日登录失败数
+     * @param errorCountNotList
+     */
+    public void setErrorCountNotList(List<Integer> errorCountNotList){
+        this.errorCountNotList = errorCountNotList;
+    }
+
+
     /**
-    * 设置  用户ID，主键，自增长
-    * @param id
-    */
+     * 获取 开始 登录锁定状态0未锁定1已锁定
+     * @return loginLockStart
+     */
+    public Integer getLoginLockStart(){
+        return this.loginLockStart;
+    }
+
+    /**
+     * 设置 开始 登录锁定状态0未锁定1已锁定
+     * @param loginLockStart
+     */
+    public void setLoginLockStart(Integer loginLockStart){
+        this.loginLockStart = loginLockStart;
+    }
+
+    /**
+     * 获取 结束 登录锁定状态0未锁定1已锁定
+     * @return $loginLockEnd
+     */
+    public Integer getLoginLockEnd(){
+        return this.loginLockEnd;
+    }
+
+    /**
+     * 设置 结束 登录锁定状态0未锁定1已锁定
+     * @param loginLockEnd
+     */
+    public void setLoginLockEnd(Integer loginLockEnd){
+        this.loginLockEnd = loginLockEnd;
+    }
+
+    /**
+     * 获取 增加 登录锁定状态0未锁定1已锁定
+     * @return loginLockIncrement
+     */
+    public Integer getLoginLockIncrement(){
+        return this.loginLockIncrement;
+    }
+
+    /**
+     * 设置 增加 登录锁定状态0未锁定1已锁定
+     * @param loginLockIncrement
+     */
+    public void setLoginLockIncrement(Integer loginLockIncrement){
+        this.loginLockIncrement = loginLockIncrement;
+    }
+
+    /**
+     * 获取 登录锁定状态0未锁定1已锁定
+     * @return loginLockList
+     */
+    public List<Integer> getLoginLockList(){
+        return this.loginLockList;
+    }
+
+    /**
+     * 设置 登录锁定状态0未锁定1已锁定
+     * @param loginLockList
+     */
+    public void setLoginLockList(List<Integer> loginLockList){
+        this.loginLockList = loginLockList;
+    }
+
+    /**
+     * 获取 登录锁定状态0未锁定1已锁定
+     * @return loginLockNotList
+     */
+    public List<Integer> getLoginLockNotList(){
+        return this.loginLockNotList;
+    }
+
+    /**
+     * 设置 登录锁定状态0未锁定1已锁定
+     * @param loginLockNotList
+     */
+    public void setLoginLockNotList(List<Integer> loginLockNotList){
+        this.loginLockNotList = loginLockNotList;
+    }
+
+
+    /**
+     * 设置  用户ID，主键，自增长
+     * @param id
+     */
     public UserQuery id(Long id){
-	    setId(id);
-		return this;
-    }
-	
-	 /**
-    * 设置 开始 用户ID，主键，自增长
-    * @param idStart
-    */
+        setId(id);
+        return this;
+    }
+
+    /**
+     * 设置 开始 用户ID，主键，自增长
+     * @param idStart
+     */
     public UserQuery idStart(Long idStart){
-		this.idStart = idStart;
-		return this;
+        this.idStart = idStart;
+        return this;
     }
 
     /**
-    * 设置 结束 用户ID，主键，自增长
-    * @param idEnd
-    */
+     * 设置 结束 用户ID，主键，自增长
+     * @param idEnd
+     */
     public UserQuery idEnd(Long idEnd){
-		this.idEnd = idEnd;
-		return this;
+        this.idEnd = idEnd;
+        return this;
     }
 
     /**
-    * 设置 增加 用户ID，主键，自增长
-    * @param idIncrement
-    */
+     * 设置 增加 用户ID，主键，自增长
+     * @param idIncrement
+     */
     public UserQuery idIncrement(Long idIncrement){
-		this.idIncrement = idIncrement;
-		return this;
+        this.idIncrement = idIncrement;
+        return this;
     }
 
     /**
-    * 设置 用户ID，主键，自增长
-    * @param idList
-    */
+     * 设置 用户ID，主键，自增长
+     * @param idList
+     */
     public UserQuery idList(List<Long> idList){
         this.idList = idList;
-		return this;
-        }
+        return this;
+    }
+
+    /**
+     * 设置 用户ID，主键，自增长
+     * @param idNotList
+     */
+    public UserQuery idNotList(List<Long> idNotList){
+        this.idNotList = idNotList;
+        return this;
+    }
 
 
-	/**
-    * 设置 登录名
-    * @param loginName
-    */
+    /**
+     * 设置 登录名
+     * @param loginName
+     */
     public UserQuery loginName(String loginName){
         setLoginName(loginName);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 登录名
-    * @param loginNameList
-    */
+     * 设置 登录名
+     * @param loginNameList
+     */
     public UserQuery loginNameList(List<String> loginNameList){
         this.loginNameList = loginNameList;
-		return this;
+        return this;
     }
 
 
-	/**
-    * 设置 登录密码，使用md5双次加密
-    * @param loginPwd
-    */
+    /**
+     * 设置 登录密码，使用md5双次加密
+     * @param loginPwd
+     */
     public UserQuery loginPwd(String loginPwd){
         setLoginPwd(loginPwd);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 登录密码，使用md5双次加密
-    * @param loginPwdList
-    */
+     * 设置 登录密码，使用md5双次加密
+     * @param loginPwdList
+     */
     public UserQuery loginPwdList(List<String> loginPwdList){
         this.loginPwdList = loginPwdList;
-		return this;
+        return this;
     }
 
 
-	/**
-    * 设置 登录限制地址，多个IP地址用逗号分隔，可以使用IP段匹配，如：172.17.*非空：则只能该值内的IP可以登录
-    * @param loginLimitAddress
-    */
+    /**
+     * 设置 登录限制地址，多个IP地址用逗号分隔，可以使用IP段匹配，如：172.17.*非空：则只能该值内的IP可以登录
+     * @param loginLimitAddress
+     */
     public UserQuery loginLimitAddress(String loginLimitAddress){
         setLoginLimitAddress(loginLimitAddress);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 登录限制地址，多个IP地址用逗号分隔，可以使用IP段匹配，如：172.17.*非空：则只能该值内的IP可以登录
-    * @param loginLimitAddressList
-    */
+     * 设置 登录限制地址，多个IP地址用逗号分隔，可以使用IP段匹配，如：172.17.*非空：则只能该值内的IP可以登录
+     * @param loginLimitAddressList
+     */
     public UserQuery loginLimitAddressList(List<String> loginLimitAddressList){
         this.loginLimitAddressList = loginLimitAddressList;
-		return this;
+        return this;
     }
 
 
-	/**
-    * 设置 用户名
-    * @param realName
-    */
+    /**
+     * 设置 用户名
+     * @param realName
+     */
     public UserQuery realName(String realName){
         setRealName(realName);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 用户名
-    * @param realNameList
-    */
+     * 设置 用户名
+     * @param realNameList
+     */
     public UserQuery realNameList(List<String> realNameList){
         this.realNameList = realNameList;
-		return this;
+        return this;
     }
 
 
-	/**
-    * 设置 用户手机号
-    * @param mobile
-    */
+    /**
+     * 设置 用户手机号
+     * @param mobile
+     */
     public UserQuery mobile(String mobile){
         setMobile(mobile);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 用户手机号
-    * @param mobileList
-    */
+     * 设置 用户手机号
+     * @param mobileList
+     */
     public UserQuery mobileList(List<String> mobileList){
         this.mobileList = mobileList;
-		return this;
+        return this;
     }
 
 
-	/**
-    * 设置 用户联系电话
-    * @param phone
-    */
+    /**
+     * 设置 用户联系电话
+     * @param phone
+     */
     public UserQuery phone(String phone){
         setPhone(phone);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 用户联系电话
-    * @param phoneList
-    */
+     * 设置 用户联系电话
+     * @param phoneList
+     */
     public UserQuery phoneList(List<String> phoneList){
         this.phoneList = phoneList;
-		return this;
+        return this;
     }
 
 
-	/**
-    * 设置 用户邮箱
-    * @param email
-    */
+    /**
+     * 设置 用户邮箱
+     * @param email
+     */
     public UserQuery email(String email){
         setEmail(email);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 用户邮箱
-    * @param emailList
-    */
+     * 设置 用户邮箱
+     * @param emailList
+     */
     public UserQuery emailList(List<String> emailList){
         this.emailList = emailList;
-		return this;
+        return this;
     }
 
 
-	/**
-    * 设置 QQ号码
-    * @param qq
-    */
+    /**
+     * 设置 QQ号码
+     * @param qq
+     */
     public UserQuery qq(String qq){
         setQq(qq);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 QQ号码
-    * @param qqList
-    */
+     * 设置 QQ号码
+     * @param qqList
+     */
     public UserQuery qqList(List<String> qqList){
         this.qqList = qqList;
-		return this;
+        return this;
     }
 
     /**
-    * 设置  用户类型(0.系统用户,1.普通用户,2.工作人员)
-    * @param userType
-    */
+     * 设置  用户类型(0.系统用户,1.普通用户,2.工作人员)
+     * @param userType
+     */
     public UserQuery userType(Integer userType){
-	    setUserType(userType);
-		return this;
-    }
-	
-	 /**
-    * 设置 开始 用户类型(0.系统用户,1.普通用户,2.工作人员)
-    * @param userTypeStart
-    */
+        setUserType(userType);
+        return this;
+    }
+
+    /**
+     * 设置 开始 用户类型(0.系统用户,1.普通用户,2.工作人员)
+     * @param userTypeStart
+     */
     public UserQuery userTypeStart(Integer userTypeStart){
-		this.userTypeStart = userTypeStart;
-		return this;
+        this.userTypeStart = userTypeStart;
+        return this;
     }
 
     /**
-    * 设置 结束 用户类型(0.系统用户,1.普通用户,2.工作人员)
-    * @param userTypeEnd
-    */
+     * 设置 结束 用户类型(0.系统用户,1.普通用户,2.工作人员)
+     * @param userTypeEnd
+     */
     public UserQuery userTypeEnd(Integer userTypeEnd){
-		this.userTypeEnd = userTypeEnd;
-		return this;
+        this.userTypeEnd = userTypeEnd;
+        return this;
     }
 
     /**
-    * 设置 增加 用户类型(0.系统用户,1.普通用户,2.工作人员)
-    * @param userTypeIncrement
-    */
+     * 设置 增加 用户类型(0.系统用户,1.普通用户,2.工作人员)
+     * @param userTypeIncrement
+     */
     public UserQuery userTypeIncrement(Integer userTypeIncrement){
-		this.userTypeIncrement = userTypeIncrement;
-		return this;
+        this.userTypeIncrement = userTypeIncrement;
+        return this;
     }
 
     /**
-    * 设置 用户类型(0.系统用户,1.普通用户,2.工作人员)
-    * @param userTypeList
-    */
+     * 设置 用户类型(0.系统用户,1.普通用户,2.工作人员)
+     * @param userTypeList
+     */
     public UserQuery userTypeList(List<Integer> userTypeList){
         this.userTypeList = userTypeList;
-		return this;
-        }
+        return this;
+    }
+
+    /**
+     * 设置 用户类型(0.系统用户,1.普通用户,2.工作人员)
+     * @param userTypeNotList
+     */
+    public UserQuery userTypeNotList(List<Integer> userTypeNotList){
+        this.userTypeNotList = userTypeNotList;
+        return this;
+    }
 
 
-	/**
-    * 设置 所属站点id,多个逗号分隔
-    * @param siteIds
-    */
+    /**
+     * 设置 所属站点id,多个逗号分隔
+     * @param siteIds
+     */
     public UserQuery siteIds(String siteIds){
         setSiteIds(siteIds);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 所属站点id,多个逗号分隔
-    * @param siteIdsList
-    */
+     * 设置 所属站点id,多个逗号分隔
+     * @param siteIdsList
+     */
     public UserQuery siteIdsList(List<String> siteIdsList){
         this.siteIdsList = siteIdsList;
-		return this;
+        return this;
     }
 
 
-	/**
-    * 设置 所属区域code,多个逗号分隔
-    * @param areaCodes
-    */
+    /**
+     * 设置 所属区域code,多个逗号分隔
+     * @param areaCodes
+     */
     public UserQuery areaCodes(String areaCodes){
         setAreaCodes(areaCodes);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 所属区域code,多个逗号分隔
-    * @param areaCodesList
-    */
+     * 设置 所属区域code,多个逗号分隔
+     * @param areaCodesList
+     */
     public UserQuery areaCodesList(List<String> areaCodesList){
         this.areaCodesList = areaCodesList;
-		return this;
+        return this;
     }
 
     /**
-    * 设置  用户状态(0.停用，1.正常，2.冻结，3.销户，4.离职)
-    * @param status
-    */
+     * 设置  用户状态(0.停用，1.正常，2.冻结，3.销户，4.离职)
+     * @param status
+     */
     public UserQuery status(Integer status){
-	    setStatus(status);
-		return this;
-    }
-	
-	 /**
-    * 设置 开始 用户状态(0.停用，1.正常，2.冻结，3.销户，4.离职)
-    * @param statusStart
-    */
+        setStatus(status);
+        return this;
+    }
+
+    /**
+     * 设置 开始 用户状态(0.停用，1.正常，2.冻结，3.销户，4.离职)
+     * @param statusStart
+     */
     public UserQuery statusStart(Integer statusStart){
-		this.statusStart = statusStart;
-		return this;
+        this.statusStart = statusStart;
+        return this;
     }
 
     /**
-    * 设置 结束 用户状态(0.停用，1.正常，2.冻结，3.销户，4.离职)
-    * @param statusEnd
-    */
+     * 设置 结束 用户状态(0.停用，1.正常，2.冻结，3.销户，4.离职)
+     * @param statusEnd
+     */
     public UserQuery statusEnd(Integer statusEnd){
-		this.statusEnd = statusEnd;
-		return this;
+        this.statusEnd = statusEnd;
+        return this;
     }
 
     /**
-    * 设置 增加 用户状态(0.停用，1.正常，2.冻结，3.销户，4.离职)
-    * @param statusIncrement
-    */
+     * 设置 增加 用户状态(0.停用，1.正常，2.冻结，3.销户，4.离职)
+     * @param statusIncrement
+     */
     public UserQuery statusIncrement(Integer statusIncrement){
-		this.statusIncrement = statusIncrement;
-		return this;
+        this.statusIncrement = statusIncrement;
+        return this;
     }
 
     /**
-    * 设置 用户状态(0.停用，1.正常，2.冻结，3.销户，4.离职)
-    * @param statusList
-    */
+     * 设置 用户状态(0.停用，1.正常，2.冻结，3.销户，4.离职)
+     * @param statusList
+     */
     public UserQuery statusList(List<Integer> statusList){
         this.statusList = statusList;
-		return this;
-        }
+        return this;
+    }
+
+    /**
+     * 设置 用户状态(0.停用，1.正常，2.冻结，3.销户，4.离职)
+     * @param statusNotList
+     */
+    public UserQuery statusNotList(List<Integer> statusNotList){
+        this.statusNotList = statusNotList;
+        return this;
+    }
 
 
     /**
-    * 设置  创建用户
-    * @param createUserId
-    */
+     * 设置  创建用户
+     * @param createUserId
+     */
     public UserQuery createUserId(Long createUserId){
-	    setCreateUserId(createUserId);
-		return this;
-    }
-	
-	 /**
-    * 设置 开始 创建用户
-    * @param createUserIdStart
-    */
+        setCreateUserId(createUserId);
+        return this;
+    }
+
+    /**
+     * 设置 开始 创建用户
+     * @param createUserIdStart
+     */
     public UserQuery createUserIdStart(Long createUserIdStart){
-		this.createUserIdStart = createUserIdStart;
-		return this;
+        this.createUserIdStart = createUserIdStart;
+        return this;
     }
 
     /**
-    * 设置 结束 创建用户
-    * @param createUserIdEnd
-    */
+     * 设置 结束 创建用户
+     * @param createUserIdEnd
+     */
     public UserQuery createUserIdEnd(Long createUserIdEnd){
-		this.createUserIdEnd = createUserIdEnd;
-		return this;
+        this.createUserIdEnd = createUserIdEnd;
+        return this;
     }
 
     /**
-    * 设置 增加 创建用户
-    * @param createUserIdIncrement
-    */
+     * 设置 增加 创建用户
+     * @param createUserIdIncrement
+     */
     public UserQuery createUserIdIncrement(Long createUserIdIncrement){
-		this.createUserIdIncrement = createUserIdIncrement;
-		return this;
+        this.createUserIdIncrement = createUserIdIncrement;
+        return this;
     }
 
     /**
-    * 设置 创建用户
-    * @param createUserIdList
-    */
+     * 设置 创建用户
+     * @param createUserIdList
+     */
     public UserQuery createUserIdList(List<Long> createUserIdList){
         this.createUserIdList = createUserIdList;
-		return this;
-        }
+        return this;
+    }
+
+    /**
+     * 设置 创建用户
+     * @param createUserIdNotList
+     */
+    public UserQuery createUserIdNotList(List<Long> createUserIdNotList){
+        this.createUserIdNotList = createUserIdNotList;
+        return this;
+    }
 
 
-	/**
-    * 设置 创建用户名称
-    * @param createUserName
-    */
+    /**
+     * 设置 创建用户名称
+     * @param createUserName
+     */
     public UserQuery createUserName(String createUserName){
         setCreateUserName(createUserName);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 创建用户名称
-    * @param createUserNameList
-    */
+     * 设置 创建用户名称
+     * @param createUserNameList
+     */
     public UserQuery createUserNameList(List<String> createUserNameList){
         this.createUserNameList = createUserNameList;
-		return this;
+        return this;
     }
 
 
 
-	/**
-    * 设置 最后一次登录地址
-    * @param lastLoginAddress
-    */
+    /**
+     * 设置 最后一次登录地址
+     * @param lastLoginAddress
+     */
     public UserQuery lastLoginAddress(String lastLoginAddress){
         setLastLoginAddress(lastLoginAddress);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 最后一次登录地址
-    * @param lastLoginAddressList
-    */
+     * 设置 最后一次登录地址
+     * @param lastLoginAddressList
+     */
     public UserQuery lastLoginAddressList(List<String> lastLoginAddressList){
         this.lastLoginAddressList = lastLoginAddressList;
-		return this;
+        return this;
+    }
+
+
+    /**
+     * 设置 所属区域code,多个逗号分隔
+     * @param areaNames
+     */
+    public UserQuery areaNames(String areaNames){
+        setAreaNames(areaNames);
+        return this;
+    }
+
+    /**
+     * 设置 所属区域code,多个逗号分隔
+     * @param areaNamesList
+     */
+    public UserQuery areaNamesList(List<String> areaNamesList){
+        this.areaNamesList = areaNamesList;
+        return this;
+    }
+
+
+    /**
+     * 设置 密码盐值
+     * @param saltKey
+     */
+    public UserQuery saltKey(String saltKey){
+        setSaltKey(saltKey);
+        return this;
+    }
+
+    /**
+     * 设置 密码盐值
+     * @param saltKeyList
+     */
+    public UserQuery saltKeyList(List<String> saltKeyList){
+        this.saltKeyList = saltKeyList;
+        return this;
+    }
+
+
+    /**
+     * 设置  当日登录失败数
+     * @param errorCount
+     */
+    public UserQuery errorCount(Integer errorCount){
+        setErrorCount(errorCount);
+        return this;
+    }
+
+    /**
+     * 设置 开始 当日登录失败数
+     * @param errorCountStart
+     */
+    public UserQuery errorCountStart(Integer errorCountStart){
+        this.errorCountStart = errorCountStart;
+        return this;
+    }
+
+    /**
+     * 设置 结束 当日登录失败数
+     * @param errorCountEnd
+     */
+    public UserQuery errorCountEnd(Integer errorCountEnd){
+        this.errorCountEnd = errorCountEnd;
+        return this;
+    }
+
+    /**
+     * 设置 增加 当日登录失败数
+     * @param errorCountIncrement
+     */
+    public UserQuery errorCountIncrement(Integer errorCountIncrement){
+        this.errorCountIncrement = errorCountIncrement;
+        return this;
+    }
+
+    /**
+     * 设置 当日登录失败数
+     * @param errorCountList
+     */
+    public UserQuery errorCountList(List<Integer> errorCountList){
+        this.errorCountList = errorCountList;
+        return this;
+    }
+
+    /**
+     * 设置 当日登录失败数
+     * @param errorCountNotList
+     */
+    public UserQuery errorCountNotList(List<Integer> errorCountNotList){
+        this.errorCountNotList = errorCountNotList;
+        return this;
+    }
+
+    /**
+     * 设置  登录锁定状态0未锁定1已锁定
+     * @param loginLock
+     */
+    public UserQuery loginLock(Integer loginLock){
+        setLoginLock(loginLock);
+        return this;
+    }
+
+    /**
+     * 设置 开始 登录锁定状态0未锁定1已锁定
+     * @param loginLockStart
+     */
+    public UserQuery loginLockStart(Integer loginLockStart){
+        this.loginLockStart = loginLockStart;
+        return this;
+    }
+
+    /**
+     * 设置 结束 登录锁定状态0未锁定1已锁定
+     * @param loginLockEnd
+     */
+    public UserQuery loginLockEnd(Integer loginLockEnd){
+        this.loginLockEnd = loginLockEnd;
+        return this;
+    }
+
+    /**
+     * 设置 增加 登录锁定状态0未锁定1已锁定
+     * @param loginLockIncrement
+     */
+    public UserQuery loginLockIncrement(Integer loginLockIncrement){
+        this.loginLockIncrement = loginLockIncrement;
+        return this;
+    }
+
+    /**
+     * 设置 登录锁定状态0未锁定1已锁定
+     * @param loginLockList
+     */
+    public UserQuery loginLockList(List<Integer> loginLockList){
+        this.loginLockList = loginLockList;
+        return this;
+    }
+
+    /**
+     * 设置 登录锁定状态0未锁定1已锁定
+     * @param loginLockNotList
+     */
+    public UserQuery loginLockNotList(List<Integer> loginLockNotList){
+        this.loginLockNotList = loginLockNotList;
+        return this;
     }
 
     /**
-    * 获取 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
-    * @return orConditionList
-    */
+     * 获取 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
+     * @return orConditionList
+     */
     public List<UserQuery> getOrConditionList(){
-    return this.orConditionList;
+        return this.orConditionList;
     }
 
     /**
-    * 设置 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
-    * @param orConditionList
-    */
+     * 设置 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
+     * @param orConditionList
+     */
     public void setOrConditionList(List<UserQuery> orConditionList){
         this.orConditionList = orConditionList;
     }
 
     /**
-    * 获取 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
-    * @return andConditionList
-    */
+     * 获取 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
+     * @return andConditionList
+     */
     public List<UserQuery> getAndConditionList(){
         return this.andConditionList;
     }
 
     /**
-    * 设置 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
-    * @param andConditionList
-    */
+     * 设置 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
+     * @param andConditionList
+     */
     public void setAndConditionList(List<UserQuery> andConditionList){
         this.andConditionList = andConditionList;
     }

portal-manager/src/main/java/com/mortals/xhx/module/user/model/vo/UserPwdRecordVo.java

+package com.mortals.xhx.module.user.model.vo;
+import com.mortals.framework.model.BaseEntityLong;
+import com.mortals.xhx.module.user.model.UserPwdRecordEntity;
+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 2023-07-26
+*/
+@Data
+public class UserPwdRecordVo extends BaseEntityLong {
+
+}
\ No newline at end of file

portal-manager/src/main/java/com/mortals/xhx/module/user/service/UserPwdRecordService.java

+package com.mortals.xhx.module.user.service;
+import com.mortals.framework.service.ICRUDService;
+import com.mortals.xhx.module.user.model.UserPwdRecordEntity;
+import com.mortals.xhx.module.user.dao.UserPwdRecordDao;
+/**
+* UserPwdRecordService
+*
+* 用户密码修改记录 service接口
+*
+* @author zxfei
+* @date 2023-07-26
+*/
+public interface UserPwdRecordService extends ICRUDService<UserPwdRecordEntity,Long>{
+
+    UserPwdRecordDao getDao();
+}
\ No newline at end of file

portal-manager/src/main/java/com/mortals/xhx/module/user/service/UserService.java

@@ -5,14 +5,9 @@ import com.mortals.framework.model.Context;
 import com.mortals.framework.model.PageInfo;
 import com.mortals.framework.model.Result;
 import com.mortals.framework.service.ICRUDService;
-import com.mortals.framework.service.IUser;
-import com.mortals.xhx.module.menu.model.MenuEntity;
 import com.mortals.xhx.module.user.model.UserEntity;
 import com.mortals.xhx.module.user.model.UserEntityExt;
 
-import java.util.List;
-import java.util.Set;
-
 /**
 * UserService
 *
@@ -31,7 +26,7 @@ public interface UserService extends ICRUDService<UserEntity,Long>{
      * @return
      * @throws AppException
      */
-    UserEntity doLogin(String loginName, String password, String loginIp) throws AppException;
+    UserEntity userdoLogin(String loginName, String password, String loginIp) throws AppException;
 
     /**
      * 校验用户名与密码是否正确

portal-manager/src/main/java/com/mortals/xhx/module/user/service/impl/UserPwdRecordServiceImpl.java

+package com.mortals.xhx.module.user.service.impl;
+import org.springframework.stereotype.Service;
+import com.mortals.framework.service.impl.AbstractCRUDServiceImpl;
+import com.mortals.framework.exception.AppException;
+import com.mortals.framework.model.Context;
+import com.mortals.xhx.module.user.dao.UserPwdRecordDao;
+import com.mortals.xhx.module.user.model.UserPwdRecordEntity;
+import com.mortals.xhx.module.user.service.UserPwdRecordService;
+import lombok.extern.slf4j.Slf4j;
+/**
+* UserPwdRecordService
+* 用户密码修改记录 service实现
+*
+* @author zxfei
+* @date 2023-07-26
+*/
+@Service("userPwdRecordService")
+@Slf4j
+public class UserPwdRecordServiceImpl extends AbstractCRUDServiceImpl<UserPwdRecordDao, UserPwdRecordEntity, Long> implements UserPwdRecordService {
+    
+}
\ No newline at end of file

portal-manager/src/main/java/com/mortals/xhx/module/user/service/impl/UserServiceImpl.java

@@ -4,21 +4,19 @@ import cn.hutool.core.util.StrUtil;
 import com.alibaba.fastjson.JSON;
 import com.alibaba.fastjson.JSONObject;
 import com.mortals.framework.ap.SysConstains;
-import com.mortals.framework.common.Rest;
 import com.mortals.framework.common.code.UserType;
 import com.mortals.framework.exception.AppException;
 import com.mortals.framework.model.Context;
+import com.mortals.framework.model.OrderCol;
 import com.mortals.framework.model.PageInfo;
 import com.mortals.framework.model.Result;
 import com.mortals.framework.service.IAuthTokenService;
 import com.mortals.framework.service.ICacheService;
 import com.mortals.framework.service.impl.AbstractCRUDServiceImpl;
-import com.mortals.framework.util.DateUtils;
-import com.mortals.framework.util.SecurityUtil;
-import com.mortals.framework.util.StringUtils;
+import com.mortals.framework.util.*;
 import com.mortals.xhx.common.code.YesNoEnum;
 import com.mortals.xhx.common.key.Constant;
-import com.mortals.xhx.feign.rsp.ApiResp;
+import com.mortals.xhx.common.utils.Solution;
 import com.mortals.xhx.module.area.model.AreaQuery;
 import com.mortals.xhx.module.area.service.AreaService;
 import com.mortals.xhx.module.menu.service.MenuService;
@@ -26,10 +24,10 @@ import com.mortals.xhx.module.role.model.RoleUserQuery;
 import com.mortals.xhx.module.role.service.RoleService;
 import com.mortals.xhx.module.role.service.RoleUserService;
 import com.mortals.xhx.module.user.dao.UserDao;
-import com.mortals.xhx.module.user.model.UserEntity;
-import com.mortals.xhx.module.user.model.UserEntityExt;
-import com.mortals.xhx.module.user.model.UserQuery;
+import com.mortals.xhx.module.user.dao.UserPwdRecordDao;
+import com.mortals.xhx.module.user.model.*;
 import com.mortals.xhx.module.user.service.UserService;
+import org.apache.commons.collections4.CollectionUtils;
 import org.springframework.beans.BeanUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
@@ -59,6 +57,8 @@ public class UserServiceImpl extends AbstractCRUDServiceImpl<UserDao, UserEntity
     private IAuthTokenService authTokenService;
     @Autowired
     private ICacheService cacheService;
+    @Autowired
+    private UserPwdRecordDao userPwdRecordDao;
 
 
 /*    @Override
@@ -79,11 +79,48 @@ public class UserServiceImpl extends AbstractCRUDServiceImpl<UserDao, UserEntity
 
     private void doHandlerUser(UserEntity entity) throws AppException {
         if (StringUtils.isNotEmpty(entity.getLoginPwd())) {
+            if(!Solution.strongPasswordCheckerII(entity.getLoginPwd())){
+                throw new AppException("新密码至少八位以上，包含大小写加特殊字符加数字");
+            }
             try {
-                entity.setLoginPwd(SecurityUtil.md5DoubleEncoding(entity.getLoginPwd()));
+                if(StringUtils.isEmpty(entity.getSaltKey())){
+                    String saltKey = SecurityCode.getSecurityCode(6,SecurityCode.SecurityCodeLevel.Medium,false);
+                    entity.setSaltKey(saltKey);
+                }
+                entity.setLoginPwd(SecurityUtil.md5DoubleEncoding(entity.getLoginPwd() + entity.getSaltKey()));
             } catch (Exception e) {
                 throw new AppException("密码转换异常");
             }
+            if(entity.getId()!=null) {
+                UserEntity old = this.get(entity.getId());
+                if (old != null ) {
+                    if(!old.getLoginPwd().equals(entity.getLoginPwd())){
+                        //判断新密码与最近五次修改密码是否相同
+                        UserPwdRecordQuery recordQuery = new UserPwdRecordQuery();
+                        recordQuery.setUserId(entity.getId());
+                        recordQuery.setOrderColList(new ArrayList<OrderCol>() {
+                            {
+                                add(new OrderCol("a.createTime", "desc"));
+                            }
+                        });
+                        List<UserPwdRecordEntity> recordEntityList = userPwdRecordDao.getList(recordQuery,0,5);
+                        if(CollectionUtils.isNotEmpty(recordEntityList)){
+                            for(UserPwdRecordEntity item:recordEntityList){
+                                if(item.getLoginPwd().equals(entity.getLoginPwd())){
+                                    throw new AppException("新密码不能与最近五次密码相同！");
+                                }
+                            }
+                        }
+                        UserPwdRecordEntity userPwdRecordEntity = new UserPwdRecordEntity();
+                        userPwdRecordEntity.setUserId(entity.getId());
+                        userPwdRecordEntity.setLoginName(entity.getLoginName());
+                        userPwdRecordEntity.setLoginPwd(entity.getLoginPwd());
+                        userPwdRecordEntity.setCreateTime(new Date());
+                        userPwdRecordEntity.setCreateUserId(entity.getId());
+                        userPwdRecordDao.insert(userPwdRecordEntity);
+                    }
+                }
+            }
         } else {
             entity.setLoginPwd(null);
         }
@@ -136,14 +173,46 @@ public class UserServiceImpl extends AbstractCRUDServiceImpl<UserDao, UserEntity
     }
 
     @Override
-    public UserEntity doLogin(String loginName, String password, String loginIp) throws AppException {
+    public UserEntity userdoLogin(String loginName, String password, String loginIp) throws AppException {
         UserEntity sysUser = this.findByLoginName(loginName);
         if (sysUser == null || !sysUser.getLoginName().equals(loginName)) {
             throw new AppException("用户名不存在！");
         }
+        if(sysUser.getErrorCount()==null){
+            sysUser.setErrorCount(0);
+        }
+        if(sysUser.getLoginLock()==null){
+            sysUser.setLoginLock(0);
+        }
+        if(sysUser.getLoginLock() == 1 && sysUser.getLockTime()!=null){
+            String nowStr = DateUtils.getCurrStrDate();
+            String loginDateStr = DateUtils.getDateTime(sysUser.getLockTime(),"yyyy-MM-dd");
+            if(nowStr.equals(loginDateStr)) {
+                throw new AppException("此账号当天密码错误次数已达上限，已被锁定");
+            }
+        }
+
         try {
+            if(StringUtils.isNotEmpty(sysUser.getSaltKey())) {
+                password += sysUser.getSaltKey();
+            }
             if (!sysUser.getLoginPwd().equals(SecurityUtil.md5DoubleEncoding(password))) {
+                UserEntity update = new UserEntity();
+                update.setId(sysUser.getId());
+                update.setErrorCount(sysUser.getErrorCount()+1);
+                if(update.getErrorCount()==5){
+                    update.setLoginLock(1);
+                    update.setLockTime(new Date());
+                }
+                this.dao.update(update);
                 throw new AppException("登录密码错误！");
+            }else {
+                if(sysUser.getLastUpdatePwdTime()!=null) {
+                    long day = DateUtils.getBetween(sysUser.getLastUpdatePwdTime(), new Date(), 2);
+                    if (day >= 90) {
+                        throw new AppException("密码已超过三个月没有更改，请修改以后再登录");
+                    }
+                }
             }
         } catch (Exception e) {
             throw new AppException("密码验认出错！", e);
@@ -152,6 +221,7 @@ public class UserServiceImpl extends AbstractCRUDServiceImpl<UserDao, UserEntity
         update.setId(sysUser.getId());
         update.setLastLoginAddress(loginIp);
         update.setLastLoginTime(new Date());
+        update.setErrorCount(0);
         this.dao.update(update);
         return sysUser;
     }
@@ -191,18 +261,55 @@ public class UserServiceImpl extends AbstractCRUDServiceImpl<UserDao, UserEntity
             throw new AppException("帐号错误！");
         }
         try {
+            if(StringUtils.isNotEmpty(sysUser.getSaltKey())) {
+                oldPwd += sysUser.getSaltKey();
+            }
             if (!sysUser.getLoginPwd().equals(SecurityUtil.md5DoubleEncoding(oldPwd))) {
                 throw new AppException("原始密码错误！");
             }
+            if(!Solution.strongPasswordCheckerII(newPwd)){
+                throw new AppException("新密码至少八位以上，包含大小写加特殊字符加数字");
+            }
         } catch (Exception e) {
             throw new AppException("密码验认出错！", e);
         }
+
         try {
+            if(StringUtils.isEmpty(sysUser.getSaltKey())) {
+                String saltKey = SecurityCode.getSecurityCode(6,SecurityCode.SecurityCodeLevel.Medium,false);
+                sysUser.setSaltKey(saltKey);
+            }
+            newPwd += sysUser.getSaltKey();
             sysUser.setLoginPwd(SecurityUtil.md5DoubleEncoding(newPwd));
+            //判断新密码与最近五次修改密码是否相同
+            UserPwdRecordQuery recordQuery = new UserPwdRecordQuery();
+            recordQuery.setUserId(sysUser.getId());
+            recordQuery.setOrderColList(new ArrayList<OrderCol>() {
+                {
+                    add(new OrderCol("a.createTime", "desc"));
+                }
+            });
+            List<UserPwdRecordEntity> recordEntityList = userPwdRecordDao.getList(recordQuery,0,5);
+            if(CollectionUtils.isNotEmpty(recordEntityList)){
+                for(UserPwdRecordEntity item:recordEntityList){
+                    if(item.getLoginPwd().equals(sysUser.getLoginPwd())){
+                        throw new AppException("新密码不能与最近五次密码相同！");
+                    }
+                }
+            }
+
+            sysUser.setLastUpdatePwdTime(new Date());
         } catch (Exception e) {
             throw new AppException("密码转换异常！", e);
         }
+        UserPwdRecordEntity userPwdRecordEntity = new UserPwdRecordEntity();
+        userPwdRecordEntity.setUserId(sysUser.getId());
+        userPwdRecordEntity.setLoginName(sysUser.getLoginName());
+        userPwdRecordEntity.setLoginPwd(sysUser.getLoginPwd());
+        userPwdRecordEntity.setCreateTime(new Date());
+        userPwdRecordEntity.setCreateUserId(sysUser.getId());
         dao.update(sysUser);
+        userPwdRecordDao.insert(userPwdRecordEntity);
         return true;
     }
 
@@ -260,6 +367,13 @@ public class UserServiceImpl extends AbstractCRUDServiceImpl<UserDao, UserEntity
             roleUserQuery.setRoleIdList(Arrays.asList(Long.parseLong(entity.getRoleId())));
             roleUserService.assignRoleToUser(roleUserQuery);
         }
+        UserPwdRecordEntity userPwdRecordEntity = new UserPwdRecordEntity();
+        userPwdRecordEntity.setUserId(entity.getId());
+        userPwdRecordEntity.setLoginName(entity.getLoginName());
+        userPwdRecordEntity.setLoginPwd(entity.getLoginPwd());
+        userPwdRecordEntity.setCreateTime(new Date());
+        userPwdRecordEntity.setCreateUserId(entity.getId());
+        userPwdRecordDao.insert(userPwdRecordEntity);
     }
 
     @Override

portal-manager/src/main/java/com/mortals/xhx/module/user/web/UserPwdRecordController.java

+package com.mortals.xhx.module.user.web;
+
+import com.mortals.framework.model.Context;
+import com.mortals.framework.web.BaseCRUDJsonBodyMappingController;
+import com.mortals.xhx.module.user.model.UserPwdRecordEntity;
+import com.mortals.xhx.module.user.service.UserPwdRecordService;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.Map;
+/**
+*
+* 用户密码修改记录
+*
+* @author zxfei
+* @date 2023-07-26
+*/
+@RestController
+@RequestMapping("user/pwd/record")
+public class UserPwdRecordController extends BaseCRUDJsonBodyMappingController<UserPwdRecordService,UserPwdRecordEntity,Long> {
+
+    public UserPwdRecordController(){
+        super.setModuleDesc( "用户密码修改记录");
+    }
+
+    @Override
+    protected void init(Map<String, Object> model, Context context) {
+        super.init(model, context);
+    }
+
+
+}
\ No newline at end of file

portal-manager/src/main/resources/sqlmap/module/user/UserMapper.xml

@@ -24,6 +24,11 @@
         <result property="lastLoginTime" column="lastLoginTime" />
         <result property="lastLoginAddress" column="lastLoginAddress" />
         <result property="areaNames" column="areaNames" />
+        <result property="saltKey" column="saltKey" />
+        <result property="lastUpdatePwdTime" column="lastUpdatePwdTime" />
+        <result property="errorCount" column="errorCount" />
+        <result property="loginLock" column="loginLock" />
+        <result property="lockTime" column="lockTime" />
 
     </resultMap>
 
@@ -88,23 +93,38 @@
             <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('areaNames') or colPickMode == 1 and data.containsKey('areaNames')))">
                 a.areaNames,
             </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('saltKey') or colPickMode == 1 and data.containsKey('saltKey')))">
+                a.saltKey,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('lastUpdatePwdTime') or colPickMode == 1 and data.containsKey('lastUpdatePwdTime')))">
+                a.lastUpdatePwdTime,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('errorCount') or colPickMode == 1 and data.containsKey('errorCount')))">
+                a.errorCount,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('loginLock') or colPickMode == 1 and data.containsKey('loginLock')))">
+                a.loginLock,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('lockTime') or colPickMode == 1 and data.containsKey('lockTime')))">
+                a.lockTime,
+            </if>
         </trim>
     </sql>
     <!-- 新增 区分主键自增加还是业务插入 -->
     <insert id="insert" parameterType="UserEntity"  useGeneratedKeys="true" keyProperty="id">
         insert into mortals_xhx_user
-        (loginName,loginPwd,loginLimitAddress,realName,mobile,phone,email,qq,userType,siteIds,areaCodes,status,createTime,createUserId,createUserName,lastLoginTime,lastLoginAddress,areaNames)
+        (loginName,loginPwd,loginLimitAddress,realName,mobile,phone,email,qq,userType,siteIds,areaCodes,status,createTime,createUserId,createUserName,lastLoginTime,lastLoginAddress,areaNames,saltKey,lastUpdatePwdTime,errorCount,loginLock,lockTime)
         VALUES
-        (#{loginName},#{loginPwd},#{loginLimitAddress},#{realName},#{mobile},#{phone},#{email},#{qq},#{userType},#{siteIds},#{areaCodes},#{status},#{createTime},#{createUserId},#{createUserName},#{lastLoginTime},#{lastLoginAddress},#{areaNames})
+        (#{loginName},#{loginPwd},#{loginLimitAddress},#{realName},#{mobile},#{phone},#{email},#{qq},#{userType},#{siteIds},#{areaCodes},#{status},#{createTime},#{createUserId},#{createUserName},#{lastLoginTime},#{lastLoginAddress},#{areaNames},#{saltKey},#{lastUpdatePwdTime},#{errorCount},#{loginLock},#{lockTime})
     </insert>
 
     <!-- 批量新增 -->
     <insert id="insertBatch" parameterType="paramDto">
         insert into mortals_xhx_user
-        (loginName,loginPwd,loginLimitAddress,realName,mobile,phone,email,qq,userType,siteIds,areaCodes,status,createTime,createUserId,createUserName,lastLoginTime,lastLoginAddress,areaNames)
+        (loginName,loginPwd,loginLimitAddress,realName,mobile,phone,email,qq,userType,siteIds,areaCodes,status,createTime,createUserId,createUserName,lastLoginTime,lastLoginAddress,areaNames,saltKey,lastUpdatePwdTime,errorCount,loginLock,lockTime)
         VALUES
         <foreach collection="data.dataList" item="item" index="index" separator="," >
-            (#{item.loginName},#{item.loginPwd},#{item.loginLimitAddress},#{item.realName},#{item.mobile},#{item.phone},#{item.email},#{item.qq},#{item.userType},#{item.siteIds},#{item.areaCodes},#{item.status},#{item.createTime},#{item.createUserId},#{item.createUserName},#{item.lastLoginTime},#{item.lastLoginAddress},#{item.areaNames})
+            (#{item.loginName},#{item.loginPwd},#{item.loginLimitAddress},#{item.realName},#{item.mobile},#{item.phone},#{item.email},#{item.qq},#{item.userType},#{item.siteIds},#{item.areaCodes},#{item.status},#{item.createTime},#{item.createUserId},#{item.createUserName},#{item.lastLoginTime},#{item.lastLoginAddress},#{item.areaNames},#{item.saltKey},#{item.lastUpdatePwdTime},#{item.errorCount},#{item.loginLock},#{item.lockTime})
         </foreach>
     </insert>
 
@@ -177,6 +197,27 @@
             <if test="(colPickMode==0 and data.containsKey('areaNames')) or (colPickMode==1 and !data.containsKey('areaNames'))">
                 a.areaNames=#{data.areaNames},
             </if>
+            <if test="(colPickMode==0 and data.containsKey('saltKey')) or (colPickMode==1 and !data.containsKey('saltKey'))">
+                a.saltKey=#{data.saltKey},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('lastUpdatePwdTime')) or (colPickMode==1 and !data.containsKey('lastUpdatePwdTime'))">
+                a.lastUpdatePwdTime=#{data.lastUpdatePwdTime},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('errorCount')) or (colPickMode==1 and !data.containsKey('errorCount'))">
+                a.errorCount=#{data.errorCount},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('errorCountIncrement')) or (colPickMode==1 and !data.containsKey('errorCountIncrement'))">
+                a.errorCount=ifnull(a.errorCount,0) + #{data.errorCountIncrement},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('loginLock')) or (colPickMode==1 and !data.containsKey('loginLock'))">
+                a.loginLock=#{data.loginLock},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('loginLockIncrement')) or (colPickMode==1 and !data.containsKey('loginLockIncrement'))">
+                a.loginLock=ifnull(a.loginLock,0) + #{data.loginLockIncrement},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('lockTime')) or (colPickMode==1 and !data.containsKey('lockTime'))">
+                a.lockTime=#{data.lockTime},
+            </if>
         </trim>
         <trim suffixOverrides="where" suffix="">
             where
@@ -330,6 +371,51 @@
                     </if>
                 </foreach>
             </trim>
+            <trim prefix="saltKey=(case" suffix="ELSE saltKey end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('saltKey')) or (colPickMode==1 and !item.containsKey('saltKey'))">
+                        when a.id=#{item.id} then #{item.saltKey}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="lastUpdatePwdTime=(case" suffix="ELSE lastUpdatePwdTime end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('lastUpdatePwdTime')) or (colPickMode==1 and !item.containsKey('lastUpdatePwdTime'))">
+                        when a.id=#{item.id} then #{item.lastUpdatePwdTime}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="errorCount=(case" suffix="ELSE errorCount end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <choose>
+                        <when test="(colPickMode==0 and item.containsKey('errorCount')) or (colPickMode==1 and !item.containsKey('errorCount'))">
+                            when a.id=#{item.id} then #{item.errorCount}
+                        </when>
+                        <when test="(colPickMode==0 and item.containsKey('errorCountIncrement')) or (colPickMode==1 and !item.containsKey('errorCountIncrement'))">
+                            when a.id=#{item.id} then ifnull(a.errorCount,0) + #{item.errorCountIncrement}
+                        </when>
+                    </choose>
+                </foreach>
+            </trim>
+            <trim prefix="loginLock=(case" suffix="ELSE loginLock end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <choose>
+                        <when test="(colPickMode==0 and item.containsKey('loginLock')) or (colPickMode==1 and !item.containsKey('loginLock'))">
+                            when a.id=#{item.id} then #{item.loginLock}
+                        </when>
+                        <when test="(colPickMode==0 and item.containsKey('loginLockIncrement')) or (colPickMode==1 and !item.containsKey('loginLockIncrement'))">
+                            when a.id=#{item.id} then ifnull(a.loginLock,0) + #{item.loginLockIncrement}
+                        </when>
+                    </choose>
+                </foreach>
+            </trim>
+            <trim prefix="lockTime=(case" suffix="ELSE lockTime end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('lockTime')) or (colPickMode==1 and !item.containsKey('lockTime'))">
+                        when a.id=#{item.id} then #{item.lockTime}
+                    </if>
+                </foreach>
+            </trim>
         </trim>
         where id in
         <foreach collection="data.dataList" item="item" index="index" open="(" separator="," close=")">
@@ -353,6 +439,21 @@
             #{item}
         </foreach>
     </delete>
+    <!-- 根据主健列表删除一批，针对单一主健有效 -->
+    <delete id="deleteByKeyList">
+        delete from mortals_xhx_user where id in
+        <foreach collection="list" item="item" index="index" open="(" separator="," close=")">
+            #{item}
+        </foreach>
+    </delete>
+
+    <!-- 根据对象列表删除一批，针对单一主健有效 -->
+    <delete id="deleteByEntityList">
+        delete from mortals_xhx_user 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_user as a
@@ -439,12 +540,18 @@
                 ${_conditionType_} a.id is null
             </if>
         </if>
-        <if test="conditionParamRef.containsKey('idList')">
+        <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>
@@ -461,12 +568,18 @@
                 ${_conditionType_} a.loginName is null
             </if>
         </if>
-        <if test="conditionParamRef.containsKey('loginNameList')">
+        <if test="conditionParamRef.containsKey('loginNameList') and conditionParamRef.loginNameList.size() > 0">
             ${_conditionType_} a.loginName in
             <foreach collection="conditionParamRef.loginNameList" open="(" close=")" index="index" item="item" separator=",">
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('loginNameNotList') and conditionParamRef.loginNameNotList.size() > 0">
+            ${_conditionType_} a.loginName not in
+            <foreach collection="conditionParamRef.loginNameNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('loginPwd')">
             <if test="conditionParamRef.loginPwd != null and conditionParamRef.loginPwd != ''">
@@ -476,12 +589,18 @@
                 ${_conditionType_} a.loginPwd is null
             </if>
         </if>
-        <if test="conditionParamRef.containsKey('loginPwdList')">
+        <if test="conditionParamRef.containsKey('loginPwdList') and conditionParamRef.loginPwdList.size() > 0">
             ${_conditionType_} a.loginPwd in
             <foreach collection="conditionParamRef.loginPwdList" open="(" close=")" index="index" item="item" separator=",">
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('loginPwdNotList') and conditionParamRef.loginPwdNotList.size() > 0">
+            ${_conditionType_} a.loginPwd not in
+            <foreach collection="conditionParamRef.loginPwdNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('loginLimitAddress')">
             <if test="conditionParamRef.loginLimitAddress != null and conditionParamRef.loginLimitAddress != ''">
@@ -491,12 +610,18 @@
                 ${_conditionType_} a.loginLimitAddress is null
             </if>
         </if>
-        <if test="conditionParamRef.containsKey('loginLimitAddressList')">
+        <if test="conditionParamRef.containsKey('loginLimitAddressList') and conditionParamRef.loginLimitAddressList.size() > 0">
             ${_conditionType_} a.loginLimitAddress in
             <foreach collection="conditionParamRef.loginLimitAddressList" open="(" close=")" index="index" item="item" separator=",">
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('loginLimitAddressNotList') and conditionParamRef.loginLimitAddressNotList.size() > 0">
+            ${_conditionType_} a.loginLimitAddress not in
+            <foreach collection="conditionParamRef.loginLimitAddressNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('realName')">
             <if test="conditionParamRef.realName != null and conditionParamRef.realName != ''">
@@ -506,12 +631,18 @@
                 ${_conditionType_} a.realName is null
             </if>
         </if>
-        <if test="conditionParamRef.containsKey('realNameList')">
+        <if test="conditionParamRef.containsKey('realNameList') and conditionParamRef.realNameList.size() > 0">
             ${_conditionType_} a.realName in
             <foreach collection="conditionParamRef.realNameList" open="(" close=")" index="index" item="item" separator=",">
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('realNameNotList') and conditionParamRef.realNameNotList.size() > 0">
+            ${_conditionType_} a.realName not in
+            <foreach collection="conditionParamRef.realNameNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('mobile')">
             <if test="conditionParamRef.mobile != null and conditionParamRef.mobile != ''">
@@ -521,12 +652,18 @@
                 ${_conditionType_} a.mobile is null
             </if>
         </if>
-        <if test="conditionParamRef.containsKey('mobileList')">
+        <if test="conditionParamRef.containsKey('mobileList') and conditionParamRef.mobileList.size() > 0">
             ${_conditionType_} a.mobile in
             <foreach collection="conditionParamRef.mobileList" open="(" close=")" index="index" item="item" separator=",">
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('mobileNotList') and conditionParamRef.mobileNotList.size() > 0">
+            ${_conditionType_} a.mobile not in
+            <foreach collection="conditionParamRef.mobileNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('phone')">
             <if test="conditionParamRef.phone != null and conditionParamRef.phone != ''">
@@ -536,12 +673,18 @@
                 ${_conditionType_} a.phone is null
             </if>
         </if>
-        <if test="conditionParamRef.containsKey('phoneList')">
+        <if test="conditionParamRef.containsKey('phoneList') and conditionParamRef.phoneList.size() > 0">
             ${_conditionType_} a.phone in
             <foreach collection="conditionParamRef.phoneList" open="(" close=")" index="index" item="item" separator=",">
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('phoneNotList') and conditionParamRef.phoneNotList.size() > 0">
+            ${_conditionType_} a.phone not in
+            <foreach collection="conditionParamRef.phoneNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('email')">
             <if test="conditionParamRef.email != null and conditionParamRef.email != ''">
@@ -551,12 +694,18 @@
                 ${_conditionType_} a.email is null
             </if>
         </if>
-        <if test="conditionParamRef.containsKey('emailList')">
+        <if test="conditionParamRef.containsKey('emailList') and conditionParamRef.emailList.size() > 0">
             ${_conditionType_} a.email in
             <foreach collection="conditionParamRef.emailList" open="(" close=")" index="index" item="item" separator=",">
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('emailNotList') and conditionParamRef.emailNotList.size() > 0">
+            ${_conditionType_} a.email not in
+            <foreach collection="conditionParamRef.emailNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('qq')">
             <if test="conditionParamRef.qq != null and conditionParamRef.qq != ''">
@@ -566,12 +715,18 @@
                 ${_conditionType_} a.qq is null
             </if>
         </if>
-        <if test="conditionParamRef.containsKey('qqList')">
+        <if test="conditionParamRef.containsKey('qqList') and conditionParamRef.qqList.size() > 0">
             ${_conditionType_} a.qq in
             <foreach collection="conditionParamRef.qqList" open="(" close=")" index="index" item="item" separator=",">
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('qqNotList') and conditionParamRef.qqNotList.size() > 0">
+            ${_conditionType_} a.qq not in
+            <foreach collection="conditionParamRef.qqNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
         <if test="conditionParamRef.containsKey('userType')">
             <if test="conditionParamRef.userType != null ">
                 ${_conditionType_} a.userType = #{${_conditionParam_}.userType}
@@ -580,12 +735,18 @@
                 ${_conditionType_} a.userType is null
             </if>
         </if>
-        <if test="conditionParamRef.containsKey('userTypeList')">
+        <if test="conditionParamRef.containsKey('userTypeList') and conditionParamRef.userTypeList.size() > 0">
             ${_conditionType_} a.userType in
             <foreach collection="conditionParamRef.userTypeList" open="(" close=")" index="index" item="item" separator=",">
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('userTypeNotList') and conditionParamRef.userTypeNotList.size() > 0">
+            ${_conditionType_} a.userType not in
+            <foreach collection="conditionParamRef.userTypeNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
         <if test="conditionParamRef.containsKey('userTypeStart') and conditionParamRef.userTypeStart != null">
             ${_conditionType_} a.userType <![CDATA[ >= ]]> #{${_conditionParam_}.userTypeStart}
         </if>
@@ -602,12 +763,18 @@
                 ${_conditionType_} a.siteIds is null
             </if>
         </if>
-        <if test="conditionParamRef.containsKey('siteIdsList')">
+        <if test="conditionParamRef.containsKey('siteIdsList') and conditionParamRef.siteIdsList.size() > 0">
             ${_conditionType_} a.siteIds in
             <foreach collection="conditionParamRef.siteIdsList" open="(" close=")" index="index" item="item" separator=",">
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('siteIdsNotList') and conditionParamRef.siteIdsNotList.size() > 0">
+            ${_conditionType_} a.siteIds not in
+            <foreach collection="conditionParamRef.siteIdsNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('areaCodes')">
             <if test="conditionParamRef.areaCodes != null and conditionParamRef.areaCodes != ''">
@@ -617,12 +784,18 @@
                 ${_conditionType_} a.areaCodes is null
             </if>
         </if>
-        <if test="conditionParamRef.containsKey('areaCodesList')">
+        <if test="conditionParamRef.containsKey('areaCodesList') and conditionParamRef.areaCodesList.size() > 0">
             ${_conditionType_} a.areaCodes in
             <foreach collection="conditionParamRef.areaCodesList" open="(" close=")" index="index" item="item" separator=",">
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('areaCodesNotList') and conditionParamRef.areaCodesNotList.size() > 0">
+            ${_conditionType_} a.areaCodes not in
+            <foreach collection="conditionParamRef.areaCodesNotList" 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}
@@ -631,12 +804,18 @@
                 ${_conditionType_} a.status is null
             </if>
         </if>
-        <if test="conditionParamRef.containsKey('statusList')">
+        <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>
@@ -667,12 +846,18 @@
                 ${_conditionType_} a.createUserId is null
             </if>
         </if>
-        <if test="conditionParamRef.containsKey('createUserIdList')">
+        <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>
@@ -689,12 +874,18 @@
                 ${_conditionType_} a.createUserName is null
             </if>
         </if>
-        <if test="conditionParamRef.containsKey('createUserNameList')">
+        <if test="conditionParamRef.containsKey('createUserNameList') and conditionParamRef.createUserNameList.size() > 0">
             ${_conditionType_} a.createUserName in
             <foreach collection="conditionParamRef.createUserNameList" open="(" close=")" index="index" item="item" separator=",">
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('createUserNameNotList') and conditionParamRef.createUserNameNotList.size() > 0">
+            ${_conditionType_} a.createUserName not in
+            <foreach collection="conditionParamRef.createUserNameNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('lastLoginTime')">
             <if test="conditionParamRef.lastLoginTime != null ">
@@ -719,12 +910,18 @@
                 ${_conditionType_} a.lastLoginAddress is null
             </if>
         </if>
-        <if test="conditionParamRef.containsKey('lastLoginAddressList')">
+        <if test="conditionParamRef.containsKey('lastLoginAddressList') and conditionParamRef.lastLoginAddressList.size() > 0">
             ${_conditionType_} a.lastLoginAddress in
             <foreach collection="conditionParamRef.lastLoginAddressList" open="(" close=")" index="index" item="item" separator=",">
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('lastLoginAddressNotList') and conditionParamRef.lastLoginAddressNotList.size() > 0">
+            ${_conditionType_} a.lastLoginAddress not in
+            <foreach collection="conditionParamRef.lastLoginAddressNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
         <if test="conditionParamRef.containsKey('areaNames')">
             <if test="conditionParamRef.areaNames != null and conditionParamRef.areaNames != ''">
@@ -734,12 +931,123 @@
                 ${_conditionType_} a.areaNames is null
             </if>
         </if>
-        <if test="conditionParamRef.containsKey('areaNamesList')">
+        <if test="conditionParamRef.containsKey('areaNamesList') and conditionParamRef.areaNamesList.size() > 0">
             ${_conditionType_} a.areaNames in
             <foreach collection="conditionParamRef.areaNamesList" open="(" close=")" index="index" item="item" separator=",">
                 #{item}
             </foreach>
         </if>
+        <if test="conditionParamRef.containsKey('areaNamesNotList') and conditionParamRef.areaNamesNotList.size() > 0">
+            ${_conditionType_} a.areaNames not in
+            <foreach collection="conditionParamRef.areaNamesNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+
+        <if test="conditionParamRef.containsKey('saltKey')">
+            <if test="conditionParamRef.saltKey != null and conditionParamRef.saltKey != ''">
+                ${_conditionType_} a.saltKey like #{${_conditionParam_}.saltKey}
+            </if>
+            <if test="conditionParamRef.saltKey == null">
+                ${_conditionType_} a.saltKey is null
+            </if>
+        </if>
+        <if test="conditionParamRef.containsKey('saltKeyList') and conditionParamRef.saltKeyList.size() > 0">
+            ${_conditionType_} a.saltKey in
+            <foreach collection="conditionParamRef.saltKeyList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('saltKeyNotList') and conditionParamRef.saltKeyNotList.size() > 0">
+            ${_conditionType_} a.saltKey not in
+            <foreach collection="conditionParamRef.saltKeyNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+
+        <if test="conditionParamRef.containsKey('lastUpdatePwdTime')">
+            <if test="conditionParamRef.lastUpdatePwdTime != null ">
+                ${_conditionType_} a.lastUpdatePwdTime = #{${_conditionParam_}.lastUpdatePwdTime}
+            </if>
+            <if test="conditionParamRef.lastUpdatePwdTime == null">
+                ${_conditionType_} a.lastUpdatePwdTime is null
+            </if>
+        </if>
+        <if test="conditionParamRef.containsKey('lastUpdatePwdTimeStart') and conditionParamRef.lastUpdatePwdTimeStart != null and conditionParamRef.lastUpdatePwdTimeStart!=''">
+            ${_conditionType_} a.lastUpdatePwdTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.lastUpdatePwdTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
+        </if>
+        <if test="conditionParamRef.containsKey('lastUpdatePwdTimeEnd') and conditionParamRef.lastUpdatePwdTimeEnd != null and conditionParamRef.lastUpdatePwdTimeEnd!=''">
+            ${_conditionType_} a.lastUpdatePwdTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.lastUpdatePwdTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
+        </if>
+        <if test="conditionParamRef.containsKey('errorCount')">
+            <if test="conditionParamRef.errorCount != null ">
+                ${_conditionType_} a.errorCount = #{${_conditionParam_}.errorCount}
+            </if>
+            <if test="conditionParamRef.errorCount == null">
+                ${_conditionType_} a.errorCount is null
+            </if>
+        </if>
+        <if test="conditionParamRef.containsKey('errorCountList') and conditionParamRef.errorCountList.size() > 0">
+            ${_conditionType_} a.errorCount in
+            <foreach collection="conditionParamRef.errorCountList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('errorCountNotList') and conditionParamRef.errorCountNotList.size() > 0">
+            ${_conditionType_} a.errorCount not in
+            <foreach collection="conditionParamRef.errorCountNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('errorCountStart') and conditionParamRef.errorCountStart != null">
+            ${_conditionType_} a.errorCount <![CDATA[ >= ]]> #{${_conditionParam_}.errorCountStart}
+        </if>
+        <if test="conditionParamRef.containsKey('errorCountEnd') and conditionParamRef.errorCountEnd != null">
+            ${_conditionType_} a.errorCount <![CDATA[ <= ]]> #{${_conditionParam_}.errorCountEnd}
+        </if>
+
+        <if test="conditionParamRef.containsKey('loginLock')">
+            <if test="conditionParamRef.loginLock != null ">
+                ${_conditionType_} a.loginLock = #{${_conditionParam_}.loginLock}
+            </if>
+            <if test="conditionParamRef.loginLock == null">
+                ${_conditionType_} a.loginLock is null
+            </if>
+        </if>
+        <if test="conditionParamRef.containsKey('loginLockList') and conditionParamRef.loginLockList.size() > 0">
+            ${_conditionType_} a.loginLock in
+            <foreach collection="conditionParamRef.loginLockList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('loginLockNotList') and conditionParamRef.loginLockNotList.size() > 0">
+            ${_conditionType_} a.loginLock not in
+            <foreach collection="conditionParamRef.loginLockNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('loginLockStart') and conditionParamRef.loginLockStart != null">
+            ${_conditionType_} a.loginLock <![CDATA[ >= ]]> #{${_conditionParam_}.loginLockStart}
+        </if>
+        <if test="conditionParamRef.containsKey('loginLockEnd') and conditionParamRef.loginLockEnd != null">
+            ${_conditionType_} a.loginLock <![CDATA[ <= ]]> #{${_conditionParam_}.loginLockEnd}
+        </if>
+
+
+        <if test="conditionParamRef.containsKey('lockTime')">
+            <if test="conditionParamRef.lockTime != null ">
+                ${_conditionType_} a.lockTime = #{${_conditionParam_}.lockTime}
+            </if>
+            <if test="conditionParamRef.lockTime == null">
+                ${_conditionType_} a.lockTime is null
+            </if>
+        </if>
+        <if test="conditionParamRef.containsKey('lockTimeStart') and conditionParamRef.lockTimeStart != null and conditionParamRef.lockTimeStart!=''">
+            ${_conditionType_} a.lockTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.lockTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
+        </if>
+        <if test="conditionParamRef.containsKey('lockTimeEnd') and conditionParamRef.lockTimeEnd != null and conditionParamRef.lockTimeEnd!=''">
+            ${_conditionType_} a.lockTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.lockTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
+        </if>
     </sql>
     <sql id="_orderCols_">
         <if test="orderColList != null and !orderColList.isEmpty()">
@@ -848,6 +1156,31 @@
                     <if test='orderCol.areaNames != null and "DESC".equalsIgnoreCase(orderCol.areaNames)'>DESC</if>
                     ,
                 </if>
+                <if test="orderCol.containsKey('saltKey')">
+                    a.saltKey
+                    <if test='orderCol.saltKey != null and "DESC".equalsIgnoreCase(orderCol.saltKey)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('lastUpdatePwdTime')">
+                    a.lastUpdatePwdTime
+                    <if test='orderCol.lastUpdatePwdTime != null and "DESC".equalsIgnoreCase(orderCol.lastUpdatePwdTime)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('errorCount')">
+                    a.errorCount
+                    <if test='orderCol.errorCount != null and "DESC".equalsIgnoreCase(orderCol.errorCount)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('loginLock')">
+                    a.loginLock
+                    <if test='orderCol.loginLock != null and "DESC".equalsIgnoreCase(orderCol.loginLock)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('lockTime')">
+                    a.lockTime
+                    <if test='orderCol.lockTime != null and "DESC".equalsIgnoreCase(orderCol.lockTime)'>DESC</if>
+                    ,
+                </if>
             </trim>
         </if>
     </sql>

portal-manager/src/main/resources/sqlmap/module/user/UserPwdRecordMapper.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
+"mybatis-3-mapper.dtd">
+<mapper namespace="com.mortals.xhx.module.user.dao.ibatis.UserPwdRecordDaoImpl">
+
+    <!-- 字段和属性映射 -->
+    <resultMap type="UserPwdRecordEntity" id="UserPwdRecordEntity-Map">
+            <id  property="id" column="id" />
+            <result property="userId" column="userId" />
+            <result property="loginName" column="loginName" />
+            <result property="loginPwd" column="loginPwd" />
+            <result property="createTime" column="createTime" />
+            <result property="createUserId" column="createUserId" />
+            
+    </resultMap>
+
+
+    <!-- 表所有列 -->
+    <sql id="_columns">
+        <trim suffixOverrides="," suffix="">
+                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('id') or colPickMode == 1 and data.containsKey('id')))">
+                    a.id,
+                </if>
+                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('userId') or colPickMode == 1 and data.containsKey('userId')))">
+                    a.userId,
+                </if>
+                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('loginName') or colPickMode == 1 and data.containsKey('loginName')))">
+                    a.loginName,
+                </if>
+                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('loginPwd') or colPickMode == 1 and data.containsKey('loginPwd')))">
+                    a.loginPwd,
+                </if>
+                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createTime') or colPickMode == 1 and data.containsKey('createTime')))">
+                    a.createTime,
+                </if>
+                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createUserId') or colPickMode == 1 and data.containsKey('createUserId')))">
+                    a.createUserId,
+                </if>
+        </trim>
+    </sql>
+    <!-- 新增 区分主键自增加还是业务插入 -->
+    <insert id="insert" parameterType="UserPwdRecordEntity"  useGeneratedKeys="true" keyProperty="id">
+        insert into mortals_xhx_user_pwd_record
+        (userId,loginName,loginPwd,createTime,createUserId)
+        VALUES
+        (#{userId},#{loginName},#{loginPwd},#{createTime},#{createUserId})
+    </insert>
+
+    <!-- 批量新增 -->
+    <insert id="insertBatch" parameterType="paramDto">
+        insert into mortals_xhx_user_pwd_record
+        (userId,loginName,loginPwd,createTime,createUserId)
+        VALUES
+        <foreach collection="data.dataList" item="item" index="index" separator="," >
+            (#{item.userId},#{item.loginName},#{item.loginPwd},#{item.createTime},#{item.createUserId})
+        </foreach>
+    </insert>
+
+
+    <!-- 根据ParamDto更新 -->
+    <update id="update" parameterType="paramDto">
+        update mortals_xhx_user_pwd_record as a
+        set
+        <trim suffixOverrides="," suffix="">
+            <if test="(colPickMode==0 and data.containsKey('userId')) or (colPickMode==1 and !data.containsKey('userId'))">
+                a.userId=#{data.userId},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('userIdIncrement')) or (colPickMode==1 and !data.containsKey('userIdIncrement'))">
+                a.userId=ifnull(a.userId,0) + #{data.userIdIncrement},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('loginName')) or (colPickMode==1 and !data.containsKey('loginName'))">
+                a.loginName=#{data.loginName},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('loginPwd')) or (colPickMode==1 and !data.containsKey('loginPwd'))">
+                a.loginPwd=#{data.loginPwd},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('createTime')) or (colPickMode==1 and !data.containsKey('createTime'))">
+                a.createTime=#{data.createTime},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('createUserId')) or (colPickMode==1 and !data.containsKey('createUserId'))">
+                a.createUserId=#{data.createUserId},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('createUserIdIncrement')) or (colPickMode==1 and !data.containsKey('createUserIdIncrement'))">
+                a.createUserId=ifnull(a.createUserId,0) + #{data.createUserIdIncrement},
+            </if>
+        </trim>
+        <trim suffixOverrides="where" suffix="">
+            where
+            <trim prefixOverrides="and" prefix="">
+                <include refid="_condition_"/>
+            </trim>
+        </trim>
+    </update>
+    <!-- 批量更新 -->
+    <update id="updateBatch" parameterType="paramDto">
+        update mortals_xhx_user_pwd_record as a
+        <trim prefix="set" suffixOverrides=",">
+                        <trim prefix="userId=(case" suffix="ELSE userId end),">
+                            <foreach collection="data.dataList" item="item" index="index" separator="" >
+                                <choose>
+                                    <when test="(colPickMode==0 and item.containsKey('userId')) or (colPickMode==1 and !item.containsKey('userId'))">
+                                        when a.id=#{item.id} then #{item.userId}
+                                    </when>
+                                    <when test="(colPickMode==0 and item.containsKey('userIdIncrement')) or (colPickMode==1 and !item.containsKey('userIdIncrement'))">
+                                        when a.id=#{item.id} then ifnull(a.userId,0) + #{item.userIdIncrement}
+                                    </when>
+                                </choose>
+                            </foreach>
+                        </trim>
+                <trim prefix="loginName=(case" suffix="ELSE loginName end),">
+                    <foreach collection="data.dataList" item="item" index="index" separator="" >
+                        <if test="(colPickMode==0 and item.containsKey('loginName')) or (colPickMode==1 and !item.containsKey('loginName'))">
+                            when a.id=#{item.id} then #{item.loginName}
+                        </if>
+                    </foreach>
+                </trim>
+                <trim prefix="loginPwd=(case" suffix="ELSE loginPwd end),">
+                    <foreach collection="data.dataList" item="item" index="index" separator="" >
+                        <if test="(colPickMode==0 and item.containsKey('loginPwd')) or (colPickMode==1 and !item.containsKey('loginPwd'))">
+                            when a.id=#{item.id} then #{item.loginPwd}
+                        </if>
+                    </foreach>
+                </trim>
+                <trim prefix="createTime=(case" suffix="ELSE createTime end),">
+                    <foreach collection="data.dataList" item="item" index="index" separator="" >
+                        <if test="(colPickMode==0 and item.containsKey('createTime')) or (colPickMode==1 and !item.containsKey('createTime'))">
+                            when a.id=#{item.id} then #{item.createTime}
+                        </if>
+                    </foreach>
+                </trim>
+                        <trim prefix="createUserId=(case" suffix="ELSE createUserId end),">
+                            <foreach collection="data.dataList" item="item" index="index" separator="" >
+                                <choose>
+                                    <when test="(colPickMode==0 and item.containsKey('createUserId')) or (colPickMode==1 and !item.containsKey('createUserId'))">
+                                        when a.id=#{item.id} then #{item.createUserId}
+                                    </when>
+                                    <when test="(colPickMode==0 and item.containsKey('createUserIdIncrement')) or (colPickMode==1 and !item.containsKey('createUserIdIncrement'))">
+                                        when a.id=#{item.id} then ifnull(a.createUserId,0) + #{item.createUserIdIncrement}
+                                    </when>
+                                </choose>
+                            </foreach>
+                        </trim>
+        </trim>
+        where id in
+        <foreach collection="data.dataList" item="item" index="index" open="(" separator="," close=")">
+            #{item.id}
+        </foreach>
+    </update>
+    <!-- 根据主健查询 -->
+    <select id="getByKey" parameterType="paramDto" resultMap="UserPwdRecordEntity-Map">
+        select <include refid="_columns"/>
+        from mortals_xhx_user_pwd_record as a
+        where a.id=#{condition.id}
+    </select>
+    <!-- 根据主健删除 -->
+    <delete id="deleteByKey" parameterType="paramDto">
+        delete a.* from mortals_xhx_user_pwd_record as a where a.id=#{condition.id}
+    </delete>
+    <!-- 根据主健删除一批，针对单一主健有效 -->
+    <delete id="deleteByKeys">
+        delete from mortals_xhx_user_pwd_record where id in
+        <foreach collection="array" item="item" index="index" open="(" separator="," close=")">
+            #{item}
+        </foreach>
+    </delete>
+    <!-- 根据主健列表删除一批，针对单一主健有效 -->
+    <delete id="deleteByKeyList">
+        delete from mortals_xhx_user_pwd_record where id in
+        <foreach collection="list" item="item" index="index" open="(" separator="," close=")">
+            #{item}
+        </foreach>
+    </delete>
+
+    <!-- 根据对象列表删除一批，针对单一主健有效 -->
+    <delete id="deleteByEntityList">
+        delete from mortals_xhx_user_pwd_record where id in
+        <foreach collection="list" item="item" index="index" open="(" separator="," close=")">
+            #{item.id}
+        </foreach>
+    </delete>
+    <!-- 根据paramDto删除一批 -->
+    <delete id="deleteByMap" parameterType="paramDto">
+        delete a.* from mortals_xhx_user_pwd_record as a
+        <trim suffixOverrides="where" suffix="">
+            where
+            <trim prefixOverrides="and" prefix="">
+                <include refid="_condition_"/>
+            </trim>
+        </trim>
+    </delete>
+    <!-- 获取列表 -->
+    <select id="getList" parameterType="paramDto" resultMap="UserPwdRecordEntity-Map">
+        select <include refid="_columns"/>
+        from mortals_xhx_user_pwd_record as a
+        <trim suffixOverrides="where" suffix="">
+            where
+            <trim prefixOverrides="and" prefix="">
+                <include refid="_condition_"/>
+            </trim>
+        </trim>
+        <include refid="_orderCols_"/>
+    </select>
+
+
+
+    <!-- 获取 -->
+    <select id="getListCount" parameterType="paramDto" resultType="int">
+        select count(1)
+        from mortals_xhx_user_pwd_record as a
+        <trim suffixOverrides="where" suffix="">
+            where
+            <trim prefixOverrides="and" prefix="">
+                <include refid="_condition_"/>
+            </trim>
+        </trim>
+    </select>
+    <!-- 条件映射 -->
+    <sql id="_condition_">
+        <if test="condition != null and !condition.isEmpty()">
+            <!-- 条件映射-普通条件 -->
+            <include refid="_condition_param_">
+                <property name="_conditionParam_" value="condition"/>
+                <property name="_conditionType_" value="and"/>
+            </include>
+            <!-- 条件映射-集合之间使用AND，集合中元素使用OR-(list[0].1 or list[0].2) and (list[1].3 or list[1].4) -->
+            <if test="condition.containsKey('andConditionList') and !condition.andConditionList.isEmpty()">
+                and
+                <foreach collection="condition.andConditionList" open="(" close=")" index="index" item="andCondition" separator=" and ">
+                    <trim prefixOverrides="or" prefix="(" suffix=")">
+                        <include refid="_condition_param_">
+                            <property name="_conditionParam_" value="andCondition"/>
+                            <property name="_conditionType_" value="or"/>
+                        </include>
+                    </trim>
+                </foreach>
+            </if>
+            <!-- 条件映射-集合之间使用OR，集合中元素使用AND-(list[0].1 and list[0].2) or (list[1].3 and list[1].4) -->
+            <if test="condition.containsKey('orConditionList') and !condition.orConditionList.isEmpty()">
+                and
+                <foreach collection="condition.orConditionList" open="(" close=")" index="index" item="orCondition" separator=" or ">
+                    <trim prefixOverrides="and" prefix="(" suffix=")">
+                        <include refid="_condition_param_">
+                            <property name="_conditionParam_" value="orCondition"/>
+                            <property name="_conditionType_" value="and"/>
+                        </include>
+                    </trim>
+                </foreach>
+            </if>
+        </if>
+    </sql>
+    <!-- 条件映射-代参数 -->
+    <sql id="_condition_param_">
+        <bind name="conditionParamRef" value="${_conditionParam_}"/>
+        <if test="conditionParamRef.containsKey('id')">
+            <if test="conditionParamRef.id != null">
+                ${_conditionType_} a.id=#{${_conditionParam_}.id}
+            </if>
+        </if>
+            <if test="conditionParamRef.containsKey('id')">
+                <if test="conditionParamRef.id != null ">
+                    ${_conditionType_} a.id = #{${_conditionParam_}.id}
+                </if>
+                <if test="conditionParamRef.id == null">
+                    ${_conditionType_} a.id is null
+                </if>
+            </if>
+            <if test="conditionParamRef.containsKey('idList') and conditionParamRef.idList.size() > 0">
+                ${_conditionType_} a.id in
+                <foreach collection="conditionParamRef.idList" open="(" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+            <if test="conditionParamRef.containsKey('idNotList') and conditionParamRef.idNotList.size() > 0">
+                ${_conditionType_} a.id not in
+                <foreach collection="conditionParamRef.idNotList" open="(" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+            <if test="conditionParamRef.containsKey('idStart') and conditionParamRef.idStart != null">
+                ${_conditionType_} a.id <![CDATA[ >= ]]> #{${_conditionParam_}.idStart}
+            </if>
+            <if test="conditionParamRef.containsKey('idEnd') and conditionParamRef.idEnd != null">
+                ${_conditionType_} a.id <![CDATA[ <= ]]> #{${_conditionParam_}.idEnd}
+            </if>
+
+            <if test="conditionParamRef.containsKey('userId')">
+                <if test="conditionParamRef.userId != null ">
+                    ${_conditionType_} a.userId = #{${_conditionParam_}.userId}
+                </if>
+                <if test="conditionParamRef.userId == null">
+                    ${_conditionType_} a.userId is null
+                </if>
+            </if>
+            <if test="conditionParamRef.containsKey('userIdList') and conditionParamRef.userIdList.size() > 0">
+                ${_conditionType_} a.userId in
+                <foreach collection="conditionParamRef.userIdList" open="(" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+            <if test="conditionParamRef.containsKey('userIdNotList') and conditionParamRef.userIdNotList.size() > 0">
+                ${_conditionType_} a.userId not in
+                <foreach collection="conditionParamRef.userIdNotList" open="(" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+            <if test="conditionParamRef.containsKey('userIdStart') and conditionParamRef.userIdStart != null">
+                ${_conditionType_} a.userId <![CDATA[ >= ]]> #{${_conditionParam_}.userIdStart}
+            </if>
+            <if test="conditionParamRef.containsKey('userIdEnd') and conditionParamRef.userIdEnd != null">
+                ${_conditionType_} a.userId <![CDATA[ <= ]]> #{${_conditionParam_}.userIdEnd}
+            </if>
+
+
+            <if test="conditionParamRef.containsKey('loginName')">
+                <if test="conditionParamRef.loginName != null and conditionParamRef.loginName != ''">
+                    ${_conditionType_} a.loginName like #{${_conditionParam_}.loginName}
+                </if>
+                <if test="conditionParamRef.loginName == null">
+                    ${_conditionType_} a.loginName is null
+                </if>
+            </if>
+            <if test="conditionParamRef.containsKey('loginNameList') and conditionParamRef.loginNameList.size() > 0">
+                ${_conditionType_} a.loginName in
+                <foreach collection="conditionParamRef.loginNameList" open="(" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+            <if test="conditionParamRef.containsKey('loginNameNotList') and conditionParamRef.loginNameNotList.size() > 0">
+                ${_conditionType_} a.loginName not in
+                <foreach collection="conditionParamRef.loginNameNotList" open="(" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+
+            <if test="conditionParamRef.containsKey('loginPwd')">
+                <if test="conditionParamRef.loginPwd != null and conditionParamRef.loginPwd != ''">
+                    ${_conditionType_} a.loginPwd like #{${_conditionParam_}.loginPwd}
+                </if>
+                <if test="conditionParamRef.loginPwd == null">
+                    ${_conditionType_} a.loginPwd is null
+                </if>
+            </if>
+            <if test="conditionParamRef.containsKey('loginPwdList') and conditionParamRef.loginPwdList.size() > 0">
+                ${_conditionType_} a.loginPwd in
+                <foreach collection="conditionParamRef.loginPwdList" open="(" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+            <if test="conditionParamRef.containsKey('loginPwdNotList') and conditionParamRef.loginPwdNotList.size() > 0">
+                ${_conditionType_} a.loginPwd not in
+                <foreach collection="conditionParamRef.loginPwdNotList" open="(" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+
+            <if test="conditionParamRef.containsKey('createTime')">
+                <if test="conditionParamRef.createTime != null ">
+                    ${_conditionType_} a.createTime = #{${_conditionParam_}.createTime}
+                </if>
+                <if test="conditionParamRef.createTime == null">
+                    ${_conditionType_} a.createTime is null
+                </if>
+            </if>
+            <if test="conditionParamRef.containsKey('createTimeStart') and conditionParamRef.createTimeStart != null and conditionParamRef.createTimeStart!=''">
+                ${_conditionType_} a.createTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
+            </if>
+            <if test="conditionParamRef.containsKey('createTimeEnd') and conditionParamRef.createTimeEnd != null and conditionParamRef.createTimeEnd!=''">
+                ${_conditionType_} a.createTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
+            </if>
+            <if test="conditionParamRef.containsKey('createUserId')">
+                <if test="conditionParamRef.createUserId != null ">
+                    ${_conditionType_} a.createUserId = #{${_conditionParam_}.createUserId}
+                </if>
+                <if test="conditionParamRef.createUserId == null">
+                    ${_conditionType_} a.createUserId is null
+                </if>
+            </if>
+            <if test="conditionParamRef.containsKey('createUserIdList') and conditionParamRef.createUserIdList.size() > 0">
+                ${_conditionType_} a.createUserId in
+                <foreach collection="conditionParamRef.createUserIdList" open="(" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+            <if test="conditionParamRef.containsKey('createUserIdNotList') and conditionParamRef.createUserIdNotList.size() > 0">
+                ${_conditionType_} a.createUserId not in
+                <foreach collection="conditionParamRef.createUserIdNotList" open="(" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+            <if test="conditionParamRef.containsKey('createUserIdStart') and conditionParamRef.createUserIdStart != null">
+                ${_conditionType_} a.createUserId <![CDATA[ >= ]]> #{${_conditionParam_}.createUserIdStart}
+            </if>
+            <if test="conditionParamRef.containsKey('createUserIdEnd') and conditionParamRef.createUserIdEnd != null">
+                ${_conditionType_} a.createUserId <![CDATA[ <= ]]> #{${_conditionParam_}.createUserIdEnd}
+            </if>
+
+    </sql>
+    <sql id="_orderCols_">
+        <if test="orderColList != null and !orderColList.isEmpty()">
+            order by
+            <trim suffixOverrides=","  suffix="">
+                <foreach collection="orderColList" open="" close="" index="index" item="item" separator=",">
+                     ${item.colName} ${item.sortKind}
+                </foreach>
+            </trim>
+        </if>
+        <if test="(orderColList == null or orderColList.isEmpty()) and orderCol != null and !orderCol.isEmpty()">
+            order by
+            <trim suffixOverrides=","  suffix="">
+                    <if test="orderCol.containsKey('id')">
+                        a.id
+                        <if test='orderCol.id != null and "DESC".equalsIgnoreCase(orderCol.id)'>DESC</if>
+                        ,
+                    </if>
+                    <if test="orderCol.containsKey('userId')">
+                        a.userId
+                        <if test='orderCol.userId != null and "DESC".equalsIgnoreCase(orderCol.userId)'>DESC</if>
+                        ,
+                    </if>
+                    <if test="orderCol.containsKey('loginName')">
+                        a.loginName
+                        <if test='orderCol.loginName != null and "DESC".equalsIgnoreCase(orderCol.loginName)'>DESC</if>
+                        ,
+                    </if>
+                    <if test="orderCol.containsKey('loginPwd')">
+                        a.loginPwd
+                        <if test='orderCol.loginPwd != null and "DESC".equalsIgnoreCase(orderCol.loginPwd)'>DESC</if>
+                        ,
+                    </if>
+                    <if test="orderCol.containsKey('createTime')">
+                        a.createTime
+                        <if test='orderCol.createTime != null and "DESC".equalsIgnoreCase(orderCol.createTime)'>DESC</if>
+                        ,
+                    </if>
+                    <if test="orderCol.containsKey('createUserId')">
+                        a.createUserId
+                        <if test='orderCol.createUserId != null and "DESC".equalsIgnoreCase(orderCol.createUserId)'>DESC</if>
+                        ,
+                    </if>
+            </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