ZhouXY108
/
plusone-admin
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request 'dev' (#1) from dev into master 

Reviewed-on: #1
main
ZhouXY108 2022-12-10 03:46:53 +08:00
parent cb07c0befd cc6e3a41c3
commit 2d02899372
13 changed files with 464 additions and 203 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
plusone-basic/plusone-basic-infrastructure/src/main/java/xyz/zhouxy/plusone/mybatis/MyBatisAutoConfiguration.java
View File

@ -1,17 +0,0 @@
package xyz.zhouxy.plusone.mybatis;
import org.apache.ibatis.session.SqlSessionFactory;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
@EnableAutoConfiguration
public class MyBatisAutoConfiguration {
@Bean
MybatisUtil mybatisUtil(SqlSessionFactory sqlSessionFactory) {
return MybatisUtil.getInstance()
.setSqlSessionFactory(sqlSessionFactory);
}
}

16
plusone-basic/plusone-basic-infrastructure/src/main/java/xyz/zhouxy/plusone/mybatis/MyBatisContextUtil.java 100644
View File

@ -0,0 +1,16 @@
package xyz.zhouxy.plusone.mybatis;
import org.apache.ibatis.session.SqlSessionFactory;
import xyz.zhouxy.plusone.spring.SpringContextHolder;
public final class MyBatisContextUtil {
private MyBatisContextUtil() {
throw new IllegalStateException("Utility class");
}
public static SqlSessionFactory getSqlSessionFactory() {
return SpringContextHolder.getContext().getBean(SqlSessionFactory.class);
}
}

2
plusone-basic/plusone-basic-infrastructure/src/main/java/xyz/zhouxy/plusone/mybatis/MyBatisPlusConfig.java
View File

@ -10,7 +10,7 @@ import org.springframework.context.annotation.Configuration;
@Configuration
public class MyBatisPlusConfig {
@Bean
public MybatisPlusInterceptor mybatisPlusInterceptor() {
MybatisPlusInterceptor mybatisPlusInterceptor() {
MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
interceptor.addInnerInterceptor(new BlockAttackInnerInterceptor());
interceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());

28
plusone-basic/plusone-basic-infrastructure/src/main/java/xyz/zhouxy/plusone/mybatis/MybatisUtil.java
View File

@ -1,28 +0,0 @@
package xyz.zhouxy.plusone.mybatis;
import org.apache.ibatis.session.SqlSessionFactory;
public final class MybatisUtil {
private SqlSessionFactory sqlSessionFactory;
private MybatisUtil() {
}
MybatisUtil setSqlSessionFactory(SqlSessionFactory sqlSessionFactory) {
this.sqlSessionFactory = sqlSessionFactory;
return this;
}
private static final class Holder {
private static final MybatisUtil INSTANCE = new MybatisUtil();
}
public static MybatisUtil getInstance() {
return Holder.INSTANCE;
}
public static SqlSessionFactory getSqlSessionFactory() {
return MybatisUtil.getInstance().sqlSessionFactory;
}
}

50
plusone-basic/plusone-basic-infrastructure/src/main/java/xyz/zhouxy/plusone/validator/BaseValidator.java
View File

@ -2,25 +2,31 @@ package xyz.zhouxy.plusone.validator;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
import xyz.zhouxy.plusone.exception.InvalidInputException;
/**
* 校验器
*
* <p>可以使用以下方式初始化一个校验器：</p>
* <p>
* 可以使用以下方式初始化一个校验器：
* </p>
*
* <pre>
* BaseValidator&lt;Integer&gt; validator = new BaseValidator&lt;&gt;() {
* {
* ruleFor(value -> Objects.nonNull(value), "value 不能为空");
* ruleFor(value -> (value >= 0 && value <= 500), "value 应在 [0, 500] 内");
* withRule(value -> Objects.nonNull(value), "value 不能为空");
* withRule(value -> (value >= 0 && value <= 500), "value 应在 [0, 500] 内");
* }
* };
* </pre>
*
* <p>也可以通过继承本类，定义一个校验器（可使用单例模式）。</p>
* <p>
* 也可以通过继承本类，定义一个校验器（可使用单例模式）。
* </p>
*
* <p>
* 然后通过校验器的 {@link #validate} 方法，或
@ -43,30 +49,40 @@ import xyz.zhouxy.plusone.exception.InvalidInputException;
*/
public abstract class BaseValidator<T> {
private final List<RuleInfo<T>> rules = new ArrayList<>();
private final List<RuleInfo<T, ?>> rules = new ArrayList<>();
protected BaseValidator() {
}
protected final void ruleFor(Predicate<T> rule, String errorMessage) {
this.rules.add(new RuleInfo<>(rule, errorMessage));
protected final void withRule(Predicate<T> rule, String errorMessage) {
withRule(rule, () -> new InvalidInputException(errorMessage));
}
protected final <E extends RuntimeException> void withRule(Predicate<T> rule, Supplier<E> exceptionCreator) {
withRule(rule, value -> exceptionCreator.get());
}
protected final <E extends RuntimeException> void withRule(Predicate<T> rule, Function<T, E> exceptionCreator) {
this.rules.add(new RuleInfo<>(rule, exceptionCreator));
}
public void validate(T obj) {
this.rules.forEach((RuleInfo<T> ruleInfo) -> {
if (!ruleInfo.rule.test(obj)) {
throw new InvalidInputException(ruleInfo.message);
}
});
this.rules.forEach(ruleInfo -> ruleInfo.validate(obj));
}
protected static class RuleInfo<T> {
Predicate<T> rule;
String message;
protected static class RuleInfo<T, E extends RuntimeException> {
private final Predicate<T> rule;
private final Function<T, E> exceptionCreator;
public RuleInfo(Predicate<T> rule, String message) {
private RuleInfo(Predicate<T> rule, Function<T, E> exceptionCreator) {
this.rule = rule;
this.message = message;
this.exceptionCreator = exceptionCreator;
}
private void validate(T obj) {
if (!rule.test(obj)) {
throw exceptionCreator.apply(obj);
}
}
}
}

129
plusone-basic/plusone-basic-infrastructure/src/main/java/xyz/zhouxy/plusone/validator/BaseValidator2.java
View File

@ -1,129 +0,0 @@
package xyz.zhouxy.plusone.validator;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Objects;
import java.util.function.Function;
import java.util.function.Predicate;
import cn.hutool.core.exceptions.ValidateException;
import lombok.AllArgsConstructor;
import xyz.zhouxy.plusone.constant.RegexConsts;
import xyz.zhouxy.plusone.util.RegexUtil;
public abstract class BaseValidator2<T> {
private List<ValidValueHolder<T, ?>> hs = new ArrayList<>();
protected final <R> ValidValueHolder<T, R> ruleFor(Function<T, R> getter) {
ValidValueHolder<T, R> validValueHolder = new ValidValueHolder<>(getter);
hs.add(validValueHolder);
return validValueHolder;
}
public void validate(T obj) {
for (var holder : hs) {
var value = holder.getter.apply(obj);
for (var rule : holder.rules) {
if (!rule.condition.test(value)) {
throw new ValidateException(rule.errMsg);
}
}
}
}
}
class ValidValueHolder<T, R> {
Function<T, R> getter;
List<RuleInfo<Object>> rules = new ArrayList<>();
public ValidValueHolder(Function<T, R> getter) {
this.getter = getter;
}
private void addRule(Predicate<Object> condition, String errMsg) {
this.rules.add(new RuleInfo<>(condition, errMsg));
}
public ValidValueHolder<T, R> nonNull(String errMsg) {
addRule(Objects::nonNull, errMsg);
return this;
}
public ValidValueHolder<T, R> nonEmpty(String errMsg) {
addRule(value -> {
if (value == null) {
return false;
}
if (value instanceof Collection) {
return ((Collection<?>) value).isEmpty();
}
if (value instanceof String) {
return ((String) value).isEmpty();
}
return false;
}, errMsg);
return this;
}
public ValidValueHolder<T, R> size(int min, int max, String errMsg) {
addRule(value -> {
if (value == null) {
return false;
}
if (value instanceof Collection) {
int size = ((Collection<?>) value).size();
return size >= min && size <= max;
}
return true;
}, errMsg);
return this;
}
public ValidValueHolder<T, R> length(int min, int max, String errMsg) {
addRule(value -> {
if (value == null) {
return false;
}
if (value instanceof String) {
int length = ((String) value).length();
return length >= min && length <= max;
}
return true;
}, errMsg);
return this;
}
public ValidValueHolder<T, R> matches(String regex, String errMsg) {
addRule(input -> RegexUtil.matches(regex, (String) input), errMsg);
return this;
}
public ValidValueHolder<T, R> matchesOr(String[] regexs, String errMsg) {
addRule(input -> RegexUtil.matchesOr((String) input, regexs), errMsg);
return this;
}
public ValidValueHolder<T, R> matchesAnd(String[] regexs, String errMsg) {
addRule(input -> RegexUtil.matchesAnd((String) input, regexs), errMsg);
return this;
}
public ValidValueHolder<T, R> email(String errMsg) {
return matches(RegexConsts.EMAIL, errMsg);
}
@SuppressWarnings("unchecked")
public ValidValueHolder<T, R> and(Predicate<R> condition, String errMsg) {
addRule((Predicate<Object>) condition, errMsg);
return this;
}
@AllArgsConstructor
static final class RuleInfo<R> {
Predicate<R> condition;
String errMsg;
}
}

2
plusone-basic/plusone-basic-infrastructure/src/main/java/xyz/zhouxy/plusone/validator/Validator.java
View File

@ -36,7 +36,7 @@ import java.util.function.Predicate;
*/
public final class Validator<T> extends BaseValidator<T> {
public final Validator<T> addRule(final Predicate<T> rule, final String errorMessage) {
ruleFor(rule, errorMessage);
withRule(rule, errorMessage);
return this;
}
}

22
plusone-basic/plusone-basic-infrastructure/src/main/java/xyz/zhouxy/plusone/validator/validator2/BaseValidator2.java 100644
View File

@ -0,0 +1,22 @@
package xyz.zhouxy.plusone.validator.validator2;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Function;
public abstract class BaseValidator2<T> {
private List<ValueValidator<T, ?>> valueValidators = new ArrayList<>();
protected final <R> ValueValidator<T, R> ruleFor(Function<T, R> getter) {
ValueValidator<T, R> validValueHolder = new ValueValidator<>(getter);
valueValidators.add(validValueHolder);
return validValueHolder;
}
public void validate(T obj) {
for (ValueValidator<T, ?> valueValidator : this.valueValidators) {
valueValidator.validateProperty(obj);
}
}
}

379
plusone-basic/plusone-basic-infrastructure/src/main/java/xyz/zhouxy/plusone/validator/validator2/ValueValidator.java 100644
View File

@ -0,0 +1,379 @@
package xyz.zhouxy.plusone.validator.validator2;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Objects;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
import cn.hutool.core.util.StrUtil;
import xyz.zhouxy.plusone.constant.RegexConsts;
import xyz.zhouxy.plusone.exception.InvalidInputException;
import xyz.zhouxy.plusone.util.RegexUtil;
public class ValueValidator<DTO, PROPERTY> {
Function<DTO, PROPERTY> getter;
List<Consumer<PROPERTY>> rules = new ArrayList<>();
public ValueValidator(Function<DTO, PROPERTY> getter) {
this.getter = getter;
}
private <E extends RuntimeException> void withRule(Predicate<PROPERTY> condition,
Function<PROPERTY, E> exceptionCreator) {
withRule(value -> {
if (!condition.test(value)) {
throw exceptionCreator.apply(value);
}
});
}
private <E extends RuntimeException> void withRule(Consumer<PROPERTY> rule) {
this.rules.add(rule);
}
// ====================
// ====== Object ======
// ====================
// ====== notNull =====
public ValueValidator<DTO, PROPERTY> notNull() {
return notNull("Value could not be null.");
}
public ValueValidator<DTO, PROPERTY> notNull(String errMsg) {
return notNull(convertExceptionCreator(errMsg));
}
public <E extends RuntimeException> ValueValidator<DTO, PROPERTY> notNull(Supplier<E> exceptionCreator) {
return notNull(convertExceptionCreator(exceptionCreator));
}
public <E extends RuntimeException> ValueValidator<DTO, PROPERTY> notNull(Function<PROPERTY, E> exceptionCreator) {
withRule(Objects::nonNull, exceptionCreator);
return this;
}
// ====== isNull =====
public ValueValidator<DTO, PROPERTY> isNull(String errMsg) {
return isNull(convertExceptionCreator(errMsg));
}
public <E extends RuntimeException> ValueValidator<DTO, PROPERTY> isNull(Supplier<E> exceptionCreator) {
return isNull(convertExceptionCreator(exceptionCreator));
}
public <E extends RuntimeException> ValueValidator<DTO, PROPERTY> isNull(Function<PROPERTY, E> exceptionCreator) {
withRule(Objects::isNull, exceptionCreator);
return this;
}
// ===== equals =====
public ValueValidator<DTO, PROPERTY> equalsThat(Object that) {
return equalsThat(that, value -> new InvalidInputException(String.format("(%s) 必须与 (%s) 相等", value, that)));
}
public ValueValidator<DTO, PROPERTY> equalsThat(Object that, String errMsg) {
return equalsThat(that, convertExceptionCreator(errMsg));
}
public <E extends RuntimeException> ValueValidator<DTO, PROPERTY> equalsThat(
Object that, Supplier<E> exceptionCreator) {
return equalsThat(that, convertExceptionCreator(exceptionCreator));
}
public <E extends RuntimeException> ValueValidator<DTO, PROPERTY> equalsThat(
Object that, Function<PROPERTY, E> exceptionCreator) {
withRule(value -> Objects.equals(value, that), exceptionCreator);
return this;
}
// ===== state =====
public ValueValidator<DTO, PROPERTY> state(Predicate<PROPERTY> condition) {
return state(condition, "无效的用户输入");
}
public ValueValidator<DTO, PROPERTY> state(Predicate<PROPERTY> condition, String errMsg) {
return state(condition, convertExceptionCreator(errMsg));
}
public <E extends RuntimeException> ValueValidator<DTO, PROPERTY> state(
Predicate<PROPERTY> condition,
Supplier<E> exceptionCreator) {
return state(condition, convertExceptionCreator(exceptionCreator));
}
public <E extends RuntimeException> ValueValidator<DTO, PROPERTY> state(
Predicate<PROPERTY> condition,
Function<PROPERTY, E> exceptionCreator) {
withRule(condition, exceptionCreator);
return this;
}
// =================
// ====== int ======
// =================
public ValueValidator<DTO, PROPERTY> between(int min, int max) {
return between(min, max, String.format("数值不在 %s 和 %s 之间", String.valueOf(min), String.valueOf(max)));
}
public ValueValidator<DTO, PROPERTY> between(int min, int max, String errMsg) {
return between(min, max, convertExceptionCreator(errMsg));
}
public <E extends RuntimeException> ValueValidator<DTO, PROPERTY> between(int min, int max,
Supplier<E> exceptionCreator) {
return between(min, max, convertExceptionCreator(exceptionCreator));
}
public <E extends RuntimeException> ValueValidator<DTO, PROPERTY> between(int min, int max,
Function<PROPERTY, E> exceptionCreator) {
withRule(value -> ((int) value >= min && (int) value < max), exceptionCreator);
return this;
}
// ====================
// ====== double ======
// ====================
public ValueValidator<DTO, PROPERTY> between(double min, double max) {
return between(min, max, String.format("数值不在 %s 和 %s 之间", String.valueOf(min), String.valueOf(max)));
}
public ValueValidator<DTO, PROPERTY> between(double min, double max, String errMsg) {
return between(min, max, convertExceptionCreator(errMsg));
}
public <E extends RuntimeException> ValueValidator<DTO, PROPERTY> between(double min, double max,
Supplier<E> exceptionCreator) {
return between(min, max, convertExceptionCreator(exceptionCreator));
}
public <E extends RuntimeException> ValueValidator<DTO, PROPERTY> between(double min, double max,
Function<PROPERTY, E> exceptionCreator) {
withRule(value -> ((double) value >= min && (double) value < max), exceptionCreator);
return this;
}
// ================================
// ====== Collection, String ======
// ================================
// ====== notEmpty =====
public ValueValidator<DTO, PROPERTY> notEmpty(String errMsg) {
return notEmpty(convertExceptionCreator(errMsg));
}
public <E extends RuntimeException> ValueValidator<DTO, PROPERTY> notEmpty(Supplier<E> exceptionCreator) {
return notEmpty(convertExceptionCreator(exceptionCreator));
}
public <E extends RuntimeException> ValueValidator<DTO, PROPERTY> notEmpty(Function<PROPERTY, E> exceptionCreator) {
withRule(value -> {
if (value == null) {
return false;
}
if (value instanceof Collection) {
return !((Collection<?>) value).isEmpty();
}
if (value instanceof String) {
return !((String) value).isEmpty();
}
return false;
}, exceptionCreator);
return this;
}
// ====== isEmpty =====
public ValueValidator<DTO, PROPERTY> isEmpty(String errMsg) {
return isEmpty(convertExceptionCreator(errMsg));
}
public <E extends RuntimeException> ValueValidator<DTO, PROPERTY> isEmpty(Supplier<E> exceptionCreator) {
return isEmpty(convertExceptionCreator(exceptionCreator));
}
public <E extends RuntimeException> ValueValidator<DTO, PROPERTY> isEmpty(Function<PROPERTY, E> exceptionCreator) {
withRule(value -> {
if (value == null) {
return false;
}
if (value instanceof Collection) {
return ((Collection<?>) value).isEmpty();
}
if (value instanceof String) {
return ((String) value).isEmpty();
}
return false;
}, exceptionCreator);
return this;
}
// =====================
// ====== boolean ======
// =====================
// ====== isTrue ======
public ValueValidator<DTO, PROPERTY> isTrue() {
return isTrue("The value must be true.");
}
public ValueValidator<DTO, PROPERTY> isTrue(String errMsg) {
return isTrue(convertExceptionCreator(errMsg));
}
public <E extends RuntimeException> ValueValidator<DTO, PROPERTY> isTrue(Supplier<E> exceptionCreator) {
return isTrue(convertExceptionCreator(exceptionCreator));
}
public <E extends RuntimeException> ValueValidator<DTO, PROPERTY> isTrue(Function<PROPERTY, E> exceptionCreator) {
withRule(Boolean.TRUE::equals, exceptionCreator);
return this;
}
// ====== isFalse ======
public ValueValidator<DTO, PROPERTY> isFalse() {
return isFalse("The value must be false.");
}
public ValueValidator<DTO, PROPERTY> isFalse(String errMsg) {
return isFalse(convertExceptionCreator(errMsg));
}
public <E extends RuntimeException> ValueValidator<DTO, PROPERTY> isFalse(Supplier<E> exceptionCreator) {
return isFalse(convertExceptionCreator(exceptionCreator));
}
public <E extends RuntimeException> ValueValidator<DTO, PROPERTY> isFalse(Function<PROPERTY, E> exceptionCreator) {
withRule(Boolean.FALSE::equals, exceptionCreator);
return this;
}
// ====================
// ====== String ======
// ====================
// ===== matches =====
public ValueValidator<DTO, PROPERTY> matches(String regex, String errMsg) {
return matches(regex, convertExceptionCreator(errMsg));
}
public <E extends RuntimeException> ValueValidator<DTO, PROPERTY> matches(
String regex,
Supplier<E> exceptionCreator) {
return matches(regex, convertExceptionCreator(exceptionCreator));
}
public <E extends RuntimeException> ValueValidator<DTO, PROPERTY> matches(
String regex,
Function<PROPERTY, E> exceptionCreator) {
withRule(input -> RegexUtil.matches((String) input, regex), exceptionCreator);
return this;
}
// ===== matchesOr =====
public ValueValidator<DTO, PROPERTY> matchesOr(String[] regexs, String errMsg) {
return matchesOr(regexs, convertExceptionCreator(errMsg));
}
public <E extends RuntimeException> ValueValidator<DTO, PROPERTY> matchesOr(
String[] regexs,
Supplier<E> exceptionCreator) {
return matchesOr(regexs, convertExceptionCreator(exceptionCreator));
}
public <E extends RuntimeException> ValueValidator<DTO, PROPERTY> matchesOr(
String[] regexs,
Function<PROPERTY, E> exceptionCreator) {
withRule(input -> RegexUtil.matchesOr((String) input, regexs), exceptionCreator);
return this;
}
// ===== matchesAnd =====
public ValueValidator<DTO, PROPERTY> matchesAnd(String[] regexs, String errMsg) {
return matchesAnd(regexs, convertExceptionCreator(errMsg));
}
public <E extends RuntimeException> ValueValidator<DTO, PROPERTY> matchesAnd(
String[] regexs,
Supplier<E> exceptionCreator) {
return matchesAnd(regexs, convertExceptionCreator(exceptionCreator));
}
public <E extends RuntimeException> ValueValidator<DTO, PROPERTY> matchesAnd(
String[] regexs,
Function<PROPERTY, E> exceptionCreator) {
withRule(input -> RegexUtil.matchesAnd((String) input, regexs), exceptionCreator);
return this;
}
// ===== notBlank =====
public ValueValidator<DTO, PROPERTY> notBlank() {
return notBlank("This String argument must have text; it must not be null, empty, or blank");
}
public ValueValidator<DTO, PROPERTY> notBlank(String errMsg) {
return notBlank(convertExceptionCreator(errMsg));
}
public <E extends RuntimeException> ValueValidator<DTO, PROPERTY> notBlank(Supplier<E> exceptionCreator) {
return notBlank(convertExceptionCreator(exceptionCreator));
}
public <E extends RuntimeException> ValueValidator<DTO, PROPERTY> notBlank(Function<PROPERTY, E> exceptionCreator) {
withRule(input -> StrUtil.isNotBlank((String) input), exceptionCreator);
return this;
}
// ===== email =====
public ValueValidator<DTO, PROPERTY> email() {
return email("The value is not an email address.");
}
public ValueValidator<DTO, PROPERTY> email(String errMsg) {
return email(convertExceptionCreator(errMsg));
}
public <E extends RuntimeException> ValueValidator<DTO, PROPERTY> email(Supplier<E> exceptionCreator) {
return email(convertExceptionCreator(exceptionCreator));
}
public <E extends RuntimeException> ValueValidator<DTO, PROPERTY> email(Function<PROPERTY, E> exceptionCreator) {
return matches(RegexConsts.EMAIL, exceptionCreator);
}
// ========================================================================
void validateProperty(DTO obj) {
PROPERTY value = this.getter.apply(obj);
for (var rule : this.rules) {
rule.accept(value);
}
}
private static <V> Function<V, InvalidInputException> convertExceptionCreator(String errMsg) {
return convertExceptionCreator(errMsg);
}
private static <V, E extends RuntimeException> Function<V, E> convertExceptionCreator(
Supplier<E> exceptionSupplier) {
return value -> exceptionSupplier.get();
}
}

12
plusone-basic/plusone-basic-infrastructure/src/test/java/xyz/zhouxy/plusone/validator/BaseValidator2Test.java → plusone-basic/plusone-basic-infrastructure/src/test/java/xyz/zhouxy/plusone/validatortest/BaseValidator2Test.java
View File

@ -1,4 +1,4 @@
package xyz.zhouxy.plusone.validator;
package xyz.zhouxy.plusone.validatortest;
import org.junit.jupiter.api.Test;
@ -6,12 +6,13 @@ import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import xyz.zhouxy.plusone.constant.RegexConsts;
import xyz.zhouxy.plusone.validator.validator2.BaseValidator2;
class BaseValidator2Test {
@Test
void testValid() {
LoginCommand loginCommand = new LoginCommand("13169053215@qq.com", "8GouTDE53a", false);
LoginCommand loginCommand = new LoginCommand("13169053215@qq.com", "A1qZ6c-cQ78=^(", false);
LoginCommandValidator.INSTANCE.validate(loginCommand);
System.err.println(loginCommand);
}
@ -32,10 +33,11 @@ class LoginCommandValidator extends BaseValidator2<LoginCommand> {
private LoginCommandValidator() {
ruleFor(loginCommand -> loginCommand.getAccount())
.nonNull("邮箱地址不能为空")
.matchesOr(new String[] { RegexConsts.EMAIL, RegexConsts.MOBILE_PHONE }, "请输入邮箱地址或手机号");
.notNull("邮箱地址不能为空")
.matchesOr(new String[] { RegexConsts.EMAIL, RegexConsts.MOBILE_PHONE }, value -> new RuntimeException('"' + value + "\" 不是邮箱地址或手机号"));
ruleFor(loginCommand -> loginCommand.getPwd())
.nonNull("密码不能为空")
.notNull("密码不能为空")
.notEmpty("密码不能为空")
.matches(RegexConsts.PASSWORD, "密码格式错误");
}
}

4
plusone-system/plusone-system-application/src/main/java/xyz/zhouxy/plusone/system/application/service/command/validator/LoginByOtpCommandValidator.java
View File

@ -15,13 +15,13 @@ import xyz.zhouxy.plusone.validator.DtoValidator;
@DtoValidator(LoginByOtpCommand.class)
public class LoginByOtpCommandValidator extends BaseValidator<LoginByOtpCommand> {
public LoginByOtpCommandValidator() {
ruleFor(loginCommand -> {
withRule(loginCommand -> {
String principal = loginCommand.getPrincipal();
return StringUtils.hasText(principal)
&&
RegexUtil.matchesOr(principal, RegexConsts.EMAIL, RegexConsts.MOBILE_PHONE);
}, "输入邮箱地址或手机号");
ruleFor(loginCommand -> {
withRule(loginCommand -> {
String otp = loginCommand.getOtp();
return StringUtils.hasText(otp) && Pattern.matches(RegexConsts.CAPTCHA, otp);
}, "验证码不符合要求");

4
plusone-system/plusone-system-application/src/main/java/xyz/zhouxy/plusone/system/application/service/command/validator/LoginByPasswordCommandValidator.java
View File

@ -15,13 +15,13 @@ import xyz.zhouxy.plusone.validator.DtoValidator;
@DtoValidator(LoginByPasswordCommand.class)
public class LoginByPasswordCommandValidator extends BaseValidator<LoginByPasswordCommand> {
public LoginByPasswordCommandValidator() {
ruleFor(loginCommand -> {
withRule(loginCommand -> {
String principal = loginCommand.getPrincipal();
return StringUtils.hasText(principal)
&&
RegexUtil.matchesOr(principal, RegexConsts.USERNAME, RegexConsts.EMAIL, RegexConsts.MOBILE_PHONE, principal);
}, "输入用户名、邮箱地址或手机号");
ruleFor(loginCommand -> {
withRule(loginCommand -> {
String password = loginCommand.getPassword();
return StringUtils.hasText(password)
&&

2
plusone-system/plusone-system-domain/src/main/java/xyz/zhouxy/plusone/system/domain/model/account/AccountInfo.java
View File

@ -38,6 +38,6 @@ public class AccountInfo implements IValueObject {
} catch (MalformedURLException e) {
throw new IllegalArgumentException(e);
}
return new AccountInfo(Nickname.ofNullable(nickname), avatarURL, Objects.nonNull(sex) ? sex : Sex.UNSET);
return new AccountInfo(Nickname.ofNullable(nickname), avatarURL, sex);
}
}