refactor: 将核心库升级到 0.2.0-RC1 版本

colorful3 · colorful3 · commit 5048bd81b294 · 2020-07-15T10:21:45.000+08:00
diff --git a/pom.xml b/pom.xml
@@ -11,7 +11,7 @@
 
     <groupId>io.github.talelin</groupId>
     <artifactId>latticy</artifactId>
-    <version>0.1.1-RC2</version>
+    <version>0.2.0-RC1</version>
     <name>latticy</name>
     <description>Demo project for lin cms</description>
 
@@ -47,7 +47,7 @@
         <dependency>
             <groupId>io.github.talelin</groupId>
             <artifactId>lin-cms-spring-boot-starter</artifactId>
-            <version>0.1.1-RC3</version>
+            <version>0.2.0-RC1</version>
         </dependency>
 
         <dependency>
diff --git a/src/main/java/io/github/talelin/latticy/common/exception/RestExceptionHandler.java b/src/main/java/io/github/talelin/latticy/common/exception/RestExceptionHandler.java
@@ -2,9 +2,9 @@
 
 import cn.hutool.core.util.StrUtil;
 import io.github.talelin.autoconfigure.bean.Code;
+import io.github.talelin.autoconfigure.exception.HttpException;
 import io.github.talelin.latticy.common.configuration.CodeMessageConfiguration;
 import io.github.talelin.latticy.vo.UnifyResponseVO;
-import io.github.talelin.autoconfigure.exception.HttpException;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.TypeMismatchException;
 import org.springframework.beans.factory.annotation.Value;
@@ -26,6 +26,8 @@
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import javax.validation.ConstraintViolationException;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -49,19 +51,20 @@ public class RestExceptionHandler {
      * HttpException
      */
     @ExceptionHandler({HttpException.class})
-    public UnifyResponseVO processException(HttpException exception, HttpServletRequest request, HttpServletResponse response) {
-        log.error("", exception);
+    public UnifyResponseVO processException(HttpException exception, HttpServletRequest request, HttpServletResponse response) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
         UnifyResponseVO unifyResponse = new UnifyResponseVO();
         unifyResponse.setRequest(getSimpleRequest(request));
         int code = exception.getCode();
-        boolean messageOnly = exception.isMessageOnly();
+        boolean defaultMessage = exception.ifDefaultMessage();
         unifyResponse.setCode(code);
         response.setStatus(exception.getHttpCode());
         String errorMessage = CodeMessageConfiguration.getMessage(code);
-        if (StrUtil.isBlank(errorMessage) || messageOnly) {
+        if (StrUtil.isBlank(errorMessage) || !defaultMessage) {
             unifyResponse.setMessage(exception.getMessage());
+            log.error("", exception);
         } else {
             unifyResponse.setMessage(errorMessage);
+            log.error("", exception.getClass().getConstructor(int.class, String.class).newInstance(code, errorMessage));
         }
         return unifyResponse;
     }
diff --git a/src/main/java/io/github/talelin/latticy/common/interceptor/AuthorizeVerifyResolverImpl.java b/src/main/java/io/github/talelin/latticy/common/interceptor/AuthorizeVerifyResolverImpl.java
@@ -63,9 +63,9 @@ public boolean handleLogin(HttpServletRequest request, HttpServletResponse respo
         try {
             claims = jwt.decodeAccessToken(tokenStr);
         } catch (TokenExpiredException e) {
-            throw new io.github.talelin.autoconfigure.exception.TokenExpiredException(e.getMessage(), 10051);
+            throw new io.github.talelin.autoconfigure.exception.TokenExpiredException(10051);
         } catch (AlgorithmMismatchException | SignatureVerificationException | JWTDecodeException | InvalidClaimException e) {
-            throw new TokenInvalidException(e.getMessage(), 10041);
+            throw new TokenInvalidException(10041);
         }
         return getClaim(claims);
     }
@@ -83,7 +83,7 @@ public boolean handleGroup(HttpServletRequest request, HttpServletResponse respo
         List<PermissionDO> permissions = userService.getUserPermissions(userId);
         boolean matched = permissions.stream().anyMatch(it -> it.getModule().equals(module) && it.getName().equals(permission));
         if (!matched) {
-            throw new AuthenticationException("you don't have the permission to access", 10001);
+            throw new AuthenticationException(10001);
         }
         return true;
     }
@@ -93,7 +93,7 @@ public boolean handleAdmin(HttpServletRequest request, HttpServletResponse respo
         handleLogin(request, response, meta);
         UserDO user = LocalUser.getLocalUser();
         if (!verifyAdmin(user)) {
-            throw new AuthenticationException("you don't have the permission to access", 10001);
+            throw new AuthenticationException(10001);
         }
         return true;
     }
@@ -106,9 +106,9 @@ public boolean handleRefresh(HttpServletRequest request, HttpServletResponse res
         try {
             claims = jwt.decodeRefreshToken(tokenStr);
         } catch (TokenExpiredException e) {
-            throw new io.github.talelin.autoconfigure.exception.TokenExpiredException(e.getMessage(), 10051);
+            throw new io.github.talelin.autoconfigure.exception.TokenExpiredException(10051);
         } catch (AlgorithmMismatchException | SignatureVerificationException | JWTDecodeException | InvalidClaimException e) {
-            throw new TokenInvalidException(e.getMessage(), 10041);
+            throw new TokenInvalidException(10041);
         }
         return getClaim(claims);
     }
@@ -126,12 +126,12 @@ public void handleAfterCompletion(HttpServletRequest request, HttpServletRespons
 
     private boolean getClaim(Map<String, Claim> claims) {
         if (claims == null) {
-            throw new TokenInvalidException("token is invalid, can't be decode", 10041);
+            throw new TokenInvalidException(10041);
         }
         int identity = claims.get("identity").asInt();
         UserDO user = userService.getById(identity);
         if (user == null) {
-            throw new NotFoundException("user is not found", 10021);
+            throw new NotFoundException(10021);
         }
         String avatarUrl;
         if (user.getAvatar() == null) {
@@ -159,18 +159,18 @@ private String verifyHeader(HttpServletRequest request, HttpServletResponse resp
         // 处理头部header,带有access_token的可以访问
         String authorization = request.getHeader(AUTHORIZATION_HEADER);
         if (authorization == null || Strings.isBlank(authorization)) {
-            throw new AuthorizationException("authorization field is required", 10012);
+            throw new AuthorizationException(10012);
         }
         String[] splits = authorization.split(" ");
         if (splits.length != 2) {
-            throw new AuthorizationException("authorization field is invalid", 10013);
+            throw new AuthorizationException(10013);
         }
         // Bearer 字段
         String scheme = splits[0];
         // token 字段
         String tokenStr = splits[1];
         if (!Pattern.matches(BEARER_PATTERN, scheme)) {
-            throw new AuthorizationException("authorization field is invalid", 10013);
+            throw new AuthorizationException(10013);
         }
         return tokenStr;
     }
diff --git a/src/main/java/io/github/talelin/latticy/controller/cms/UserController.java b/src/main/java/io/github/talelin/latticy/controller/cms/UserController.java
@@ -73,14 +73,14 @@ public CreatedVO register(@RequestBody @Validated RegisterDTO validator) {
     public Tokens login(@RequestBody @Validated LoginDTO validator) {
         UserDO user = userService.getUserByUsername(validator.getUsername());
         if (user == null) {
-            throw new NotFoundException("user not found", 10021);
+            throw new NotFoundException(10021);
         }
         boolean valid = userIdentityService.verifyUsernamePassword(
                 user.getId(),
                 user.getUsername(),
                 validator.getPassword());
         if (!valid) {
-            throw new ParameterException("username or password is fault", 10031);
+            throw new ParameterException(10031);
         }
         return jwt.generateTokens(user.getId());
     }
diff --git a/src/main/java/io/github/talelin/latticy/controller/v1/BookController.java b/src/main/java/io/github/talelin/latticy/controller/v1/BookController.java
@@ -40,7 +40,7 @@ public class BookController {
     public BookDO getBook(@PathVariable(value = "id") @Positive(message = "{id.positive}") Integer id) {
         BookDO book = bookService.getById(id);
         if (book == null) {
-            throw new NotFoundException("book not found", 10022);
+            throw new NotFoundException(10022);
         }
         return book;
     }
@@ -70,7 +70,7 @@ public CreatedVO createBook(@RequestBody @Validated CreateOrUpdateBookDTO valida
     public UpdatedVO updateBook(@PathVariable("id") @Positive(message = "{id.positive}") Integer id, @RequestBody @Validated CreateOrUpdateBookDTO validator) {
         BookDO book = bookService.getById(id);
         if (book == null) {
-            throw new NotFoundException("book not found", 10022);
+            throw new NotFoundException(10022);
         }
         bookService.updateBook(book, validator);
         return new UpdatedVO(13);
@@ -83,7 +83,7 @@ public UpdatedVO updateBook(@PathVariable("id") @Positive(message = "{id.positiv
     public DeletedVO deleteBook(@PathVariable("id") @Positive(message = "{id.positive}") Integer id) {
         BookDO book = bookService.getById(id);
         if (book == null) {
-            throw new NotFoundException("book not found", 10022);
+            throw new NotFoundException(10022);
         }
         bookService.deleteById(book.getId());
         return new DeletedVO(14);
diff --git a/src/main/java/io/github/talelin/latticy/extension/file/LocalUploader.java b/src/main/java/io/github/talelin/latticy/extension/file/LocalUploader.java
@@ -45,7 +45,7 @@ protected boolean handleOneFile(byte[] bytes, String newFilename) {
             stream.close();
         } catch (Exception e) {
             log.error("write file to local err:", e);
-            // throw new FailedException("read file date failed", 10190);
+            // throw new FailedException(10190);
             return false;
         }
         return true;
diff --git a/src/main/java/io/github/talelin/latticy/module/file/AbstractUploader.java b/src/main/java/io/github/talelin/latticy/module/file/AbstractUploader.java
@@ -120,11 +120,11 @@ protected String getNewFilename(String ext) {
      */
     protected void checkFileMap(MultiValueMap<String, MultipartFile> fileMap) {
         if (fileMap.isEmpty()) {
-            throw new NotFoundException("file not found", 10026);
+            throw new NotFoundException(10026);
         }
         int nums = getFileProperties().getNums();
         if (fileMap.size() > nums) {
-            throw new FileTooManyException("too many files, amount of files must less than" + nums, 10180);
+            throw new FileTooManyException(10180, "too many files, amount of files must less than" + nums);
         }
     }
 
diff --git a/src/main/java/io/github/talelin/latticy/service/impl/AdminServiceImpl.java b/src/main/java/io/github/talelin/latticy/service/impl/AdminServiceImpl.java
@@ -99,7 +99,7 @@ public boolean updateUserInfo(Integer id, UpdateUserInfoDTO validator) {
         Integer rootGroupId = groupService.getParticularGroupIdByLevel(GroupLevelEnum.ROOT);
         boolean anyMatch = newGroupIds.stream().anyMatch(it -> it.equals(rootGroupId));
         if (anyMatch) {
-            throw new ForbiddenException("you can't add user to root group", 10073);
+            throw new ForbiddenException(10073);
         }
         List<Integer> existGroupIds = groupService.getUserGroupIdsByUserId(id);
         // 删除existGroupIds有，而newGroupIds没有的
@@ -141,7 +141,7 @@ public boolean updateGroup(Integer id, UpdateGroupDTO dto) {
         // bug 如果只修改info，不修改name，则name已经存在，此时不应该报错
         GroupDO exist = groupService.getById(id);
         if (exist == null) {
-            throw new NotFoundException("group not found", 10024);
+            throw new NotFoundException(10024);
         }
         if (!exist.getName().equals(dto.getName())) {
             throwGroupNameExist(dto.getName());
@@ -156,10 +156,10 @@ public boolean deleteGroup(Integer id) {
         Integer rootGroupId = groupService.getParticularGroupIdByLevel(GroupLevelEnum.ROOT);
         Integer guestGroupId = groupService.getParticularGroupIdByLevel(GroupLevelEnum.GUEST);
         if (id.equals(rootGroupId)) {
-            throw new ForbiddenException("root group can't delete", 10074);
+            throw new ForbiddenException(10074);
         }
         if (id.equals(guestGroupId)) {
-            throw new ForbiddenException("guest group can't delete", 10075);
+            throw new ForbiddenException(10075);
         }
         throwGroupNotExistById(id);
         return groupService.removeById(id);
@@ -221,21 +221,21 @@ public Map<String, List<PermissionDO>> getAllStructuralPermissions() {
     private void throwUserNotExistById(Integer id) {
         boolean exist = userService.checkUserExistById(id);
         if (!exist) {
-            throw new NotFoundException("user not found", 10021);
+            throw new NotFoundException(10021);
         }
     }
 
     private void throwGroupNotExistById(Integer id) {
         boolean exist = groupService.checkGroupExistById(id);
         if (!exist) {
-            throw new NotFoundException("group not found", 10024);
+            throw new NotFoundException(10024);
         }
     }
 
     private void throwGroupNameExist(String name) {
         boolean exist = groupService.checkGroupExistByName(name);
         if (exist) {
-            throw new ForbiddenException("group name already exist, please enter a new one", 10072);
+            throw new ForbiddenException(10072);
         }
     }
 }
diff --git a/src/main/java/io/github/talelin/latticy/service/impl/GroupServiceImpl.java b/src/main/java/io/github/talelin/latticy/service/impl/GroupServiceImpl.java
@@ -85,7 +85,7 @@ public boolean deleteUserGroupRelations(Integer userId, List<Integer> deleteIds)
             return true;
         }
         if (checkIsRootByUserId(userId)) {
-            throw new ForbiddenException("can't modify the root user's group", 10078);
+            throw new ForbiddenException(10078);
         }
         QueryWrapper<UserGroupDO> wrapper = new QueryWrapper<>();
         wrapper.lambda()
@@ -101,7 +101,7 @@ public boolean addUserGroupRelations(Integer userId, List<Integer> addIds) {
         }
         boolean ok = checkGroupExistByIds(addIds);
         if (!ok) {
-            throw new ForbiddenException("cant't add user to non-existent group", 10077);
+            throw new ForbiddenException(10077);
         }
         List<UserGroupDO> relations = addIds.stream().map(it -> new UserGroupDO(userId, it)).collect(Collectors.toList());
         return userGroupMapper.insertBatch(relations) > 0;
diff --git a/src/main/java/io/github/talelin/latticy/service/impl/UserServiceImpl.java b/src/main/java/io/github/talelin/latticy/service/impl/UserServiceImpl.java
@@ -59,12 +59,12 @@ public class UserServiceImpl extends ServiceImpl<UserMapper, UserDO> implements
     public UserDO createUser(RegisterDTO dto) {
         boolean exist = this.checkUserExistByUsername(dto.getUsername());
         if (exist) {
-            throw new ForbiddenException("username already exist, please choose a new one", 10071);
+            throw new ForbiddenException(10071);
         }
         if (StrUtil.isNotBlank(dto.getEmail())) {
             exist = this.checkUserExistByEmail(dto.getEmail());
             if (exist) {
-                throw new ForbiddenException("email already exist, please choose a new one", 10076);
+                throw new ForbiddenException(10076);
             }
         } else {
             // bug 前端如果传入的email为 "" 时，由于数据库中存在""的email，会报duplication错误
@@ -99,7 +99,7 @@ public UserDO updateUserInfo(UpdateInfoDTO dto) {
         if (StrUtil.isNotBlank(dto.getUsername())) {
             boolean exist = this.checkUserExistByUsername(dto.getUsername());
             if (exist) {
-                throw new ForbiddenException("username already exist, please choose a new one", 10071);
+                throw new ForbiddenException(10071);
             }
             user.setUsername(dto.getUsername());
             userIdentityService.changeUsername(user.getId(), dto.getUsername());
@@ -114,11 +114,11 @@ public UserDO changeUserPassword(ChangePasswordDTO dto) {
         UserDO user = LocalUser.getLocalUser();
         boolean valid = userIdentityService.verifyUsernamePassword(user.getId(), user.getUsername(), dto.getOldPassword());
         if (!valid) {
-            throw new ParameterException("password invalid, please enter correct password", 10032);
+            throw new ParameterException(10032);
         }
         valid = userIdentityService.changePassword(user.getId(), dto.getNewPassword());
         if (!valid) {
-            throw new FailedException("password change failed", 10011);
+            throw new FailedException(10011);
         }
         return user;
     }
@@ -198,7 +198,7 @@ public Integer getRootUserId() {
     private void checkGroupsExist(List<Integer> ids) {
         for (Integer id : ids) {
             if (!groupService.checkGroupExistById(id)) {
-                throw new NotFoundException("group not found，can't create user", 10023);
+                throw new NotFoundException(10023);
             }
         }
     }
@@ -207,7 +207,7 @@ private void checkGroupsValid(List<Integer> ids) {
         Integer rootGroupId = groupService.getParticularGroupIdByLevel(GroupLevelEnum.ROOT);
         boolean anyMatch = ids.stream().anyMatch(it -> it.equals(rootGroupId));
         if (anyMatch) {
-            throw new ForbiddenException("you can't add user to root group", 10073);
+            throw new ForbiddenException(10073);
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -63,9 +63,9 @@ public boolean handleLogin(HttpServletRequest request, HttpServletResponse respo`
`63`	`63`	`try {`
`64`	`64`	`claims = jwt.decodeAccessToken(tokenStr);`
`65`	`65`	`} catch (TokenExpiredException e) {`
`66`		`- throw new io.github.talelin.autoconfigure.exception.TokenExpiredException(e.getMessage(), 10051);`
	`66`	`+ throw new io.github.talelin.autoconfigure.exception.TokenExpiredException(10051);`
`67`	`67`	`} catch (AlgorithmMismatchException \| SignatureVerificationException \| JWTDecodeException \| InvalidClaimException e) {`
`68`		`- throw new TokenInvalidException(e.getMessage(), 10041);`
	`68`	`+ throw new TokenInvalidException(10041);`
`69`	`69`	`}`
`70`	`70`	`return getClaim(claims);`
`71`	`71`	`}`
`@@ -83,7 +83,7 @@ public boolean handleGroup(HttpServletRequest request, HttpServletResponse respo`
`83`	`83`	`List<PermissionDO> permissions = userService.getUserPermissions(userId);`
`84`	`84`	`boolean matched = permissions.stream().anyMatch(it -> it.getModule().equals(module) && it.getName().equals(permission));`
`85`	`85`	`if (!matched) {`
`86`		`- throw new AuthenticationException("you don't have the permission to access", 10001);`
	`86`	`+ throw new AuthenticationException(10001);`
`87`	`87`	`}`
`88`	`88`	`return true;`
`89`	`89`	`}`
`@@ -93,7 +93,7 @@ public boolean handleAdmin(HttpServletRequest request, HttpServletResponse respo`
`93`	`93`	`handleLogin(request, response, meta);`
`94`	`94`	`UserDO user = LocalUser.getLocalUser();`
`95`	`95`	`if (!verifyAdmin(user)) {`
`96`		`- throw new AuthenticationException("you don't have the permission to access", 10001);`
	`96`	`+ throw new AuthenticationException(10001);`
`97`	`97`	`}`
`98`	`98`	`return true;`
`99`	`99`	`}`
`@@ -106,9 +106,9 @@ public boolean handleRefresh(HttpServletRequest request, HttpServletResponse res`
`106`	`106`	`try {`
`107`	`107`	`claims = jwt.decodeRefreshToken(tokenStr);`
`108`	`108`	`} catch (TokenExpiredException e) {`
`109`		`- throw new io.github.talelin.autoconfigure.exception.TokenExpiredException(e.getMessage(), 10051);`
	`109`	`+ throw new io.github.talelin.autoconfigure.exception.TokenExpiredException(10051);`
`110`	`110`	`} catch (AlgorithmMismatchException \| SignatureVerificationException \| JWTDecodeException \| InvalidClaimException e) {`
`111`		`- throw new TokenInvalidException(e.getMessage(), 10041);`
	`111`	`+ throw new TokenInvalidException(10041);`
`112`	`112`	`}`
`113`	`113`	`return getClaim(claims);`
`114`	`114`	`}`
`@@ -126,12 +126,12 @@ public void handleAfterCompletion(HttpServletRequest request, HttpServletRespons`
`126`	`126`
`127`	`127`	`private boolean getClaim(Map<String, Claim> claims) {`
`128`	`128`	`if (claims == null) {`
`129`		`- throw new TokenInvalidException("token is invalid, can't be decode", 10041);`
	`129`	`+ throw new TokenInvalidException(10041);`
`130`	`130`	`}`
`131`	`131`	`int identity = claims.get("identity").asInt();`
`132`	`132`	`UserDO user = userService.getById(identity);`
`133`	`133`	`if (user == null) {`
`134`		`- throw new NotFoundException("user is not found", 10021);`
	`134`	`+ throw new NotFoundException(10021);`
`135`	`135`	`}`
`136`	`136`	`String avatarUrl;`
`137`	`137`	`if (user.getAvatar() == null) {`
`@@ -159,18 +159,18 @@ private String verifyHeader(HttpServletRequest request, HttpServletResponse resp`
`159`	`159`	`// 处理头部header,带有access_token的可以访问`
`160`	`160`	`String authorization = request.getHeader(AUTHORIZATION_HEADER);`
`161`	`161`	`if (authorization == null \|\| Strings.isBlank(authorization)) {`
`162`		`- throw new AuthorizationException("authorization field is required", 10012);`
	`162`	`+ throw new AuthorizationException(10012);`
`163`	`163`	`}`
`164`	`164`	`String[] splits = authorization.split(" ");`
`165`	`165`	`if (splits.length != 2) {`
`166`		`- throw new AuthorizationException("authorization field is invalid", 10013);`
	`166`	`+ throw new AuthorizationException(10013);`
`167`	`167`	`}`
`168`	`168`	`// Bearer 字段`
`169`	`169`	`String scheme = splits[0];`
`170`	`170`	`// token 字段`
`171`	`171`	`String tokenStr = splits[1];`
`172`	`172`	`if (!Pattern.matches(BEARER_PATTERN, scheme)) {`
`173`		`- throw new AuthorizationException("authorization field is invalid", 10013);`
	`173`	`+ throw new AuthorizationException(10013);`
`174`	`174`	`}`
`175`	`175`	`return tokenStr;`
`176`	`176`	`}`
Original file line number	Diff line number	Diff line change
`@@ -73,14 +73,14 @@ public CreatedVO register(@RequestBody @Validated RegisterDTO validator) {`
`73`	`73`	`public Tokens login(@RequestBody @Validated LoginDTO validator) {`
`74`	`74`	`UserDO user = userService.getUserByUsername(validator.getUsername());`
`75`	`75`	`if (user == null) {`
`76`		`- throw new NotFoundException("user not found", 10021);`
	`76`	`+ throw new NotFoundException(10021);`
`77`	`77`	`}`
`78`	`78`	`boolean valid = userIdentityService.verifyUsernamePassword(`
`79`	`79`	`user.getId(),`
`80`	`80`	`user.getUsername(),`
`81`	`81`	`validator.getPassword());`
`82`	`82`	`if (!valid) {`
`83`		`- throw new ParameterException("username or password is fault", 10031);`
	`83`	`+ throw new ParameterException(10031);`
`84`	`84`	`}`
`85`	`85`	`return jwt.generateTokens(user.getId());`
`86`	`86`	`}`
Original file line number	Diff line number	Diff line change
`@@ -45,7 +45,7 @@ protected boolean handleOneFile(byte[] bytes, String newFilename) {`
`45`	`45`	`stream.close();`
`46`	`46`	`} catch (Exception e) {`
`47`	`47`	`log.error("write file to local err:", e);`
`48`		`- // throw new FailedException("read file date failed", 10190);`
	`48`	`+ // throw new FailedException(10190);`
`49`	`49`	`return false;`
`50`	`50`	`}`
`51`	`51`	`return true;`
Original file line number	Diff line number	Diff line change
`@@ -120,11 +120,11 @@ protected String getNewFilename(String ext) {`
`120`	`120`	`*/`
`121`	`121`	`protected void checkFileMap(MultiValueMap<String, MultipartFile> fileMap) {`
`122`	`122`	`if (fileMap.isEmpty()) {`
`123`		`- throw new NotFoundException("file not found", 10026);`
	`123`	`+ throw new NotFoundException(10026);`
`124`	`124`	`}`
`125`	`125`	`int nums = getFileProperties().getNums();`
`126`	`126`	`if (fileMap.size() > nums) {`
`127`		`- throw new FileTooManyException("too many files, amount of files must less than" + nums, 10180);`
	`127`	`+ throw new FileTooManyException(10180, "too many files, amount of files must less than" + nums);`
`128`	`128`	`}`
`129`	`129`	`}`
`130`	`130`
Original file line number	Diff line number	Diff line change
`@@ -99,7 +99,7 @@ public boolean updateUserInfo(Integer id, UpdateUserInfoDTO validator) {`
`99`	`99`	`Integer rootGroupId = groupService.getParticularGroupIdByLevel(GroupLevelEnum.ROOT);`
`100`	`100`	`boolean anyMatch = newGroupIds.stream().anyMatch(it -> it.equals(rootGroupId));`
`101`	`101`	`if (anyMatch) {`
`102`		`- throw new ForbiddenException("you can't add user to root group", 10073);`
	`102`	`+ throw new ForbiddenException(10073);`
`103`	`103`	`}`
`104`	`104`	`List<Integer> existGroupIds = groupService.getUserGroupIdsByUserId(id);`
`105`	`105`	`// 删除existGroupIds有，而newGroupIds没有的`
`@@ -141,7 +141,7 @@ public boolean updateGroup(Integer id, UpdateGroupDTO dto) {`
`141`	`141`	`// bug 如果只修改info，不修改name，则name已经存在，此时不应该报错`
`142`	`142`	`GroupDO exist = groupService.getById(id);`
`143`	`143`	`if (exist == null) {`
`144`		`- throw new NotFoundException("group not found", 10024);`
	`144`	`+ throw new NotFoundException(10024);`
`145`	`145`	`}`
`146`	`146`	`if (!exist.getName().equals(dto.getName())) {`
`147`	`147`	`throwGroupNameExist(dto.getName());`
`@@ -156,10 +156,10 @@ public boolean deleteGroup(Integer id) {`
`156`	`156`	`Integer rootGroupId = groupService.getParticularGroupIdByLevel(GroupLevelEnum.ROOT);`
`157`	`157`	`Integer guestGroupId = groupService.getParticularGroupIdByLevel(GroupLevelEnum.GUEST);`
`158`	`158`	`if (id.equals(rootGroupId)) {`
`159`		`- throw new ForbiddenException("root group can't delete", 10074);`
	`159`	`+ throw new ForbiddenException(10074);`
`160`	`160`	`}`
`161`	`161`	`if (id.equals(guestGroupId)) {`
`162`		`- throw new ForbiddenException("guest group can't delete", 10075);`
	`162`	`+ throw new ForbiddenException(10075);`
`163`	`163`	`}`
`164`	`164`	`throwGroupNotExistById(id);`
`165`	`165`	`return groupService.removeById(id);`
`@@ -221,21 +221,21 @@ public Map<String, List<PermissionDO>> getAllStructuralPermissions() {`
`221`	`221`	`private void throwUserNotExistById(Integer id) {`
`222`	`222`	`boolean exist = userService.checkUserExistById(id);`
`223`	`223`	`if (!exist) {`
`224`		`- throw new NotFoundException("user not found", 10021);`
	`224`	`+ throw new NotFoundException(10021);`
`225`	`225`	`}`
`226`	`226`	`}`
`227`	`227`
`228`	`228`	`private void throwGroupNotExistById(Integer id) {`
`229`	`229`	`boolean exist = groupService.checkGroupExistById(id);`
`230`	`230`	`if (!exist) {`
`231`		`- throw new NotFoundException("group not found", 10024);`
	`231`	`+ throw new NotFoundException(10024);`
`232`	`232`	`}`
`233`	`233`	`}`
`234`	`234`
`235`	`235`	`private void throwGroupNameExist(String name) {`
`236`	`236`	`boolean exist = groupService.checkGroupExistByName(name);`
`237`	`237`	`if (exist) {`
`238`		`- throw new ForbiddenException("group name already exist, please enter a new one", 10072);`
	`238`	`+ throw new ForbiddenException(10072);`
`239`	`239`	`}`
`240`	`240`	`}`
`241`	`241`	`}`
Original file line number	Diff line number	Diff line change
`@@ -85,7 +85,7 @@ public boolean deleteUserGroupRelations(Integer userId, List<Integer> deleteIds)`
`85`	`85`	`return true;`
`86`	`86`	`}`
`87`	`87`	`if (checkIsRootByUserId(userId)) {`
`88`		`- throw new ForbiddenException("can't modify the root user's group", 10078);`
	`88`	`+ throw new ForbiddenException(10078);`
`89`	`89`	`}`
`90`	`90`	`QueryWrapper<UserGroupDO> wrapper = new QueryWrapper<>();`
`91`	`91`	`wrapper.lambda()`
`@@ -101,7 +101,7 @@ public boolean addUserGroupRelations(Integer userId, List<Integer> addIds) {`
`101`	`101`	`}`
`102`	`102`	`boolean ok = checkGroupExistByIds(addIds);`
`103`	`103`	`if (!ok) {`
`104`		`- throw new ForbiddenException("cant't add user to non-existent group", 10077);`
	`104`	`+ throw new ForbiddenException(10077);`
`105`	`105`	`}`
`106`	`106`	`List<UserGroupDO> relations = addIds.stream().map(it -> new UserGroupDO(userId, it)).collect(Collectors.toList());`
`107`	`107`	`return userGroupMapper.insertBatch(relations) > 0;`
Original file line number	Diff line number	Diff line change
`@@ -59,12 +59,12 @@ public class UserServiceImpl extends ServiceImpl<UserMapper, UserDO> implements`
`59`	`59`	`public UserDO createUser(RegisterDTO dto) {`
`60`	`60`	`boolean exist = this.checkUserExistByUsername(dto.getUsername());`
`61`	`61`	`if (exist) {`
`62`		`- throw new ForbiddenException("username already exist, please choose a new one", 10071);`
	`62`	`+ throw new ForbiddenException(10071);`
`63`	`63`	`}`
`64`	`64`	`if (StrUtil.isNotBlank(dto.getEmail())) {`
`65`	`65`	`exist = this.checkUserExistByEmail(dto.getEmail());`
`66`	`66`	`if (exist) {`
`67`		`- throw new ForbiddenException("email already exist, please choose a new one", 10076);`
	`67`	`+ throw new ForbiddenException(10076);`
`68`	`68`	`}`
`69`	`69`	`} else {`
`70`	`70`	`// bug 前端如果传入的email为 "" 时，由于数据库中存在""的email，会报duplication错误`
`@@ -99,7 +99,7 @@ public UserDO updateUserInfo(UpdateInfoDTO dto) {`
`99`	`99`	`if (StrUtil.isNotBlank(dto.getUsername())) {`
`100`	`100`	`boolean exist = this.checkUserExistByUsername(dto.getUsername());`
`101`	`101`	`if (exist) {`
`102`		`- throw new ForbiddenException("username already exist, please choose a new one", 10071);`
	`102`	`+ throw new ForbiddenException(10071);`
`103`	`103`	`}`
`104`	`104`	`user.setUsername(dto.getUsername());`
`105`	`105`	`userIdentityService.changeUsername(user.getId(), dto.getUsername());`
`@@ -114,11 +114,11 @@ public UserDO changeUserPassword(ChangePasswordDTO dto) {`
`114`	`114`	`UserDO user = LocalUser.getLocalUser();`
`115`	`115`	`boolean valid = userIdentityService.verifyUsernamePassword(user.getId(), user.getUsername(), dto.getOldPassword());`
`116`	`116`	`if (!valid) {`
`117`		`- throw new ParameterException("password invalid, please enter correct password", 10032);`
	`117`	`+ throw new ParameterException(10032);`
`118`	`118`	`}`
`119`	`119`	`valid = userIdentityService.changePassword(user.getId(), dto.getNewPassword());`
`120`	`120`	`if (!valid) {`
`121`		`- throw new FailedException("password change failed", 10011);`
	`121`	`+ throw new FailedException(10011);`
`122`	`122`	`}`
`123`	`123`	`return user;`
`124`	`124`	`}`
`@@ -198,7 +198,7 @@ public Integer getRootUserId() {`
`198`	`198`	`private void checkGroupsExist(List<Integer> ids) {`
`199`	`199`	`for (Integer id : ids) {`
`200`	`200`	`if (!groupService.checkGroupExistById(id)) {`
`201`		`- throw new NotFoundException("group not found，can't create user", 10023);`
	`201`	`+ throw new NotFoundException(10023);`
`202`	`202`	`}`
`203`	`203`	`}`
`204`	`204`	`}`
`@@ -207,7 +207,7 @@ private void checkGroupsValid(List<Integer> ids) {`
`207`	`207`	`Integer rootGroupId = groupService.getParticularGroupIdByLevel(GroupLevelEnum.ROOT);`
`208`	`208`	`boolean anyMatch = ids.stream().anyMatch(it -> it.equals(rootGroupId));`
`209`	`209`	`if (anyMatch) {`
`210`		`- throw new ForbiddenException("you can't add user to root group", 10073);`
	`210`	`+ throw new ForbiddenException(10073);`
`211`	`211`	`}`
`212`	`212`	`}`
`213`	`213`	`}`