• Home
• group.rober
• rober-dataform
• 2.1.8
• source code
• DataFormValidateUtils.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

group.rober.dataform.util.DataFormValidateUtils Maven / Gradle / Ivy

package group.rober.dataform.util;

import group.rober.dataform.exception.DataFormException;
import group.rober.dataform.exception.ValidatorException;
import group.rober.dataform.handler.DataObjectHandler;
import group.rober.dataform.model.DataForm;
import group.rober.dataform.model.DataFormElement;
import group.rober.dataform.model.types.ElementValidatorMode;
import group.rober.dataform.model.types.ElementValidatorRunAt;
import group.rober.dataform.validator.ValidateRecord;
import group.rober.dataform.validator.ValidateResult;
import group.rober.dataform.validator.ValidateType;
import group.rober.runtime.holder.MessageHolder;
import group.rober.runtime.kit.BeanKit;
import group.rober.runtime.kit.ClassKit;
import group.rober.runtime.kit.StringKit;
import group.rober.runtime.lang.MapData;
import group.rober.runtime.lang.ValueObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.regex.Pattern;

/**
 * 校验实现功能，单独放到一个类中来
 */
public class DataFormValidateUtils {
    protected static Logger logger = LoggerFactory.getLogger(DataFormValidateUtils.class);

    public static ValidateResult validateOne(DataForm dataForm, DataObjectHandler dataFormHandler, Object dataOne) {
        ValidateResult vr = new ValidateResult();

        Object entity = dataOne;
        List elements = dataForm.getElements();
        for (DataFormElement element : elements) {
            //检查必输项
            validateRequired(vr, element, entity);
            //根据规则作检查
            validateByRules(vr, dataFormHandler, element, entity);
        }

        return vr;
    }

    public static  List validateList(DataForm dataForm, DataObjectHandler dataFormHandler, List dataList) {
        List vrList = new ArrayList(dataList.size());
        //每行列表都必需初始化一个校验结果
        for (int i = 0; i < dataList.size(); i++) {
            vrList.add(new ValidateResult());
        }

        //处理每一行校验
        for (int i = 0; i < dataList.size(); i++) {
            ValidateResult vrItem = vrList.get(i);
            List elements = dataForm.getElements();
            for (DataFormElement element : elements) {
                //检查必输项
                validateRequired(vrItem, element, dataList.get(i));
                //根据规则作检查
                validateListByRules(vrItem,dataFormHandler,element,dataList.get(i),dataList);
            }

        }

        return vrList;
    }


    /**
     * 必输项检查
     *
     * @param validateResult validateResult
     * @param element element
     * @param entity entity
     */
    private static  void validateRequired(ValidateResult validateResult, DataFormElement element, T entity) {
        if (element.getElementUIHint().getRequired()) {
            ValueObject vo = BeanKit.getPropertyValueObject(entity, element.getCode());
            if (vo.isBlank()) {
                String errorText = MessageHolder.getMessage("此项必填", "dataform.validate.required");

                ValidateRecord vRecord = new ValidateRecord();
                vRecord.setMandatory(true)
                        .setPassed(false)
                        .setValidateType(ValidateType.Required)
                        .setMessage(errorText);
                validateResult.addRecord(element.getCode(), vRecord);
            }
        }
    }

    /**
     * 校验列表对象
     *
     * @param validateResult validateResult
     * @param dataFormHandler dataFormHandler
     * @param element element
     * @param object object
     * @param dataList dataList
     */
    public static  void validateListByRules(ValidateResult validateResult, DataObjectHandler dataFormHandler
            , DataFormElement element, T object, List dataList) {
        /**
         * 构建校验器，执行单个bean这一类的校验
         */
        ValidateByRuleTemplate ruleTemplate = new ValidateByRuleTemplate(validateResult,dataFormHandler,element){
            public void validateByHandler(String methodName, Object v, T object, List objectList) {
                String methodFullName = dataFormHandler.getClass().getName() + "." + methodName;
                try {
//                    Method method = dataFormHandler.getClass().getMethod(methodName, v.getClass(), object.getClass(),objectList.getClass());
                    Method method = ClassKit.getMethod(dataFormHandler.getClass(),methodName);
                    if(method == null){
                        throw new DataFormException(methodFullName + "方法不存在!");
                    }
                    method.invoke(dataFormHandler, v, object,objectList);
                } catch (IllegalAccessException e) {
                    throw new DataFormException(methodFullName + "方法调用出错，请检查参数(第一个是值，第二个是对象,第三个是列表)");
                } catch (InvocationTargetException e) {
                    //校验方法抛出校验异常了，则截取下来，并且返回
                    parseException(validateResult,element,e);
                }
            }
        };
        ruleTemplate.exec(object,dataList);
    }

    /**
     * 根据正则表达式，handler上配置的方法进行校验（校验单个对象）
     *
     * @param validateResult validateResult
     * @param dataFormHandler dataFormHandler
     * @param element element
     * @param object object
     */
    private static void validateByRules(ValidateResult validateResult, DataObjectHandler dataFormHandler, DataFormElement element, Object object) {
        /**
         * 构建校验器，执行单个bean这一类的校验
         */
        ValidateByRuleTemplate