增加密码复杂度校验

kongzy

2024-10-25 e6f72c636a956f2347dee6edfd5cb6f90daeb646

增加密码复杂度校验

 src/main/java/com/ruoyi/common/utils/RegexUtil.java

对比新文件
@@ -0,0 +1,62 @@
package com.ruoyi.common.utils;

import java.util.regex.Pattern;

/**
 * @author lyf_
 */
public class RegexUtil {

    private static final String REGEX_MOBILE = "^((13[0-9])|(14[579])|(15([0-3]|[5-9]))|(16[56])|(17[0-8])|(18[0-9])|(19[1589]))\\d{8}$";

    private static final String REGEX_EMAIL = "^([a-z0-9A-Z]+[-|\\.]?)+[a-z0-9A-Z]@([a-z0-9A-Z]+(-[a-z0-9A-Z]+)?\\.)+[a-zA-Z]{2,}$";

    private static final String REGEX_PASSWORD = "^(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z]).{10,}$";

    /**
     * 手机号校验 pattern
     * */
    private static final Pattern PATTERN_REGEX_MOBILE = Pattern.compile(REGEX_MOBILE, Pattern.CASE_INSENSITIVE);

    /**
     * 邮箱校验 pattern
     * */
    private static final Pattern PATTERN_REGEX_EMAIL = Pattern.compile(REGEX_EMAIL, Pattern.CASE_INSENSITIVE);

    /**
     * 密码校验 pattern
     * */
    private static final Pattern PATTERN_REGEX_PASSWORD = Pattern.compile(REGEX_PASSWORD, Pattern.CASE_INSENSITIVE);



    /**
     * 手机号码正则
     * @param phone 手机号
     * @return 是否匹配
     */
    public static boolean isMobile(String phone) {
        return PATTERN_REGEX_MOBILE.matcher(phone).matches();
    }

    /**
     * 邮箱正则
     * @param email 邮箱
     * @return 是否匹配
     */
    public static boolean isEmail(String email) {
        return PATTERN_REGEX_EMAIL.matcher(email).matches();
    }


    /**
     * 密码正则匹配
     * @param password 密码
     * @return 是否匹配
     */
    public static Boolean isPassword(String password) {
        return PATTERN_REGEX_PASSWORD.matcher(password).matches();
    }


}

 src/main/java/com/ruoyi/doublePrevention/scheduls/ExecCJReportDateSchedule.java

@@ -592,7 +592,7 @@
            StringBuffer recordFromTaskResultBuffer = null;
            //上报数据
            try {
               // URL url = new URL("http://120.71.182.198:9999/v1/data/receive/measuresTaskRecordMsg");
              //  URL url = new URL("http://120.71.182.198:9999/v1/data/receive/measuresTaskRecordMsg");
                URL url = new URL("https://cjzjg.gtaq.com.cn:7004/v1/data/receive/measuresTaskRecordMsg");  //备用地址
                //得到连接对象
                con = (HttpURLConnection) url.openConnection();

 src/main/java/com/ruoyi/doublePrevention/scheduls/SearchReportDateSchedule.java

@@ -1,6 +1,7 @@
package com.ruoyi.doublePrevention.scheduls;


import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.doublePrevention.entity.*;
import com.ruoyi.doublePrevention.entity.CJReport.*;
import com.ruoyi.doublePrevention.enums.E;
@@ -20,6 +21,7 @@
import com.ruoyi.project.tr.hiddenDangerCheckPoint.service.IHiddenDangerCheckPointService;
import com.ruoyi.project.tr.riskList.domain.RiskList;
import com.ruoyi.project.tr.riskList.service.IRiskListService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.ObjectUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -31,10 +33,10 @@
import java.text.SimpleDateFormat;
import java.util.*;

@Slf4j
@Component
public class SearchReportDateSchedule {

    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    public static SimpleDateFormat startFormat = new SimpleDateFormat("yyyy-MM-dd 06:30:00");
    public static SimpleDateFormat endFormat = new SimpleDateFormat("yyyy-MM-dd 23:59:59");
@@ -107,12 +109,12 @@


    @Transactional
    @Scheduled(cron = "0 0/10 * * * ? ")    // 分钟
    @Scheduled(cron = "0 0/2 * * * ? ")    // 分钟
//    @Scheduled(cron = "0/10 * * * * ?")  // 30秒
 //   @Scheduled(cron = "0 0/25 * * * ? ")    // 分钟
    public void searchReportDate(){

        logger.info("【双重预防】定时检索需要上报数据...");
        log.info("【双重预防】定时检索需要上报数据...");
        int step = 1;
        String companyCode = "652310082";

@@ -124,7 +126,7 @@
        //如果主配置开启上报，开始
        if (unitReportConfig.getReportState().equals(SyncEnum.REPORT_ON.getCode())){

            logger.info("【##】1.检索风险分析单元...");
            log.info("【##】1.检索风险分析单元...");

            //查询所有 选择上报的数据 && (reportTime == null 或者 reportTime < updateReportDataTime）
            List<PreventRiskUnitUuid> riskUnitUuidList = preventRiskUnitUuidService.listRiskAnaUnit();
@@ -181,17 +183,17 @@
                    int result = preventRiskUnitUuidService.updateReportStatus(handlerReportParam);
                }
            }else {
                logger.info("【双重预防】当前无风险分析单元数据需要处理");
                log.info("【双重预防】当前无风险分析单元数据需要处理");
            }
            //写入昌吉州转换表
            for (PreventCJReportRiskAnaUnit CJUnit : CJUnitLists) {
                CJRiskAnaUnitService.insertUnitList(CJUnit);
                logger.info("【双重预防】1.风险分析单元CJ：数据处理...");
                log.info("【双重预防】1.风险分析单元CJ：数据处理...");
            }
            step = 2;
        }else {
            step = 2;
            logger.info("风险分析单元数据上报已关闭");
            log.info("风险分析单元数据上报已关闭");
        }


@@ -242,17 +244,17 @@
                    preventRiskEventService.updateEventReportStatus(handlerReportParam);
                }
            }else {
                logger.info("【双重预防】当前无安全风险事件数据需要处理");
                log.info("【双重预防】当前无安全风险事件数据需要处理");
            }
            //写入昌吉州转换表
            for (PreventCJReportRiskEvent CJEvent : CJEventLists) {
                CJEventService.insertEventLists(CJEvent);
                logger.info("【双重预防】2.风险分析事件CJ：数据处理...");
                log.info("【双重预防】2.风险分析事件CJ：数据处理...");
            }
            step = 3;
        }else {
            step = 3;
            logger.info("安全风险事件数据上报已关闭");
            log.info("安全风险事件数据上报已关闭");
        }


@@ -315,7 +317,7 @@
                    preventRiskControlMeasureService.updateMeasureReportStatus(handlerReportParam);
                }
            }else {
                logger.info("【双重预防】当前无安全风险管控措施数据需要处理");
                log.info("【双重预防】当前无安全风险管控措施数据需要处理");
            }

            step = 4;
@@ -324,11 +326,11 @@
            for (PreventCJReportRiskControlMeasure CJMeasure : CJMeasureLists) {
                CJMeasureService.insertMeasureList(CJMeasure);

                logger.info("【双重预防】3.安全风险管控措施CJ：数据处理...");
                log.info("【双重预防】3.安全风险管控措施CJ：数据处理...");
            }
        }else {
            step = 4;
            logger.info("安全风险管控措施数据上报已关闭");
            log.info("安全风险管控措施数据上报已关闭");
        }

        /**
@@ -344,7 +346,7 @@
            //获取上报数据对象与list
            List<PreventCJReportCheckTaskFromWork> CJTaskFromWorkLists = new ArrayList<>();
            HandlerReportParam handlerReportParam = new HandlerReportParam();

            log.info("检索任务配置开始执行,{}",works.size());
            if (ObjectUtils.isNotEmpty(works)){
                //遍历，封装数据
                for (PreventRiskJobAndMeasure work : works) {
@@ -433,16 +435,17 @@
                    preventRiskJobAndMeasureService.updateWorkReportStatus(handlerReportParam);
                }
            }else {
                logger.info("【双重预防】当前无任务配置数据需要处理");
                log.info("【双重预防】当前无任务配置数据需要处理");
            }
            //写入上报昌吉州数据转换表
            log.info("【双重预防】任务配置CJ数量:{}",CJTaskFromWorkLists.size());
            for (PreventCJReportCheckTaskFromWork CJTaskFromWorks : CJTaskFromWorkLists) {
                CJTaskFromWorkService.insertTaskFromWorkList(CJTaskFromWorks);
                logger.info("【双重预防】任务配置CJ：数据处理...");
                log.info("【双重预防】任务配置CJ：数据处理...");
            }
        }else {
            step = 5;
            logger.info("任务配置数据上报已关闭");
            log.info("任务配置数据上报已关闭");
        }


@@ -482,7 +485,7 @@

                        //避免个别任务无检查点的情况
                        if (ObjectUtils.isEmpty(hiddenDangerCheckPointList)) {
                            logger.info("【双重预防】排查任务记录CJ：异常，无检查点...");
                            log.info("【双重预防】排查任务记录CJ：异常，无检查点...");
                        }else {
                            for (HiddenDangerCheckPoint hiddenDangerCheckPoint : hiddenDangerCheckPointList) {
                                //获取上报数据对象
@@ -557,15 +560,27 @@
//                                PreventCJReportCheckTaskFromWork preventCJReportCheckTaskFromWork = CJTaskFromWorkService.geByMeasureUUidAndJobId(preventRiskControlMeasureById.getUuid(), task.getJobId());
//                                CJRecordFromTask.setCheckTaskId(preventCJReportCheckTaskFromWork.getId());
                                // todo 取出所有措施，再循环在匹配
                                boolean checkTaskIdExist=true;
                                for (PreventRiskControlMeasure measure : allMeasureList) {
                                    if (controlMeasureId.equals(measure.getId())){
                                        //通过管控措施uuid ，jobId(workId)，在任务上报表中，找到任务对应的uuid

                                        PreventCJReportCheckTaskFromWork preventCJReportCheckTaskFromWork = CJTaskFromWorkService.geByMeasureUUidAndJobId(measure.getUuid(), task.getJobId());
                                        CJRecordFromTask.setCheckTaskId(preventCJReportCheckTaskFromWork.getId());
                                        try {
                                            //  if(preventCJReportCheckTaskFromWork!=null) {
                                            CJRecordFromTask.setCheckTaskId(preventCJReportCheckTaskFromWork.getId());
                                            //}
                                        }catch (Exception e){
                                            checkTaskIdExist=false;
                                            log.info("chekcPointId={},PreventRiskDangerCheckLogId={},controlMeasureId={},measure uuid={},jobId={}",hiddenDangerCheckPoint.getId(),task.getId(),controlMeasureId,measure.getUuid(),task.getJobId());
                                            log.error(e.getMessage());
                                        }
                                    }
                                }


                                if(!checkTaskIdExist){
                                    continue;
                                }
                                CJRecordFromTask.setCheckTime(hiddenDangerCheckById.getCheckTime());
                                CJRecordFromTask.setTaskId(task.getCheckId());
                                //第二版标准新增
@@ -609,11 +624,11 @@

                }
            }else {
                logger.info("【双重预防】当前无排查任务记录需要处理");
                log.info("【双重预防】当前无排查任务记录需要处理");
            }

            if (CJRecordFromTaskLists.size() > 0){
                logger.info("【双重预防】排查任务记录CJ：数据处理...");
                log.info("【双重预防】排查任务记录CJ：数据处理...");
                //设置原始数据状态
                int taskUpdateResult = preventRiskDangerCheckLogService.updateTaskReportStatusByList(taskIds);
                if (taskUpdateResult < taskIds.size()){
@@ -627,7 +642,7 @@
            step = 6;
        }else {
            step = 6;
            logger.info("排查任务记录数据上报已关闭");
            log.info("排查任务记录数据上报已关闭");
        }


@@ -677,7 +692,18 @@
                        User rectifyUser = trUserService.getUserByLoginName(hiddenDanger.getRectifyUserName());
                        //整改人信息
                        CJDangerInfo.setLiablePerson(rectifyUser.getUserName());//整改责任人
                        CJDangerInfo.setCost(hiddenDanger.getRectifyFund());//资金
                        if(!StringUtils.isEmpty(hiddenDanger.getRectifyFund())){
                            String REGEX_CHINESE = "[\u4e00-\u9fa5]";// 中文正则
                            String cost=hiddenDanger.getRectifyFund().replaceAll(REGEX_CHINESE,"").trim();
                            if(StringUtils.isEmpty(cost)){
                                CJDangerInfo.setCost(null);//资金
                            }else{
                                CJDangerInfo.setCost(cost);//资金
                            }
                        }else{
                            CJDangerInfo.setCost(null);//资金
                        }

                    }

                    if (ObjectUtils.isNotEmpty(hiddenDanger.getAcceptUserName())){
@@ -755,20 +781,20 @@
                    preventRiskDangerInfoService.updateDangerInfoReportStatus(handlerReportParam);
                }
            }else {
                logger.info("【双重预防】当前无隐患信息需要处理");
                log.info("【双重预防】当前无隐患信息需要处理");
            }

            //插入上报昌吉州转换表
            for (PreventCJReportDangerInfo CJDanger : CJDangerInfoLists) {
                logger.info("【双重预防】隐患信息插入...");
                log.info("【双重预防】隐患信息插入...");
                int result = CJDangerInfoService.insert(CJDanger);
                if (result < 0){
                    throw new AusinessException(E.ADD_FAIL.getCode(), "隐患信息插入失败");
                }
                logger.info("【双重预防】隐患信息：数据处理...");
                log.info("【双重预防】隐患信息：数据处理...");
            }
        }else {
            logger.info("隐患信息数据上报已关闭");
            log.info("隐患信息数据上报已关闭");
        }



 src/main/java/com/ruoyi/project/mobile/service/ApiSystemService.java

@@ -4,8 +4,10 @@
import com.fasterxml.jackson.databind.ObjectMapper;
import com.github.pagehelper.util.StringUtil;
import com.ruoyi.common.constant.Constants;
import com.ruoyi.common.exception.BusinessException;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.MessageUtils;
import com.ruoyi.common.utils.RegexUtil;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.framework.manager.AsyncManager;
import com.ruoyi.framework.manager.factory.AsyncFactory;
@@ -274,6 +276,12 @@
            Map<String, String> parameters = new ObjectMapper().readValue(str, HashMap.class);
            String oldPassword = parameters.get("oldPassword");//旧密码
            String newPassword = parameters.get("newPassword");//新密码
            if(StringUtils.isEmpty(newPassword)){
                return ApiResult.error("新密码不能为空");
            }
            if(!RegexUtil.isPassword(newPassword)){
                return ApiResult.error("密码无效。密码必须包含至少一个大写字母、一个小写字母和一个数字，并且至少10个字符长。");
            }
            User user = userService.selectUserById(Long.valueOf(header.userId));
            if (StringUtils.isNotEmpty(oldPassword)) {
                if (StringUtils.isNotEmpty(newPassword)) {

 src/main/java/com/ruoyi/project/system/user/service/UserServiceImpl.java

@@ -2,6 +2,7 @@

import com.ruoyi.common.constant.UserConstants;
import com.ruoyi.common.exception.BusinessException;
import com.ruoyi.common.utils.RegexUtil;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.utils.security.ShiroUtils;
import com.ruoyi.common.utils.text.Convert;
@@ -220,6 +221,12 @@
    @Override
    @Transactional
    public int insertUser(User user) {
        if(StringUtils.isEmpty(user.getPassword())){
            throw new BusinessException("密码不能为空");
        }
        if(!RegexUtil.isPassword(user.getPassword())){
            throw new BusinessException("密码无效。密码必须包含至少一个大写字母、一个小写字母和一个数字，并且至少10个字符长。");
        }
        user.randomSalt();
        user.setPassword(passwordService.encryptPassword(user.getLoginName(), user.getPassword(), user.getSalt()));
        user.setCreateBy(ShiroUtils.getLoginName());
@@ -299,6 +306,12 @@
     */
    @Override
    public int resetUserPwd(User user) {
        if(StringUtils.isEmpty(user.getPassword())){
            throw new BusinessException("密码不能为空");
        }
        if(!RegexUtil.isPassword(user.getPassword())){
            throw new BusinessException("密码无效。密码必须包含至少一个大写字母、一个小写字母和一个数字，并且至少10个字符长。");
        }
        user.randomSalt();
        user.setPassword(passwordService.encryptPassword(user.getLoginName(), user.getPassword(), user.getSalt()));
        return updateUserInfo(user);

 src/main/resources/mybatis/doublePrevention/PreventCJReportCheckTaskFromWorkMapper.xml

@@ -102,7 +102,7 @@
<!--    PreventCJReportCheckTaskFromWork geByMeasureUUidAndJobId(String measureUuid, Long jobId);-->
    <select id="geByMeasureUUidAndJobId" resultMap="BaseResultMap">
        select * from prevent_cj_report_check_task_from_work
        where work_id = #{jobId} and risk_measure_id = #{measureUuid} and deleted = 0
        where work_id = #{jobId} and risk_measure_id = #{measureUuid} and deleted = 0 order by create_date desc limit 1
    </select>