更新

FullCardClient/src/main/java/com/zhongshu/card/client/model/org/OrganizationAddParam.java

@@ -47,4 +47,7 @@ public class OrganizationAddParam extends SuperParam {
 
     @Schema(description = "机构类型")
     private AuthType authType = AuthType.Enterprise;
+
+    @Schema(description = "密码")
+    private String password;
 }

FullCardClient/src/main/java/com/zhongshu/card/client/model/org/RegionModel.java

@@ -0,0 +1,29 @@
+package com.zhongshu.card.client.model.org;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+public class RegionModel {
+
+    /**
+     * 编号
+     */
+    @Schema(description = "编号")
+    private String code;
+
+
+    @Schema(description = "地区名称")
+    private String name;
+
+    /**
+     * 省市区province、city、county
+     */
+    @Schema(description = "省市区province、市city、村county")
+    private String type;
+
+}

FullCardClient/src/main/java/com/zhongshu/card/client/model/org/SchoolAddParam.java

@@ -0,0 +1,15 @@
+package com.zhongshu.card.client.model.org;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+
+/**
+ * @author TRX
+ * @date 2024/6/4
+ */
+@Data
+public class SchoolAddParam extends OrganizationAddParam{
+    @Schema(description = "项目ID")
+    private String projectId;
+
+}

FullCardClient/src/main/java/com/zhongshu/card/client/service/org/OrganizationService.java

@@ -19,6 +19,9 @@ public interface OrganizationService {
 
     public ResultContent addOrganization(OrganizationAddParam param);
 
+    // 添加学校
+    public ResultContent addSchool(SchoolAddParam param);
+
     public ResultContent update(OrganizationUpdateParam param);
 
     public ResultContent<OrganizationModel> getDetail(String oid);

FullCardServer/src/main/java/com/zhongshu/card/server/core/controller/org/OrganizationController.java

@@ -52,6 +52,20 @@ public class OrganizationController {
 
     //------------------------------项目管理 end------------------------
 
+    //------------------------------学校管理 start----------------------
+
+    @ResourceAuth(value = "user",type = AuthType.User)
+    @ResourceAuth(value = AuthConstant.SuperAdmin,type = AuthType.Platform)
+    @Operation(summary = "学校-添加", description = "学校-添加")
+    @RequestMapping(value = "addSchool", method = {RequestMethod.POST})
+    public ResultContent addSchool(@RequestBody SchoolAddParam param) {
+        param.setAuthType(AuthType.Project);
+        return this.organizationService.addSchool(param);
+    }
+
+
+    //------------------------------学校管理 end------------------------
+
     @ResourceAuth(value = "user",type = AuthType.User)
     @ResourceAuth(value = AuthConstant.SuperAdmin,type = AuthType.Platform)
     @Operation(summary = "项目-学校-商家-删除", description = "项目-学校-商家-删除")

FullCardServer/src/main/java/com/zhongshu/card/server/core/controller/org/RegionController.java

@@ -0,0 +1,37 @@
+package com.zhongshu.card.server.core.controller.org;
+
+import com.github.microservice.auth.client.constant.AuthConstant;
+import com.github.microservice.auth.client.content.ResultContent;
+import com.github.microservice.auth.security.annotations.ResourceAuth;
+import com.github.microservice.auth.security.type.AuthType;
+import com.zhongshu.card.client.model.org.RegionModel;
+import com.zhongshu.card.server.core.service.org.RegionService;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.List;
+
+@RestController
+@RequestMapping("region")
+@Slf4j
+@Tag(name = "地区管理")
+public class RegionController {
+
+    @Autowired
+    RegionService regionService;
+
+    @Operation( summary = "获取地区数据")
+    @RequestMapping(value = "getRegion", method = RequestMethod.POST)
+    @ResourceAuth(value = AuthConstant.User, type = AuthType.User)
+    public ResultContent<List<RegionModel>> getRegion(@RequestBody @Validated RegionModel regionModel) {
+        return regionService.getRegion(regionModel);
+    }
+
+}

FullCardServer/src/main/java/com/zhongshu/card/server/core/dao/org/RegionDao.java

@@ -0,0 +1,12 @@
+package com.zhongshu.card.server.core.dao.org;
+
+import com.github.microservice.components.data.mongo.mongo.dao.MongoDao;
+import com.zhongshu.card.server.core.dao.org.extend.RegionDaoExtend;
+import com.zhongshu.card.server.core.domain.org.Region;
+
+import java.util.List;
+
+public interface RegionDao extends MongoDao<Region>, RegionDaoExtend {
+
+    List<Region> findByCodeStartingWithAndType(String code, String type);
+}

FullCardServer/src/main/java/com/zhongshu/card/server/core/dao/org/extend/RegionDaoExtend.java

@@ -0,0 +1,11 @@
+package com.zhongshu.card.server.core.dao.org.extend;
+
+import com.zhongshu.card.client.model.org.RegionModel;
+
+import java.util.List;
+
+public interface RegionDaoExtend {
+
+
+    List<RegionModel> findByCodeStartingWithAndTypeAndName(RegionModel regionModel);
+}

FullCardServer/src/main/java/com/zhongshu/card/server/core/dao/org/impl/RegionDaoImpl.java

@@ -0,0 +1,36 @@
+package com.zhongshu.card.server.core.dao.org.impl;
+
+import com.zhongshu.card.client.model.org.RegionModel;
+import com.zhongshu.card.server.core.dao.org.extend.RegionDaoExtend;
+import com.zhongshu.card.server.core.domain.org.Region;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.mongodb.core.MongoTemplate;
+import org.springframework.data.mongodb.core.query.Criteria;
+import org.springframework.data.mongodb.core.query.Query;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+public class RegionDaoImpl implements RegionDaoExtend {
+
+    @Autowired
+    MongoTemplate mongoTemplate;
+
+    @Override
+    public List<RegionModel> findByCodeStartingWithAndTypeAndName(RegionModel regionModel) {
+        Query query = new Query();
+        Criteria criteria = new Criteria();
+        Optional.ofNullable(regionModel.getCode()).ifPresent(it -> criteria.and("code").regex("^" + it));
+        Optional.ofNullable(regionModel.getName()).ifPresent(it -> criteria.and("name").regex("^.*" + it + ".*$"));
+        Optional.ofNullable(regionModel.getType()).ifPresent(it -> criteria.and("type").is(it));
+
+        query.addCriteria(criteria);
+        return mongoTemplate.find(query, Region.class).stream().map(it -> {
+            RegionModel re = new RegionModel();
+            BeanUtils.copyProperties(it, re);
+            return re;
+        }).collect(Collectors.toList());
+    }
+}

FullCardServer/src/main/java/com/zhongshu/card/server/core/dataConfig/PasswordCheckConf.java

@@ -0,0 +1,120 @@
+package com.zhongshu.card.server.core.dataConfig;
+
+public class PasswordCheckConf {
+
+    /*
+     * 是否检测密码口令长度
+     */
+    public static String CHECK_PASSWORD_LENGTH = "enable";
+
+    /**
+     * 密码最小长度，默认为6
+     */
+    public static String MIN_LENGTH = "6";
+
+    /**
+     * 密码最大长度，默认为20
+     */
+    public static String MAX_LENGTH = "8";
+
+    /**
+     * 是否包含数字
+     */
+    public static String CHECK_CONTAIN_DIGIT = "disable";
+
+    /**
+     * 是否包含字母
+     */
+    public static String CHECK_CONTAIN_CASE = "disable";
+
+    /**
+     * 是否区分大小写
+     */
+    public static String CHECK_DISTINGGUISH_CASE = "disable";
+
+    /**
+     * 是否包含小写字母
+     */
+    public static String CHECK_LOWER_CASE = "disable";
+
+    /**
+     * 是否包含大学字母
+     */
+    public static String CHECK_UPPER_CASE = "disable";
+
+    /**
+     * 是否包含特殊符号
+     */
+    public static String CHECK_CONTAIN_SPECIAL_CHAR = "disable";
+
+    /**
+     * 特殊符号集合
+     */
+    public static String SPECIAL_CHAR = "!\\\"#$%&'()*+,-./:;<=>?@[\\\\]^_`{|}~";
+
+    /**
+     * 是否检测键盘按键横向连续
+     */
+    public static String CHECK_HORIZONTAL_KEY_SEQUENTIAL = "enable";
+
+    /**
+     * 键盘物理位置横向不允许最小的连续个数
+     */
+    public static String LIMIT_HORIZONTAL_NUM_KEY = "4";
+
+    /**
+     * 是否检测键盘按键斜向连续
+     */
+    public static String CHECK_SLOPE_KEY_SEQUENTIAL = "enable";
+
+    /**
+     * 键盘物理位置斜向不允许最小的连续个数
+     */
+    public static String LIMIT_SLOPE_NUM_KEY = "4";
+
+    /**
+     * 是否检测逻辑位置连续
+     */
+    public static String CHECK_LOGIC_SEQUENTIAL = "enable";
+    /**
+     * 密码口令中字符在逻辑位置上不允许最小的连续个数
+     */
+    public static String LIMIT_LOGIC_NUM_CHAR = "6";
+
+    /**
+     * 是否检测连续字符相同
+     */
+    public static String CHECK_SEQUENTIAL_CHAR_SAME = "enable";
+    /**
+     * 密码口令中相同字符不允许最小的连续个数
+     */
+    public static String LIMIT_NUM_SAME_CHAR = "3";
+
+    /**
+     * 键盘横向方向规则
+     */
+    public static String[] KEYBOARD_HORIZONTAL_ARR = { "01234567890", "qwertyuiop", "asdfghjkl", "zxcvbnm", };
+    /**
+     * 键盘斜线方向规则
+     */
+    public static String[] KEYBOARD_SLOPE_ARR = { "1qaz", "2wsx", "3edc", "4rfv", "5tgb", "6yhn", "7ujm", "8ik,",
+            "9ol.", "0p;/", "=[;.", "-pl,", "0okm", "9ijn", "8uhb", "7ygv", "6tfc", "5rdx", "4esz" };
+
+    /**
+     * 是否检测常用词库
+     */
+    public static String CHECK_SIMPLE_WORD = "enable";
+
+    /**
+     * 常用词库
+     */
+    public static String[] SIMPLE_WORDS = { "admin", "szim", "epicrouter", "password", "grouter", "dare", "root",
+            "guest", "user", "success", "pussy", "mustang", "fuckme", "jordan", "test", "hunter", "jennifer", "batman",
+            "thomas", "soccer", "sexy", "killer", "george", "asshole", "fuckyou", "summer", "hello", "secret", "fucker",
+            "enter", "cookie", "administrator",
+            // 中国网民常用密码
+            "xiaoming", "taobao", "iloveyou", "woaini", "982464",
+            // 国外网民常用密码
+            "monkey", "letmein", "trustno1", "dragon", "baseball", "master", "sunshine", "ashley", "bailey", "shadow",
+            "superman", "football", "michael", "qazwsx" };
+}

FullCardServer/src/main/java/com/zhongshu/card/server/core/domain/org/Region.java

@@ -0,0 +1,36 @@
+package com.zhongshu.card.server.core.domain.org;
+
+import com.github.microservice.components.data.mongo.mongo.domain.SuperEntity;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import org.springframework.data.mongodb.core.mapping.Document;
+
+@Data
+@Builder
+@Document
+@AllArgsConstructor
+@NoArgsConstructor
+public class Region extends SuperEntity {
+
+    /**
+     * 编号
+     */
+    private String code;
+
+    /**
+     * 名称
+     */
+    private String name;
+
+    /**
+     * 省市区province、city、county
+     */
+    private String type;
+
+    /**
+     * 删除
+     */
+    private String isDelete;
+}

FullCardServer/src/main/java/com/zhongshu/card/server/core/service/org/OrganizationServiceImpl.java

@@ -97,7 +97,7 @@ public class OrganizationServiceImpl extends SuperService implements Organizatio
      * @return
      */
     @Override
-    public ResultContent addOrganization(OrganizationAddParam param) {
+    public ResultContent<Organization> addOrganization(OrganizationAddParam param) {
         param.setId(null);
         // 验证数据
         Organization temp = organizationDao.findTopByName(param.getName());
@@ -156,6 +156,18 @@ public class OrganizationServiceImpl extends SuperService implements Organizatio
             initOrganization(organization);
         }
 
+        return ResultContent.buildSuccess(organization);
+    }
+
+    /**
+     * 添加学校
+     * @param param
+     * @return
+     */
+    @Override
+    public ResultContent addSchool(SchoolAddParam param){
+
+
         return ResultContent.buildSuccess();
     }
 

FullCardServer/src/main/java/com/zhongshu/card/server/core/service/org/RegionService.java

@@ -0,0 +1,24 @@
+package com.zhongshu.card.server.core.service.org;
+
+import com.github.microservice.auth.client.content.ResultContent;
+import com.zhongshu.card.client.model.org.RegionModel;
+import com.zhongshu.card.server.core.dao.org.RegionDao;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+@Slf4j
+@Service
+public class RegionService {
+
+    @Autowired
+    RegionDao regionDao;
+
+    public ResultContent<List<RegionModel>> getRegion(RegionModel regionModel){
+        List<RegionModel> byCodeStartingWithAndTypeAndName = regionDao.findByCodeStartingWithAndTypeAndName(regionModel);
+        return ResultContent.buildContent(byCodeStartingWithAndTypeAndName);
+    }
+
+}

FullCardServer/src/main/java/com/zhongshu/card/server/core/util/PasswordCheckUtil.java

@@ -0,0 +1,477 @@
+package com.zhongshu.card.server.core.util;
+
+
+import com.zhongshu.card.server.core.dataConfig.PasswordCheckConf;
+
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * 密码规则检测
+ */
+public class PasswordCheckUtil {
+
+    /**
+     * 检测密码中字符长度
+     *
+     * @param password
+     * @return 符合长度要求 返回
+     */
+    public static boolean checkPasswordLength(String password) {
+        boolean flag = false;
+
+        // 如未设置最大长度，仅判断最小长度即可
+        if ("".equals(PasswordCheckConf.MAX_LENGTH)) {
+            if (password.length() >= Integer.parseInt(PasswordCheckConf.MIN_LENGTH)) {
+                flag = true;
+            }
+        } else {
+            if (password.length() >= Integer.parseInt(PasswordCheckConf.MIN_LENGTH)
+                    && password.length() <= Integer.parseInt(PasswordCheckConf.MAX_LENGTH)) {
+                flag = true;
+            }
+        }
+
+        return flag;
+    }
+
+    /**
+     * 检查密码中是否包含数字
+     *
+     * @param password
+     * @return 包含数字 返回true
+     */
+    public static boolean checkContainDigit(String password) {
+        char[] chPass = password.toCharArray();
+        boolean flag = false;
+        int num_count = 0;
+
+        for (int i = 0; i < chPass.length; i++) {
+            if (Character.isDigit(chPass[i])) {
+                num_count++;
+            }
+        }
+        if (num_count >= 1) {
+            flag = true;
+        }
+        return flag;
+    }
+
+    /**
+     * 检查密码中是否包含字母(不区分大小写)
+     *
+     * @param password
+     * @return 包含字母 返回true
+     */
+    public static boolean checkContainCase(String password) {
+        char[] chPass = password.toCharArray();
+        boolean flag = false;
+        int char_count = 0;
+
+        for (int i = 0; i < chPass.length; i++) {
+            if (Character.isLetter(chPass[i])) {
+                char_count++;
+            }
+        }
+
+        if (char_count >= 1) {
+            flag = true;
+        }
+
+        return flag;
+    }
+
+    /**
+     * 检查密码中是否包含小写字母
+     *
+     * @param password
+     * @return 包含小写字母 返回true
+     */
+    public static boolean checkContainLowerCase(String password) {
+        boolean flag = false;
+        char[] chPass = password.toCharArray();
+        int char_count = 0;
+
+        for (int i = 0; i < chPass.length; i++) {
+            if (Character.isLowerCase(chPass[i])) {
+                char_count++;
+            }
+        }
+
+        if (char_count >= 1) {
+            flag = true;
+        }
+
+        return flag;
+    }
+
+    /**
+     * 检查密码中是否包含大写字母
+     *
+     * @param password
+     * @return 包含大写字母 返回true
+     */
+    public static boolean checkContainUpperCase(String password) {
+        boolean flag = false;
+        char[] chPass = password.toCharArray();
+        int char_count = 0;
+
+        for (int i = 0; i < chPass.length; i++) {
+            if (Character.isUpperCase(chPass[i])) {
+                char_count++;
+            }
+        }
+
+        if (char_count >= 1) {
+            flag = true;
+        }
+
+        return flag;
+    }
+
+    /**
+     * 检查密码中是否包含特殊字符
+     *
+     * @param password
+     * @return 包含特殊字符 返回true
+     */
+    public static boolean checkContainSpecialChar(String password) {
+        boolean flag = false;
+        char[] chPass = password.toCharArray();
+        int special_count = 0;
+
+        for (int i = 0; i < chPass.length; i++) {
+            if (PasswordCheckConf.CHECK_CONTAIN_SPECIAL_CHAR.indexOf(chPass[i]) != -1) {
+                special_count++;
+            }
+        }
+
+        if (special_count >= 1) {
+            flag = true;
+        }
+
+        return flag;
+    }
+
+    /**
+     * 键盘规则匹配器 横向连续检测
+     *
+     * @param password
+     * @return 含有横向连续字符串 返回true
+     */
+    public static boolean checkLateralKeyboardSite(String password) {
+
+        String t_password = new String(password);
+        // 将字符串内所有字符转为小写
+        t_password = t_password.toLowerCase();
+        int n = t_password.length();
+
+        /**
+         * 键盘横向规则检测
+         */
+        boolean flag = false;
+        int arrLen = PasswordCheckConf.KEYBOARD_HORIZONTAL_ARR.length;
+        int limit_num = Integer.parseInt(PasswordCheckConf.LIMIT_HORIZONTAL_NUM_KEY);
+
+        for (int i = 0; i + limit_num <= n; i++) {
+            String str = t_password.substring(i, i + limit_num);
+            String distinguishStr = password.substring(i, i + limit_num);
+
+            for (int j = 0; j < arrLen; j++) {
+                String configStr = PasswordCheckConf.KEYBOARD_HORIZONTAL_ARR[j];
+                String revOrderStr = new StringBuffer(PasswordCheckConf.KEYBOARD_HORIZONTAL_ARR[j]).reverse()
+                        .toString();
+
+                // 检查包含字母(区分大小写)
+                if ("enable".equals(PasswordCheckConf.CHECK_DISTINGGUISH_CASE)) {
+                    // 考虑 大写键盘匹配的情况
+                    String upperStr = PasswordCheckConf.KEYBOARD_HORIZONTAL_ARR[j].toUpperCase();
+                    if ((configStr.indexOf(distinguishStr) != -1) || (upperStr.indexOf(distinguishStr) != -1)) {
+                        flag = true;
+                        return flag;
+                    }
+                    // 考虑逆序输入情况下 连续输入
+                    String revUpperStr = new StringBuffer(upperStr).reverse().toString();
+                    if ((revOrderStr.indexOf(distinguishStr) != -1) || (revUpperStr.indexOf(distinguishStr) != -1)) {
+                        flag = true;
+                        return flag;
+                    }
+                } else {
+                    if (configStr.indexOf(str) != -1) {
+                        flag = true;
+                        return flag;
+                    }
+                    // 考虑逆序输入情况下 连续输入
+                    if (revOrderStr.indexOf(str) != -1) {
+                        flag = true;
+                        return flag;
+                    }
+                }
+            }
+        }
+        return flag;
+    }
+
+    /**
+     * 键盘规则匹配器 斜向规则检测
+     *
+     * @param password
+     * @return 含有斜向连续字符串 返回true
+     */
+    public static boolean checkKeyboardSlantSite(String password) {
+        String t_password = new String(password);
+        t_password = t_password.toLowerCase();
+        int n = t_password.length();
+        /**
+         * 键盘斜线方向规则检测
+         */
+        boolean flag = false;
+        int arrLen = PasswordCheckConf.KEYBOARD_SLOPE_ARR.length;
+        int limit_num = Integer.parseInt(PasswordCheckConf.LIMIT_SLOPE_NUM_KEY);
+
+        for (int i = 0; i + limit_num <= n; i++) {
+            String str = t_password.substring(i, i + limit_num);
+            String distinguishStr = password.substring(i, i + limit_num);
+            for (int j = 0; j < arrLen; j++) {
+                String configStr = PasswordCheckConf.KEYBOARD_SLOPE_ARR[j];
+                String revOrderStr = new StringBuffer(PasswordCheckConf.KEYBOARD_SLOPE_ARR[j]).reverse().toString();
+                // 检测包含字母(区分大小写)
+                if ("enable".equals(PasswordCheckConf.CHECK_DISTINGGUISH_CASE)) {
+
+                    // 考虑 大写键盘匹配的情况
+                    String UpperStr = PasswordCheckConf.KEYBOARD_SLOPE_ARR[j].toUpperCase();
+                    if ((configStr.indexOf(distinguishStr) != -1) || (UpperStr.indexOf(distinguishStr) != -1)) {
+                        flag = true;
+                        return flag;
+                    }
+                    // 考虑逆序输入情况下 连续输入
+                    String revUpperStr = new StringBuffer(UpperStr).reverse().toString();
+                    if ((revOrderStr.indexOf(distinguishStr) != -1) || (revUpperStr.indexOf(distinguishStr) != -1)) {
+                        flag = true;
+                        return flag;
+                    }
+                } else {
+                    if (configStr.indexOf(str) != -1) {
+                        flag = true;
+                        return flag;
+                    }
+                    // 考虑逆序输入情况下 连续输入
+                    if (revOrderStr.indexOf(str) != -1) {
+                        flag = true;
+                        return flag;
+                    }
+                }
+            }
+        }
+        return flag;
+    }
+
+    /**
+     * 评估a-z,z-a这样的连续字符
+     *
+     * @param password
+     * @return 含有a-z,z-a连续字符串 返回true
+     */
+    public static boolean checkSequentialChars(String password) {
+        String t_password = new String(password);
+        boolean flag = false;
+        int limit_num = Integer.parseInt(PasswordCheckConf.LIMIT_LOGIC_NUM_CHAR);
+        int normal_count = 0;
+        int reversed_count = 0;
+
+        // 检测包含字母(区分大小写)
+        if ("enable".equals(PasswordCheckConf.CHECK_DISTINGGUISH_CASE)) {
+
+        } else {
+            t_password = t_password.toLowerCase();
+        }
+        int n = t_password.length();
+        char[] pwdCharArr = t_password.toCharArray();
+
+        for (int i = 0; i + limit_num <= n; i++) {
+            normal_count = 0;
+            reversed_count = 0;
+            for (int j = 0; j < limit_num - 1; j++) {
+                if (pwdCharArr[i + j + 1] - pwdCharArr[i + j] == 1) {
+                    normal_count++;
+                    if (normal_count == limit_num - 1) {
+                        return true;
+                    }
+                }
+
+                if (pwdCharArr[i + j] - pwdCharArr[i + j + 1] == 1) {
+                    reversed_count++;
+                    if (reversed_count == limit_num - 1) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return flag;
+    }
+
+    /**
+     * 评估aaaa, 1111这样的相同连续字符
+     *
+     * @param password
+     * @return 含有aaaa, 1111等连续字符串 返回true
+     */
+    public static boolean checkSequentialSameChars(String password) {
+        String t_password = new String(password);
+        int n = t_password.length();
+        char[] pwdCharArr = t_password.toCharArray();
+        boolean flag = false;
+        int limit_num = Integer.parseInt(PasswordCheckConf.LIMIT_NUM_SAME_CHAR);
+        int count = 0;
+        for (int i = 0; i + limit_num <= n; i++) {
+            count = 0;
+            for (int j = 0; j < limit_num - 1; j++) {
+                if (pwdCharArr[i + j] == pwdCharArr[i + j + 1]) {
+                    count++;
+                    if (count == limit_num - 1) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return flag;
+    }
+
+    /**
+     * 检测常用词库
+     *
+     * @param password
+     * @return 含有常见词库 返回true
+     */
+    public static boolean checkSimpleWord(String password) {
+        List<String> simpleWords = Arrays.asList(PasswordCheckConf.SIMPLE_WORDS);
+        return simpleWords.contains(password.toLowerCase());
+    }
+
+    /**
+     * 评估密码中包含的字符类型是否符合要求
+     *
+     * @param password
+     * @return 符合要求 返回true
+     */
+    public static boolean evalPassword(String password) {
+        if (password == null || "".equals(password)) {
+            return false;
+        }
+        boolean flag = false;
+
+        /**
+         * 检测长度
+         */
+        if ("enable".equals(PasswordCheckConf.CHECK_PASSWORD_LENGTH)) {
+            flag = checkPasswordLength(password);
+            if (!flag) {
+                return false;
+            }
+        }
+
+        /**
+         * 检测包含数字
+         */
+//        if ("enable".equals(PasswordCheckConf.CHECK_CONTAIN_DIGIT)) {
+//            flag = checkContainDigit(password);
+//            if (!flag) {
+//                return false;
+//            }
+//        }
+
+        /**
+         * 检测包含字母
+         */
+//        if ("enable".equals(PasswordCheckConf.CHECK_CONTAIN_CASE)) {
+//            flag = checkContainCase(password);
+//            if (!flag) {
+//                return false;
+//            }
+//        }
+
+        /**
+         * 检测字母区分大小写
+         */
+//        if ("enable".equals(PasswordCheckConf.CHECK_DISTINGGUISH_CASE)) {
+//            // 检测包含小写字母
+//            if ("enable".equals(PasswordCheckConf.CHECK_LOWER_CASE)) {
+//                flag = checkContainLowerCase(password);
+//                if (!flag) {
+//                    return false;
+//                }
+//            }
+//
+//            // 检测包含大写字母
+//            if ("enable".equals(PasswordCheckConf.CHECK_UPPER_CASE)) {
+//                flag = checkContainUpperCase(password);
+//                if (!flag) {
+//                    return false;
+//                }
+//            }
+//        }
+
+        /**
+         * 检测包含特殊符号
+         */
+//        if ("enable".equals(PasswordCheckConf.CHECK_CONTAIN_SPECIAL_CHAR)) {
+//            flag = checkContainSpecialChar(password);
+//            if (!flag) {
+//                return false;
+//            }
+//        }
+
+        /**
+         * 检测键盘横向连续
+         */
+//        if ("enable".equals(PasswordCheckConf.CHECK_HORIZONTAL_KEY_SEQUENTIAL)) {
+//            flag = checkLateralKeyboardSite(password);
+//            if (flag) {
+//                return false;
+//            }
+//        }
+
+        /**
+         * 检测键盘斜向连续
+         */
+//        if ("enable".equals(PasswordCheckConf.CHECK_SLOPE_KEY_SEQUENTIAL)) {
+//            flag = checkKeyboardSlantSite(password);
+//            if (flag) {
+//                return false;
+//            }
+//        }
+
+        /**
+         * 检测逻辑位置连续
+         */
+        if ("enable".equals(PasswordCheckConf.CHECK_LOGIC_SEQUENTIAL)) {
+            flag = checkSequentialChars(password);
+            if (flag) {
+                return false;
+            }
+        }
+
+        /**
+         * 检测相邻字符是否相同
+         */
+        if ("enable".equals(PasswordCheckConf.CHECK_SEQUENTIAL_CHAR_SAME)) {
+            flag = checkSequentialSameChars(password);
+            if (flag) {
+                return false;
+            }
+        }
+
+        /**
+         * 检测常用词库
+         */
+//        if ("enable".equals(PasswordCheckConf.CHECK_SIMPLE_WORD)) {
+//            flag = checkSimpleWord(password);
+//            if (flag) {
+//                return false;
+//            }
+//        }
+
+        return true;
+    }
+
+}